playback_program_builder.h

Go to the documentation of this file.

#pragma once
 
#include <iosfwd>
#include <memory>
#include <unordered_set>
 
#include "halco/hicann-dls/vx/barrier.h"
#include "haldls/vx/barrier.h"
#include "haldls/vx/common.h"
#include "hate/visibility.h"
#include "hxcomm/vx/target.h"
#include "stadls/vx/dumper.h"
#include "stadls/vx/genpybind.h"
#include "stadls/vx/playback_program.h"
 
// clang-format off
#if defined(__GENPYBIND__) or defined(__GENPYBIND_GENERATED__)
#include "haldls/vx/pickle.h"
#endif
 
#ifdef __GENPYBIND_GENERATED__
#include "fisch/vx/playback_program_builder.h"
#endif
// clang-format on
 
namespace fisch::vx {
class PlaybackProgramBuilder;
} // namespace fisch::vx
 
namespace stadls::vx GENPYBIND_TAG_STADLS_VX {
 
#if defined(__GENPYBIND__) or defined(__GENPYBIND_GENERATED__)
namespace v2 {
class DumperDone;
using Dumper = class stadls::vx::detail::Dumper<stadls::vx::v2::DumperDone>;
} // namespace v2
#endif
 
namespace detail {
 
template <typename, typename, template <typename> class>
class PlaybackProgramBuilderAdapterImpl;
 
template <typename, typename, template <typename> class>
class PlaybackProgramBuilderAdapter;
 
template <typename T, typename U, template <typename> class C>
std::ostream& operator<<(std::ostream& os, PlaybackProgramBuilderAdapter<T, U, C> const& builder)
    SYMBOL_VISIBLE;
 
template <
    typename BuilderStorage,
    typename DoneType,
    template <typename>
    class CoordinateToContainer>
class SYMBOL_VISIBLE PlaybackProgramBuilderAdapter
{
public:
    PlaybackProgramBuilderAdapter();
 
    PlaybackProgramBuilderAdapter(PlaybackProgramBuilderAdapter&& other);
    PlaybackProgramBuilderAdapter& operator=(PlaybackProgramBuilderAdapter&& other);
    PlaybackProgramBuilderAdapter(PlaybackProgramBuilderAdapter const&) = delete;
    ~PlaybackProgramBuilderAdapter();
 
    typedef BuilderStorage Builder;
 
    void wait_until(
        typename haldls::vx::Timer::coordinate_type const& coord, haldls::vx::Timer::Value time);
 
    void block_until(
        typename haldls::vx::Timer::coordinate_type const& coord, haldls::vx::Timer::Value time);
 
    void block_until(halco::hicann_dls::vx::BarrierOnFPGA const& coord, haldls::vx::Barrier sync);
 
    /*
     * Add instruction to block execution until configured Omnibus address has (not) defined value.
     * @param coord Coordinate for which to block
     * @param sync PollingOmnibusBlock value for which to block execution
     */
    void block_until(
        halco::hicann_dls::vx::PollingOmnibusBlockOnFPGA const& coord,
        haldls::vx::PollingOmnibusBlock sync);
 
    template <typename Type>
    void write(
        typename Type::coordinate_type const& coord,
        Type const& config,
        haldls::vx::Backend backend);
 
    template <typename Type>
    void write(typename Type::coordinate_type const& coord, Type const& config);
 
    template <typename Type>
    void write(
        typename Type::coordinate_type const& coord,
        Type const& config,
        Type const& config_reference,
        haldls::vx::Backend backend);
 
    template <typename Type>
    void write(
        typename Type::coordinate_type const& coord,
        Type const& config,
        Type const& config_reference);
 
    template <typename CoordinateType>
    PlaybackProgram::ContainerTicket<typename CoordinateToContainer<CoordinateType>::type> read(
        CoordinateType const& coord, haldls::vx::Backend backend);
 
    template <typename CoordinateType>
    PlaybackProgram::ContainerTicket<typename CoordinateToContainer<CoordinateType>::type> read(
        CoordinateType const& coord);
 
    void merge_back(PlaybackProgramBuilderAdapter& other);
 
    void merge_back(PlaybackProgramBuilderAdapter&& other) GENPYBIND(hidden);
 
    void merge_back(BuilderStorage& other);
 
    void merge_back(BuilderStorage&& other) GENPYBIND(hidden);
 
    void copy_back(PlaybackProgramBuilderAdapter const& other);
 
    void copy_back(BuilderStorage const& other);
 
    DoneType done();
 
    template <typename T, typename U, template <typename> class C>
    friend std::ostream& operator<<(
        std::ostream& os, PlaybackProgramBuilderAdapter<T, U, C> const& builder);
 
    GENPYBIND_MANUAL({
        parent.def("__repr__", [](GENPYBIND_PARENT_TYPE const& p) {
            std::stringstream ss;
            typedef hate::type_list<::stadls::vx::v2::Dumper> dumper_types;
            if constexpr (hate::is_in_type_list<
                              typename std::decay<decltype(p)>::type::Builder,
                              dumper_types>::value) {
                ss << "PlaybackProgramBuilderDumper()";
            } else {
                ss << "PlaybackProgramBuilder(to FPGA size: " << p.size_to_fpga()
                   << ", is write only: " << std::boolalpha << p.is_write_only() << ")";
            }
            return ss.str();
        });
        parent.def("__str__", [](GENPYBIND_PARENT_TYPE const& p) {
            std::stringstream ss;
            ss << p;
            return ss.str();
        });
    })
 
    bool empty() const;
 
    size_t size_to_fpga() const;
 
    bool is_write_only() const;
 
private:
    using Impl =
        detail::PlaybackProgramBuilderAdapterImpl<BuilderStorage, DoneType, CoordinateToContainer>;
    friend Impl;
 
    friend class cereal::access;
    template <class Archive>
    void serialize(Archive& ar, std::uint32_t const version);
 
    std::unique_ptr<BuilderStorage> m_builder_impl;
 
    std::unordered_set<hxcomm::vx::Target> m_unsupported_targets;
};
 
} // namespace detail
 
} // namespace stadls::vx