API Reference: stadls

template<typename ContainerT, typename = void>
struct container_supports_empty_coordinate : public std::true_type
#include <supports_empty.h>
template<typename ContainerT>
struct container_supports_empty_coordinate<ContainerT, typename boost::enable_if_has_type<typename ContainerT::supports_empty_coordinate>::type> : public ContainerT::supports_empty_coordinate
#include <supports_empty.h>
class stadls::vx::ContainerTicket
#include <container_ticket.h>

Ticket for to-be-available container data corresponding to a read instruction.

Public Types

std::variant<#define PLAYBACK_CONTAINER(Name, Type) #define LAST_PLAYBACK_CONTAINER(Name, Type) > ticket_impl_type

Public Functions

haldls::vx::Container const & get () const SYMBOL_VISIBLE

Get container data if available.

Returns constant reference to owned container instance.

Throws

std::runtime_error – On container data not available yet

Returns

Container data

template<typename CoordinateT>
struct stadls::vx::v3::CoordinateToContainer
#include <coordinate_to_container.h>

Given a coordinate type, resolves the corresponding unique container type.

tparam CoordinateT

Coordinate type to resolve container type for

Public Types

typedef hate::index_type_list_by_integer<hate::index_type_list_by_type<CoordinateT, coordinate_list>::value, container_list>::type type
template<typename T>
class stadls::DecodeVisitor
#include <visitors.h>

Fill the visited containers by decoding the specified configuration data.

Each container should implement a decode member function that accepts an array of words read from the hardware. The first argument to the function can optionally be the coordinate of the container, should it be required to correctly decode the data. Containers that do not themselves contain data (i.e. containers of containers) can alternatively be tagged via 

typedef std::false_type has_local_data;
See

ReadAddressVisitor, which is used to extract the addresses to read the configuration data from.

Public Functions

inline DecodeVisitor(T data)
template<typename CoordinateT, typename ContainerT>
inline void operator()(CoordinateT const &coordinate, ContainerT &config)

Private Types

typedef T::value_type value_type

Private Functions

template<typename CoordinateT, typename ContainerT, typename DecodeContainerT, size_t N>
inline void decode(CoordinateT const&, ContainerT &container, void (DecodeContainerT::* decode)(std::array<value_type, N> const&))
template<typename CoordinateT, typename ContainerT, typename DecodeContainerT, size_t N>
inline void decode(CoordinateT const &coordinate, ContainerT &container, void (DecodeContainerT::* decode)(CoordinateT const&, std::array<value_type, N> const&))
template<typename CoordinateT, typename ContainerT>
inline auto impl(CoordinateT const&, ContainerT const&) -> typename std::enable_if<!ContainerT::has_local_data::value>::type
template<typename CoordinateT, typename ContainerT>
inline auto impl(CoordinateT const &coordinate, ContainerT &container) -> decltype(&ContainerT::decode, void())
template<typename CoordinateT, typename ContainerT>
inline auto impl(CoordinateT const &coordinate, ContainerT &container) -> decltype(&ContainerT::template decode<value_type>, void())
inline size_t remaining() const
template<size_t N>
inline auto slice() -> std::array<value_type, N>

Private Members

T m_data
T::const_iterator m_it
class stadls::vx::v3::DigitalInit : public stadls::vx::v3::detail::InitGenerator
#include <init_generator.h>

Generator for initialization of the chip up to digital communication.

Uses the default InitGenerator() to establish digital communication to the chip.

Public Types

typedef halco::common::typed_array<haldls::vx::ADPLL, halco::hicann_dls::vx::v3::ADPLLOnDLS> adplls_type

ADPLL setting.

typedef v3::PlaybackProgramBuilder Builder

Builder typedef (e.g.

for usage in generators).

typedef halco::common::typed_array<haldls::vx::v3::CapMemBlockConfig, halco::hicann_dls::vx::v3::CapMemBlockConfigOnDLS> capmem_block_config_type

Initialize the CapMem with usable default values.

typedef halco::common::typed_array<haldls::vx::v3::CapMemBlock, halco::hicann_dls::vx::v3::CapMemBlockOnDLS> capmem_block_type

Set initial CapMem config.

By default, a value of zero is written to all cells.

typedef hate::Nil Result

Public Functions

DigitalInit () SYMBOL_VISIBLE

Default constructor.

Public Members

adplls_type adplls
capmem_block_config_type capmem_block_config
capmem_block_type capmem_config
lola::vx::DACChannelBlock dac_channel_block

DAC channel configs on xBoard.

lola::vx::DACControlBlock dac_control_block

DAC control config on xBoard.

bool enable_capmem

Select whether the CapMem should be enabled.

Note

The CapMem initialization requires highspeed access.

bool enable_highspeed_link

Enable Highspeed connection.

Note

Disabling this discards all highspeed related configuration.

bool enable_xboard

Enable xBoard DAC and shift register configuration.

Disabling this allows to discard unnecessary configuration when simulating.

Note

Disabling this discards all xBoard configuration

haldls::vx::EventRecordingConfig event_recording

Event recording config, defaults to active recording.

struct stadls::vx::v3::detail::InitGenerator::HighspeedLink highspeed_link
haldls::vx::InstructionTimeoutConfig instruction_timeout

Instruction timeout duration on FPGA config.

haldls::vx::JTAGClockScaler jtag_clock_scaler

JTAG clock scaler setting.

lola::vx::v3::MemoryTiming memory_timing

Memory timing settings.

haldls::vx::v3::PLLClockOutputBlock pll_clock_output_block

PLL clock output block setting.

haldls::vx::v3::ReferenceGeneratorConfig reference_generator_config

Generate usable reference current for the CapMem.

haldls::vx::ShiftRegister shift_register

Shift register on xBoard config.

haldls::vx::SynapseBiasSelection synapse_bias_selection

Select internal bias currents for synapses.

Protected Functions

PlaybackGeneratorReturn< Result > generate () const SYMBOL_VISIBLE

Generate PlaybackProgramBuilder.

Returns

PlaybackGeneratorReturn instance with sequence embodied and specified Result value

Friends

friend auto generate(DigitalInit const&)
struct stadls::vx::detail::DummyVisitor
#include <supports_empty.h>

Public Functions

template<typename ContainerT, typename CoordinateT>
inline void operator()(CoordinateT const&, ContainerT const&)
template<typename DoneType>
class stadls::vx::detail::Dumper
#include <dumper.h>

Dumper implements an interface derived from fisch::vx::PlaybackProgramBuilder.

However, it does work on haldls container/halco coordinate pairs instead of fisch containers. Reads are not supported as there is currently no application; writes are collected into a std container holding coordinate/container pairs. The std container is returned by done().

Public Types

typedef DoneType done_type

Public Functions

Dumper() = default

Default constructor.

Dumper(Dumper&&) = default

Move constructor.

Dumper(Dumper const&) = delete

Copy constructor forbidden.

~Dumper() = default

Destructor.

void block_until(haldls::vx::BlockUntil::Coordinate const &coord, haldls::vx::BlockUntil const &condition)

Add instruction to block execution until specified condition is satisfied.

Parameters

  • coord – Coordinate for which to block

  • condition – Condition to block execution for until satisfaction

void copy_back(Dumper const &other)

Copy other Dumper to the end of this instance.

The copied-from builder is untouched during the process.

Throws

std::runtime_error – On other builder not being write only

Parameters

other – Builder to copy to this instance at the back

done_type done()

Return ordered list of write coordinate-container pairs.

Returns

Ordered list of writes of coordinate-container pairs.

bool empty() const

Get whether builder is empty, i.e.

no instructions are embodied.

Returns

Boolean value

void merge_back(Dumper &other)

Merge other Dumper to the end of this instance.

The moved-from builder is emptied during the process.

Parameters

other – Builder to move to this instance at the back

void merge_front(Dumper &other)

Merge other PlaybackProgramBuilder to the beginning of this builder instance.

The moved-from builder is emptied during the process.

Parameters

other – Builder to move to this instance at the front

Dumper &operator=(Dumper&&) = default

Move assignment operator.

Dumper &operator=(Dumper const&) = delete

Copy assignment forbidden.

ContainerTicket read(haldls::vx::Container::Coordinate const &coord)

We do not support read and throw at runtime.

void write(haldls::vx::Container::Coordinate const &coord, haldls::vx::Container const &config)

Add write instruction for container.

Parameters

  • coord – Container coordinate

  • config – Container data

Private Functions

template<class Archive, typename T>
friend void serialize(Archive &ar, Dumper<T> &value, std::uint32_t const version)

Private Members

done_type m_dumpit

Friends

template<typename T>
friend std::ostream &operator<<(std::ostream &os, Dumper<T> const &builder)

Print coordinate/container pairs added until now.

Returns

Altered ostream

struct stadls::vx::v3::DumperDone
#include <dumperdone.h>

Public Types

typedef std::pair<std::unique_ptr<haldls::vx::Encodable::Coordinate>, std::unique_ptr<haldls::vx::Encodable>> coco_type

Variant over all coordinate/container pairs.

typedef std::vector<coco_type> values_type

Public Functions

DumperDone() = default
DumperDone(DumperDone&&) = default
DumperDone(DumperDone const&) = delete
parent def_property ("values", get_values, set_values)
inline  for (auto const &value :self.values)
DumperDone &operator=(DumperDone&&) = default
DumperDone &operator=(DumperDone const&) = delete

Public Members

return ret
auto const set_values = [parent](                               GENPYBIND_PARENT_TYPE& self, pybind11::list const& new_values) { stadls::vx::v3::DumperDone::values_type tmp_values; for (auto const& value : new_values) { if (!py::isinstance<py::tuple>(value)) { throw std::runtime_error("Expected tuple."); } auto const* const coord =         py::cast<halco::common::Coordinate const*>(py::cast<py::tuple>(value)[0]); auto const* const config =         py::cast<haldls::vx::Encodable const*>(py::cast<py::tuple>(value)[1]); if (coord == nullptr || config == nullptr) { throw py::cast_error("Casted to nullptr."); } tmp_values.push_back(std::make_pair(coord->clone(), config->clone_encodable())); } self.values = std::move(tmp_values); }
values_type values
template<typename T>
class stadls::EncodeVisitor
#include <visitors.h>

Extract hardware configuration data for the visited containers.

Each container should implement an encode member function that returns an array of words to be written to the hardware. The first argument to the function can optionally be the coordinate of the container, should it be required to correctly encode the data. Containers that do not themselves contain data (i.e. containers of containers) can alternatively be tagged via 

typedef std::false_type has_local_data;
See

WriteAddressVisitor, which is used to extract the addresses to write the configuration data to.

Public Functions

inline EncodeVisitor(T &data)
template<typename CoordinateT, typename ContainerT>
inline void operator()(CoordinateT const &coordinate, ContainerT &config)

Private Types

typedef T::value_type value_type

Private Functions

template<typename CoordinateT, typename ContainerT, typename EncodeContainerT, size_t N>
inline void encode(CoordinateT const&, ContainerT const &container, std::array<value_type, N> (EncodeContainerT::* encode)() const)
template<typename CoordinateT, typename ContainerT, typename EncodeContainerT, size_t N>
inline void encode(CoordinateT const &coordinate, ContainerT const &container, std::array<value_type, N> (EncodeContainerT::* encode)(CoordinateT const&) const)
template<typename CoordinateT, typename ContainerT>
inline auto impl(CoordinateT const&, ContainerT const&) -> typename std::enable_if<!ContainerT::has_local_data::value>::type
template<typename CoordinateT, typename ContainerT>
inline auto impl(CoordinateT const &coordinate, ContainerT const &container) -> decltype(&ContainerT::encode, void())
template<typename CoordinateT, typename ContainerT>
inline auto impl(CoordinateT const &coordinate, ContainerT const &container) -> decltype(&ContainerT::template encode<value_type>, void())

Private Members

T &m_data
class stadls::vx::v3::ExperimentInit : public stadls::vx::v3::detail::InitGenerator
#include <init_generator.h>

Generator for initialization required for typical experiments.

Uses the InitGenerator() to establish digital communication to the chip, and further initializes the CapMem in a working state and selects internal bias currents for synapses.

Public Types

typedef halco::common::typed_array<haldls::vx::ADPLL, halco::hicann_dls::vx::v3::ADPLLOnDLS> adplls_type

ADPLL setting.

typedef PlaybackProgramBuilder Builder

Builder typedef (e.g.

for usage in generators).

typedef halco::common::typed_array<haldls::vx::v3::CapMemBlockConfig, halco::hicann_dls::vx::v3::CapMemBlockConfigOnDLS> capmem_block_config_type

Initialize the CapMem with usable default values.

typedef halco::common::typed_array<haldls::vx::v3::CapMemBlock, halco::hicann_dls::vx::v3::CapMemBlockOnDLS> capmem_block_type

Set initial CapMem config.

By default, a value of zero is written to all cells.

typedef halco::common::typed_array<haldls::vx::v3::ColumnCorrelationQuad, halco::hicann_dls::vx::v3::ColumnCorrelationQuadOnDLS> column_correlation_quad_type

Set ColumnCorrelationQuad/Switch connections.

typedef halco::common::typed_array<haldls::vx::v3::ColumnCurrentQuad, halco::hicann_dls::vx::v3::ColumnCurrentQuadOnDLS> column_current_quad_type

Set ColumnCurrentQuad/Switch connections.

typedef halco::common::typed_array<haldls::vx::v3::CommonCorrelationConfig, halco::hicann_dls::vx::v3::CommonCorrelationConfigOnDLS> common_correlation_config_type

Set common correlation config.

typedef halco::common::typed_array<haldls::vx::CommonNeuronBackendConfig, halco::hicann_dls::vx::v3::CommonNeuronBackendConfigOnDLS> common_neuron_backend_config_type

Set common neuron backend with clocks enabled.

If clocks are disabled, it may behave strangely.

typedef detail::InitGenerator::Result Result

Public Functions

ExperimentInit () SYMBOL_VISIBLE

Default constructor.

Public Members

adplls_type adplls
capmem_block_config_type capmem_block_config
capmem_block_type capmem_config
column_correlation_quad_type column_correlation_quad_config
column_current_quad_type column_current_quad_config
common_correlation_config_type common_correlation_config
common_neuron_backend_config_type common_neuron_backend_config
lola::vx::DACChannelBlock dac_channel_block

DAC channel configs on xBoard.

lola::vx::DACControlBlock dac_control_block

DAC control config on xBoard.

bool enable_capmem

Select whether the CapMem should be enabled.

Note

The CapMem initialization requires highspeed access.

bool enable_highspeed_link

Enable Highspeed connection.

Note

Disabling this discards all highspeed related configuration.

bool enable_xboard

Enable xBoard DAC and shift register configuration.

Disabling this allows to discard unnecessary configuration when simulating.

Note

Disabling this discards all xBoard configuration

haldls::vx::EventRecordingConfig event_recording

Event recording config, defaults to active recording.

struct stadls::vx::v3::detail::InitGenerator::HighspeedLink highspeed_link
haldls::vx::InstructionTimeoutConfig instruction_timeout

Instruction timeout duration on FPGA config.

haldls::vx::JTAGClockScaler jtag_clock_scaler

JTAG clock scaler setting.

lola::vx::v3::MemoryTiming memory_timing

Memory timing settings.

haldls::vx::v3::PLLClockOutputBlock pll_clock_output_block

PLL clock output block setting.

haldls::vx::v3::ReferenceGeneratorConfig reference_generator_config

Generate usable reference current for the CapMem.

haldls::vx::ShiftRegister shift_register

Shift register on xBoard config.

haldls::vx::SynapseBiasSelection synapse_bias_selection

Select internal bias currents for synapses.

Private Functions

PlaybackGeneratorReturn< Result > generate () const SYMBOL_VISIBLE

Generate PlaybackProgramBuilder.

Returns

PlaybackGeneratorReturn instance with sequence embodied and specified Result value

Friends

friend auto generate(ExperimentInit const&)
struct stadls::vx::v3::detail::InitGenerator::HighspeedLink
#include <init_generator.h>

Public Types

typedef halco::common::typed_array<haldls::vx::PhyConfigChip, halco::hicann_dls::vx::v3::PhyConfigChipOnDLS> phy_configs_chip_type

Highspeed-link PHY settings for the chip side.

typedef halco::common::typed_array<haldls::vx::PhyConfigFPGA, halco::hicann_dls::vx::v3::PhyConfigFPGAOnDLS> phy_configs_fpga_type

Highspeed-link PHY settings for the FPGA side.

Public Functions

HighspeedLink () SYMBOL_VISIBLE

Default constructor.

Public Members

haldls::vx::CommonPhyConfigChip common_phy_config_chip

Highspeed-link PHY enable values for the chip side.

haldls::vx::CommonPhyConfigFPGA common_phy_config_fpga

Highspeed-link PHY enable values for the FPGA side.

bool enable_systime

Enable systime synchronization.

Note

Disabling this discards all systime related configuration, i.e. setting the SystimeSyncBase and initiating the time hand-shake between the chip and the FPGA. This leads to no time annotation being present in the response stream.

phy_configs_chip_type phy_configs_chip
phy_configs_fpga_type phy_configs_fpga
haldls::vx::SystimeSyncBase systime_sync_base

Systime synchronization base value.

class stadls::vx::v3::detail::InitGenerator
#include <init_generator.h>

Subclassed by stadls::vx::v3::DigitalInit, stadls::vx::v3::ExperimentInit

Public Types

typedef halco::common::typed_array<haldls::vx::ADPLL, halco::hicann_dls::vx::v3::ADPLLOnDLS> adplls_type

ADPLL setting.

typedef v3::PlaybackProgramBuilder Builder

Builder typedef (e.g.

for usage in generators).

typedef halco::common::typed_array<haldls::vx::v3::CapMemBlockConfig, halco::hicann_dls::vx::v3::CapMemBlockConfigOnDLS> capmem_block_config_type

Initialize the CapMem with usable default values.

typedef halco::common::typed_array<haldls::vx::v3::CapMemBlock, halco::hicann_dls::vx::v3::CapMemBlockOnDLS> capmem_block_type

Set initial CapMem config.

By default, a value of zero is written to all cells.

typedef hate::Nil Result

Public Functions

InitGenerator () SYMBOL_VISIBLE

Default constructor.

Public Members

adplls_type adplls
capmem_block_config_type capmem_block_config
capmem_block_type capmem_config
lola::vx::DACChannelBlock dac_channel_block

DAC channel configs on xBoard.

lola::vx::DACControlBlock dac_control_block

DAC control config on xBoard.

bool enable_capmem

Select whether the CapMem should be enabled.

Note

The CapMem initialization requires highspeed access.

bool enable_highspeed_link

Enable Highspeed connection.

Note

Disabling this discards all highspeed related configuration.

bool enable_xboard

Enable xBoard DAC and shift register configuration.

Disabling this allows to discard unnecessary configuration when simulating.

Note

Disabling this discards all xBoard configuration

haldls::vx::EventRecordingConfig event_recording

Event recording config, defaults to active recording.

struct stadls::vx::v3::detail::InitGenerator::HighspeedLink highspeed_link
haldls::vx::InstructionTimeoutConfig instruction_timeout

Instruction timeout duration on FPGA config.

haldls::vx::JTAGClockScaler jtag_clock_scaler

JTAG clock scaler setting.

lola::vx::v3::MemoryTiming memory_timing

Memory timing settings.

haldls::vx::v3::PLLClockOutputBlock pll_clock_output_block

PLL clock output block setting.

haldls::vx::v3::ReferenceGeneratorConfig reference_generator_config

Generate usable reference current for the CapMem.

haldls::vx::ShiftRegister shift_register

Shift register on xBoard config.

haldls::vx::SynapseBiasSelection synapse_bias_selection

Select internal bias currents for synapses.

Protected Functions

PlaybackGeneratorReturn< Result > generate () const SYMBOL_VISIBLE

Generate PlaybackProgramBuilder.

Returns

PlaybackGeneratorReturn instance with sequence embodied and specified Result value

Friends

friend std::ostream & operator<< (std::ostream &os, InitGenerator const &sequence) SYMBOL_VISIBLE
friend auto generate(InitGenerator const&)
template<typename Builder, typename Result>
struct stadls::vx::PlaybackGeneratorReturn
#include <playback_generator.h>

Return type of generate() call on playback sequence.

Allows named access to generated PlaybackProgramBuilder and to be specified Result value.

tparam Result

Result data structure, e.g. read-ticket data

Public Members

Builder builder
Result result
class stadls::vx::PlaybackProgram
#include <playback_program.h>

Sequential stream of executable instructions for the executor and result-container for event response data during execution.Get MADC samples as 2D matrix, i.e.

numpy array(s).

Note

We expose the data as a flat numpy DTYPE with the same data layout as the underlying MADCSampleFromChipDType type.

Public Types

typedef ::stadls::vx::PlaybackProgram::spikes_type _values_type

  • This version exposes with 3 columns: * chip time, neuron label, and spl1 address

typedef std::vector<haldls::vx::HighspeedLinkNotification> highspeed_link_notifications_type
typedef fisch::vx::PlaybackProgram::madc_sample_pack_counts_type madc_sample_pack_counts_type
typedef std::vector<haldls::vx::MADCSampleFromChip> madc_samples_type
typedef fisch::vx::PlaybackProgram::spike_pack_counts_type spike_pack_counts_type
typedef std::vector<haldls::vx::SpikeFromChip> spikes_type

Public Functions

PlaybackProgram () SYMBOL_VISIBLE

Default constructor.

attr attr ("to_numpy")
bool empty () const SYMBOL_VISIBLE

Get whether program is empty, i.e.

does not feature any commands to be sent.

Returns

Boolean value

highspeed_link_notifications_type get_highspeed_link_notifications () const SYMBOL_VISIBLE

Get vector of time-annotated highspeed-link notifications.

Returns

Vector of notifications

madc_samples_type get_madc_samples () const SYMBOL_VISIBLE

Get vector of time-annotated MADC sample events.

Returns

Vector of sample events

madc_sample_pack_counts_type const & get_madc_samples_pack_counts () const SYMBOL_VISIBLE

Get number of occurences of MADC sample packing from chip.

Returns

Array of packing occurences

spikes_type get_spikes () const SYMBOL_VISIBLE

Get vector of time-annotated spike events.

Returns

Vector of spike events

spike_pack_counts_type const & get_spikes_pack_counts () const SYMBOL_VISIBLE

Get number of occurences of spike packing from chip.

Returns

Array of packing occurences

std::unordered_set< hxcomm::vx::Target > const & get_unsupported_targets () const SYMBOL_VISIBLE

Get set of unsupported targets.

Returns

Set of target restictions

bool operator!= (PlaybackProgram const &other) const SYMBOL_VISIBLE
bool operator== (PlaybackProgram const &other) const SYMBOL_VISIBLE
pybind11::bind_vector (parent, "spikes_type")

Get spikes as 2D matrix, i.e.

numpy array(s).

Note

We expose the data as a flat numpy DTYPE with the same data layout as the underlying SpikeFromChipDType type.

Public Members

auto ism = parent->py::is_method(attr)

Friends

friend std::ostream & operator<< (std::ostream &os, PlaybackProgram const &program) SYMBOL_VISIBLE
template<typename BuilderStorage, typename DoneType>
class stadls::vx::detail::PlaybackProgramBuilderAdapter
#include <playback_program_builder.h>

Sequential PlaybackProgram builder.

Public Types

typedef BuilderStorage Builder
typedef hate::type_list<::stadls::vx::v3::Dumper> dumper_types

Public Functions

PlaybackProgramBuilderAdapter()

Construct builder.

PlaybackProgramBuilderAdapter(PlaybackProgramBuilderAdapter &&other)
PlaybackProgramBuilderAdapter(PlaybackProgramBuilderAdapter const&) = delete
~PlaybackProgramBuilderAdapter()
void block_until(haldls::vx::BlockUntil::Coordinate const &coord, haldls::vx::BlockUntil const &condition)

Add instruction to block execution until specified condition is satisfied.

Parameters

  • coord – Coordinate for which to block

  • condition – Condition to block execution for until satisfaction

inline if constexpr (hate::is_in_type_list< typename std::decay< decltype(p)>::type::Builder, dumper_types >::value)
void copy_back(BuilderStorage const &other)

Copy BuilderStorage to the end of this builder instance.

The copied-from storage is untouched during the process.

Throws

std::runtime_error – On other builder not being write only

Parameters

other – BuilderStorage to copy to this instance at the back

void copy_back(PlaybackProgramBuilderAdapter const &other)

Copy other PlaybackProgramBuilderAdapter to the end of this builder instance.

The copied-from builder is untouched during the process.

Throws

std::runtime_error – On other builder not being write only

Parameters

other – Builder to copy to this instance at the back

parent def ("__str__", [](GENPYBIND_PARENT_TYPE const &p) { std::stringstream ss;ss<< p;return ss.str();})
DoneType done()

Close PlaybackProgram build process and return executable program.

Returns

Executable PlaybackProgram

void merge_back(BuilderStorage &&other)

Merge BuilderStorage to the end of this builder instance.

The moved-from storage is emptied during the process.

Parameters

other – BuilderStorage to move to this instance at the back

void merge_back(BuilderStorage &other)

Merge BuilderStorage to the end of this builder instance.

The moved-from storage is emptied during the process.

Parameters

other – BuilderStorage to move to this instance at the back

void merge_back(PlaybackProgramBuilderAdapter &&other)

Merge other PlaybackProgramBuilderAdapter to the end of this builder instance.

The moved-from builder is emptied during the process.

Parameters

other – Builder to move to this instance at the back

void merge_back(PlaybackProgramBuilderAdapter &other)

Merge other PlaybackProgramBuilderAdapter to the end of this builder instance.

The moved-from builder is emptied during the process.

Parameters

other – Builder to move to this instance at the back

PlaybackProgramBuilderAdapter &operator=(PlaybackProgramBuilderAdapter &&other)
ContainerTicket read(haldls::vx::Container::Coordinate const &coord)

Add instructions to read container data from given location.

Parameters

coord – Coordinate value selecting location

ContainerTicket read(haldls::vx::Container::Coordinate const &coord, haldls::vx::Backend backend)

Add instructions to read container data from given location.

Parameters

  • coord – Coordinate value selecting location

  • backend – Backend selection

return ss str ()
void write(haldls::vx::Container::Coordinate const &coord, haldls::vx::Container const &config)

Add instructions to write given container to given location.

Parameters

  • coord – Coordinate value selecting location

  • config – Container configuration data

void write(haldls::vx::Container::Coordinate const &coord, haldls::vx::Container const &config, haldls::vx::Backend backend)

Add instructions to write given container to given location.

Parameters

  • coord – Coordinate value selecting location

  • config – Container configuration data

  • backend – Backend selection

void write(haldls::vx::Container::Coordinate const &coord, haldls::vx::Container const &config, haldls::vx::Container const &config_reference)

Add instructions to write given container to given location.

Parameters

  • coord – Coordinate value selecting location

  • config – Container configuration data

  • config_reference – Reference configuration for differential write

void write(haldls::vx::Container::Coordinate const &coord, haldls::vx::Container const &config, haldls::vx::Container const &config_reference, haldls::vx::Backend backend)

Add instructions to write given container to given location.

Parameters

  • coord – Coordinate value selecting location

  • config – Container configuration data

  • config_reference – Reference configuration for differential write

  • backend – Backend selection

Public Members

else   = { ss << "PlaybackProgramBuilder(to FPGA size: " << p.size_to_fpga()        << ", is write only: " << std::boolalpha << p.is_write_only() << ")"

Friends

template<typename T, typename U>
friend std::ostream &operator<<(std::ostream &os, PlaybackProgramBuilderAdapter<T, U> const &builder)
template<typename, typename>
class PlaybackProgramBuilderAdapterImpl
template<typename T>
struct stadls::ReadAddressVisitor
#include <visitors.h>

Extract addresses for reading from hardware for the visited containers.

Each container can provide addresses via a read_addresses member function or via a addresses member function in case the addresses for reading and writing are the same. Containers that do not themselves contain data to be read from the hardware (i.e. containers of containers) can alternatively be tagged via 

typedef std::false_type has_local_data;

Public Functions

template<typename CoordinateT, typename ContainerT>
inline void operator()(CoordinateT const &coord, ContainerT&)

Public Members

T &addresses

Private Functions

template<typename CoordinateT, typename ContainerT>
inline auto impl(CoordinateT const &coord) -> decltype(ContainerT::addresses(coord), void())
template<typename CoordinateT, typename ContainerT>
inline auto impl(CoordinateT const &coord) -> decltype(ContainerT::read_addresses(coord), void())
template<typename CoordinateT, typename ContainerT>
inline auto impl(CoordinateT const &coord) -> decltype(ContainerT::template addresses<typename T::value_type>(coord), void())
template<typename CoordinateT, typename ContainerT>
inline auto impl(CoordinateT const &coord) -> decltype(ContainerT::template read_addresses<typename T::value_type>(coord), void())
class stadls::vx::ReinitStackEntry
#include <reinit_stack_entry.h>

Public Functions

ReinitStackEntry() = delete
template<typename Connection>
ReinitStackEntry(Connection &connection)
ReinitStackEntry(ReinitStackEntry&&) = default
ReinitStackEntry(ReinitStackEntry const&) = delete
~ReinitStackEntry () SYMBOL_VISIBLE
void enforce () SYMBOL_VISIBLE
ReinitStackEntry &operator=(ReinitStackEntry&&) = default
void pop () SYMBOL_VISIBLE
void set (PlaybackProgram const &pbmem_request, std::optional< PlaybackProgram > const &pbmem_snapshot=std::nullopt, bool enforce=true) SYMBOL_VISIBLE

Set and maybe enforce reinit stack entry value.

Parameters

  • pbmem_request – Playback program to be executed once a reinit is required.

  • pbmem_snapshot – Playback program to be executed once the exclusive access to the hardware is relinquished. All read commands within this program are translated to writes and replace the pbmem_request for future reinit operations. This is to be used to snapshot (parts of) the current state of the hardware prior to releasing the exclusive access to other users and be able to reapply this state at the next reinit operation without need for client-side synchronisation and transform of the read-out data. Currently only Omnibus read -> write operations are supported.

  • enforce – Whether to directly apply the pbmem_request or only apply it during the next reinit.

Private Members

std::unique_ptr<Impl> m_impl
template<typename T>
struct stadls::WriteAddressVisitor
#include <visitors.h>

Extract addresses for writing to hardware for the visited containers.

Each container can provide addresses via a write_addresses member function or via a addresses member function in case the addresses for reading and writing are the same. Containers that do not themselves contain data to be written to the hardware (i.e. containers of containers) can alternatively be tagged via 

typedef std::false_type has_local_data;

Public Functions

template<typename CoordinateT, typename ContainerT>
inline void operator()(CoordinateT const &coord, ContainerT&)

Public Members

T &addresses

Private Functions

template<typename CoordinateT, typename ContainerT>
inline auto impl(CoordinateT const &coord) -> decltype(ContainerT::addresses(coord), void())
template<typename CoordinateT, typename ContainerT>
inline auto impl(CoordinateT const &coord) -> decltype(ContainerT::template addresses<typename T::value_type>(coord), void())
template<typename CoordinateT, typename ContainerT>
inline auto impl(CoordinateT const &coord) -> decltype(ContainerT::template write_addresses<typename T::value_type>(coord), void())
template<typename CoordinateT, typename ContainerT>
inline auto impl(CoordinateT const &coord) -> decltype(ContainerT::write_addresses(coord), void())
namespace cereal

Functions

template<typename Archive, typename DoneType>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, stadls::vx::detail::Dumper<DoneType> &value, std::uint32_t const version)
template<typename Archive, typename BuilderStorage, typename DoneType>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, stadls::vx::detail::PlaybackProgramBuilderAdapter<BuilderStorage, DoneType> &value, std::uint32_t const version)
template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, stadls::vx::PlaybackProgram &value, std::uint32_t const version)
template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, stadls::vx::v3::DumperDone &value, std::uint32_t const version)
namespace ContainerT
namespace fisch
namespace vx
namespace stadls
namespace stadls::vx

Typedefs

template<typename ContainerT>
using has_empty_container_visit_call = decltype(haldls::vx::detail::VisitPreorderImpl<ContainerT>::template call(std::declval<hate::Empty<ContainerT> const&>(), std::declval<typename ContainerT::coordinate_type>(), std::declval<detail::DummyVisitor>()))
template<typename ContainerT>
using has_empty_coordinate_visit_call = decltype(haldls::vx::detail::VisitPreorderImpl<ContainerT>::template call(std::declval<ContainerT&>(), std::declval<hate::Empty<typename ContainerT::coordinate_type>>(), std::declval<detail::DummyVisitor>()))
typedef fisch::vx::RunTimeInfo RunTimeInfo

Functions

attr attr ("to_numpy")
PlaybackProgramBuilderDumper convert_to_dumper (DumperDone const &cocos) SYMBOL_VISIBLE

Convert a sequence of coordinate container pairs to a PlaybackProgramBuilderDumper.

Parameters

cocos – Coordinate-Container pair sequence

template<>
inline void decode_ones(haldls::vx::CHIP_REVISION_STR::CapMemBlockConfig&)
template<>
inline void decode_ones(lola::vx::CHIP_REVISION_STR::CapMem&)
template<class T>
inline void decode_ones(T &config)

Decode data with all bits set to one into a container.

Template Parameters

T – Container type

Returns

Filled container

template<>
inline void decode_random(std::mt19937 &gen, haldls::vx::CHIP_REVISION_STR::CapMemBlockConfig &config)
template<>
inline void decode_random(std::mt19937 &gen, haldls::vx::JTAGIdCode &config)
template<>
inline void decode_random(std::mt19937 &gen, lola::vx::CHIP_REVISION_STR::CapMem &config)
template<>
inline void decode_random(std::mt19937 &gen, lola::vx::v3::Chip &config)
template<class T>
inline void decode_random(std::mt19937 &gen, T &config)

Decode random data into a container.

Template Parameters

T – Container type

Parameters

gen – RNG

Returns

randomly filled container

template<typename Seq>
auto generate(Seq const &seq)

Generate function to be called on an object implementing the PlaybackGenerator concept.

The PlaybackGenerator concept for a type Generator is comprised of having a nested Result type and a constant function with signature PlaybackGeneratorReturn<Generator::Result> generate() const;.

haldls::vx::Container::Coordinate const & get_coordinate () const SYMBOL_VISIBLE

Get coordinate corresponding to location of (to-be) read container data.

Returns constant reference to owned coordinate instance.

Returns

Coordinate value

template<typename WordT, typename ContainerT, typename CoordinateT>
auto get_encode(ContainerT const &config, CoordinateT const &coord)
template<typename WordT, typename ContainerT, typename CoordinateT>
auto get_local_encode(ContainerT const &config, CoordinateT const &coord)
template<typename AddressT, typename CoordinateT, template<typename> typename CoordinateToContainer>
auto get_local_read_addresses(CoordinateT const &c)

Get read addresses which are local to this container, i.e.

which can be accessed via container.{read_,}addresses() as opposed to visiting the down-stream containers it is (also) comprised of. In the case of leaf-node containers this are all its read addresses.

template<typename AddressT, typename CoordinateT, template<typename> typename CoordinateToContainer>
auto get_local_write_addresses(CoordinateT const &c)

Get write addresses which are local to this container, i.e.

which can be accessed via container.{write,}addresses() as opposed to visiting the down-stream containers it is (also) comprised of. In the case of leaf-node containers this are all its write addresses.

template<typename AddressT, typename CoordinateT, template<typename> typename CoordinateToContainer>
auto get_read_addresses(CoordinateT const &c)
template<typename AddressT, typename CoordinateT, template<typename> typename CoordinateToContainer>
auto get_write_addresses(CoordinateT const &c)
pybind11::bind_vector< stadls::vx::PlaybackProgram::madc_samples_type > (parent, "madc_samples_type")
void remove_block_until () SYMBOL_VISIBLE

Remove entries which contain block_until commands.

template<typename Connection>
RunTimeInfo run(Connection &connection, PlaybackProgram &&program)

Transfer and execute the given playback program and fetch results.

Template Parameters

Connection – Connection type to be used for running the program

Parameters

  • connection – Connection instance to be used for running the program

  • program – PlaybackProgram to run

Returns

Run time information

template<typename Connection>
RunTimeInfo run(Connection &connection, PlaybackProgram &program)

Transfer and execute the given playback program and fetch results.

Template Parameters

Connection – Connection type to be used for running the program

Parameters

  • connection – Connection instance to be used for running the program

  • program – PlaybackProgram to run

Returns

Run time information

template<typename Connection>
RunTimeInfo run(Connection &connection, std::shared_ptr<fisch::vx::PlaybackProgram> const &program)

Transfer and execute the given fisch playback program and fetch results.

Template Parameters

Connection – Connection type to be used for running the program

Parameters

  • connection – Connection instance to be used for running the program

  • program – PlaybackProgram to run

Returns

Run time information

template<typename WordT, typename ContainerT, typename CoordinateT, size_t N>
void set_decode(ContainerT &config, CoordinateT const &coord, std::array<WordT, N> const &data)
template<typename WordT, typename ContainerT, typename CoordinateT>
void set_decode(ContainerT &config, CoordinateT const &coord, std::vector<WordT> const &data)
template<typename WordT, typename ContainerT, typename CoordinateT, size_t N>
void set_local_decode(ContainerT &config, CoordinateT const &coord, std::array<WordT, N> const &data)
void squash () SYMBOL_VISIBLE

For each coordinate value only retain the latest command.

Order between different container types is not preserved.

class stadls::vx::ContainerTicket valid () const SYMBOL_VISIBLE

Get whether container data is available.

Returns

Boolean value

Variables

auto attr = parent.attr("madc_samples_type")
auto ism = parent->py::is_method(attr)
constexpr size_t playback_memory_size_to_fpga = fisch::vx::playback_memory_size_to_fpga

Playback memory FIFO size on FPGA in instructions for playback execution.

template<typename ContainerT>
constexpr bool supports_empty_container_v = hate::is_detected_v<has_empty_container_visit_call, ContainerT>
template<typename ContainerT>
constexpr bool supports_empty_coordinate_v = hate::is_detected_v<has_empty_coordinate_visit_call, ContainerT> && detail::container_supports_empty_coordinate_v<ContainerT>
auto const to_numpy = [](_values_type const& self) { pybind11::array_t<haldls::vx::MADCSampleFromChip::MADCSampleFromChipDType> ret(         static_cast<pybind11::ssize_t>(self.size()),         reinterpret_cast<             haldls::vx::MADCSampleFromChip::MADCSampleFromChipDType const*>(             self.data())); return ret; }
namespace stadls::vx::detail

Typedefs

template<typename T, typename C>
using has_addresses = decltype(std::declval<T&>().addresses(std::declval<C>()))
template<typename T, typename C, typename A> has_addresses_templated = decltype(std::declval< T & >().template addresses< A >(std::declval< C >()))
template<typename T, typename C>
using has_decode = decltype(std::declval<T&>().decode(std::declval<C>()))
template<typename T, typename C, typename CC>
using has_decode_coordinate = decltype(std::declval<T&>().decode(std::declval<CC const&>(), std::declval<C>()))
template<typename T, typename C, typename CC, typename A> has_decode_coordinate_templated = decltype(std::declval< T & >().template decode< A >(std::declval< CC const  & >(), std::declval< C >()))

Helpers for checking if decode exists.

This is used to compile-time dispatch to the correct version below.

template<typename T, typename C, typename A> has_decode_templated = decltype(std::declval< T & >().template decode< A >(std::declval< C >()))

Helpers for checking if decode exists.

This is used to compile-time dispatch to the correct version below.

template<typename T>
using has_encode = decltype(std::declval<T&>().encode())
template<typename T>
using has_encode_coordinate = decltype(std::declval<T&>().encode(std::declval<typename T::coordinate_type const&>()))
template<typename T, typename W> has_encode_coordinate_templated = decltype(std::declval< T & >().template encode< W >(std::declval< typename T::coordinate_type const  & >()))
template<typename T, typename W> has_encode_templated = decltype(std::declval< T & >().template encode< W >())

Helpers for checking if encode exists and in which form (templated vs.

non-templated). This is used to compile-time dispatch to the correct version below.

template<typename T, typename C>
using has_read_addresses = decltype(std::declval<T&>().read_addresses(std::declval<C>()))
template<typename T, typename C, typename A> has_read_addresses_templated = decltype(std::declval< T & >().template read_addresses< A >(std::declval< C >()))

Helpers for checking if {read_,write_,}addresses exists and in which form (templated vs.

non-templated). This is used to compile-time dispatch to the correct version below.

template<typename T, typename C>
using has_write_addresses = decltype(std::declval<T&>().write_addresses(std::declval<C>()))
template<typename T, typename C, typename A> has_write_addresses_templated = decltype(std::declval< T & >().template write_addresses< A >(std::declval< C >()))
typedef detail::PlaybackProgramBuilderAdapterImpl<BuilderStorage, DoneType> Impl

Functions

template<typename T>
size_t count_decoding_words(T const &config)

Get number of words expected for decoding.

Template Parameters

T – Container type

Parameters

Container –

Returns

Number of words for default backend

template<typename BuilderStorage, typename DoneType> class SYMBOL_VISIBLE stadls::vx::detail::PlaybackProgramBuilderAdapter empty () const

Get whether builder is empty, i.e.

no instructions are embodied.

Returns

Boolean value

template<typename T>
T::coordinate_type get_coord(T const &config)

Get coordinate matching container, e.g.

with respect to size.

Template Parameters

T – Container type

Parameters

Container –

Returns

Coordinate

bool is_write_only() const

Get whether builder only stores write instructions.

Returns

Boolean value

template SYMBOL_VISIBLE std::ostream & operator<< (std::ostream &, PlaybackProgramBuilderAdapter< fisch::vx::PlaybackProgramBuilder, stadls::vx::PlaybackProgram > const &)
template SYMBOL_VISIBLE std::ostream & operator<< (std::ostream &, PlaybackProgramBuilderAdapter< stadls::vx::v3::Dumper, stadls::vx::v3::Dumper::done_type > const &)
template<typename T> std::ostream & operator<< (std::ostream &os, Dumper< T > const &builder) SYMBOL_VISIBLE
Returns

Altered ostream

template<typename T, typename U> std::ostream & operator<< (std::ostream &os, PlaybackProgramBuilderAdapter< T, U > const &builder) SYMBOL_VISIBLE
size_t size_from_fpga() const

Get number of expected UT messages from FPGA.

Returns

Size

size_t size_to_fpga() const

Get number of UT messages to FPGA.

Returns

Size

Variables

template<typename ContainerT>
constexpr bool container_supports_empty_coordinate_v = container_supports_empty_coordinate<ContainerT>::value
std::unique_ptr<BuilderStorage> m_builder_impl
std::unordered_set<hxcomm::vx::Target> m_unsupported_targets
namespace stadls::vx::ppu

Functions

template<typename ContainerT, template<typename> typename CoordinateToContainer>
ContainerT read(typename ContainerT::coordinate_type const &coord)
template<typename ContainerT, template<typename> typename CoordinateToContainer>
void write(typename ContainerT::coordinate_type const &coord, ContainerT const &config)
namespace stadls::vx::v3

Typedefs

hate::type_list<#define PLAYBACK_CONTAINER(Name, Type) # 13 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls/include/stadls/vx/v3/coordinate_to_container.h" 2#define LAST_PLAYBACK_CONTAINER(Name, Type) #define PLAYBACK_CONTAINER(Name, Type) # 16 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls/include/stadls/vx/v3/coordinate_to_container.h" 2 > container_list

List of container types used to resolve a container type from a coordinate type.

using ContainerTicket = stadls::vx::ContainerTicket
hate::type_list<#define PLAYBACK_CONTAINER(Name, Type) # 25 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls/include/stadls/vx/v3/coordinate_to_container.h" 2#define LAST_PLAYBACK_CONTAINER(Name, Type) #define PLAYBACK_CONTAINER(Name, Type) # 28 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls/include/stadls/vx/v3/coordinate_to_container.h" 2 > coordinate_list

List of coordinate types sorted the same way as the container list.

using Dumper = stadls::vx::detail::Dumper<DumperDone>
template<typename Result>
using PlaybackGeneratorReturn = stadls::vx::PlaybackGeneratorReturn<PlaybackProgramBuilder, Result>
using PlaybackProgram = stadls::vx::PlaybackProgram
using PlaybackProgramBuilder = detail::PlaybackProgramBuilderAdapter<fisch::vx::PlaybackProgramBuilder, PlaybackProgram>
using PlaybackProgramBuilderDumper = detail::PlaybackProgramBuilderAdapter<Dumper, Dumper::done_type>
typedef stadls::vx::ReinitStackEntry ReinitStackEntry

Functions

PlaybackProgramBuilder convert_to_builder (Dumper::done_type const &cocos) SYMBOL_VISIBLE

Convert a sequence of coordinate container pairs to a PlaybackProgramBuilder.

Parameters

cocos – Coordinate-Container pair sequence

PlaybackProgramBuilder convert_to_builder (PlaybackProgramBuilderDumper &&dumper) SYMBOL_VISIBLE

Convert a PlaybackProgramBuilderDumper to a PlaybackProgramBuilder (rvalue reference overload).

The dumper is emptied during the process.

Parameters

dumper – Dumper to convert

PlaybackProgramBuilder convert_to_builder (PlaybackProgramBuilderDumper &dumper) SYMBOL_VISIBLE

Convert a PlaybackProgramBuilderDumper to a PlaybackProgramBuilder.

The dumper is emptied during the process.

Parameters

dumper – Dumper to convert

wrapped def ("pop", &ReinitStackEntry::pop)
wrapped def ("set", &ReinitStackEntry::set, pybind11::arg("pbmem_request"), pybind11::arg("pbmem_snapshot")=std::nullopt, pybind11::arg("enforce")=true)
def ("tolist", [](GENPYBIND_PARENT_TYPE const &v) { py::list ret;for(auto const &vv :v.values) { py::object item=py::make_tuple(std::get< 0 >(vv) ->clone(), std::get< 1 >(vv) ->clone_encodable());ret.append(item);} return ret;})
template<typename ...Ts>
auto generate(Ts&&... args) -> decltype(stadls::vx::generate(std::forward<Ts>(args)...))
bool operator!= (DumperDone const &other) const SYMBOL_VISIBLE
template<typename ...Ts>
auto run(Ts&&... args) -> decltype(stadls::vx::run(std::forward<Ts>(args)...))

Variables

::pyhxcomm::vx::reinit_stack_entry_unroll_helper<decltype(wrapped)> helper = {wrapped}
struct stadls::vx::v3::DumperDone operator   ==(DumperDone const& other) const SYMBOL_VISIBLE
const override   = { PYBIND11_OVERLOAD_PURE(pybind11::tuple, ::stadls::vx::PlaybackGenerator, generate, )
namespace detail
namespace stadls::vx::v3::ppu

Functions

template<typename ContainerT>
ContainerT read(typename ContainerT::coordinate_type const &coord)
template<typename ContainerT>
void write(typename ContainerT::coordinate_type const &coord, ContainerT const &config)
namespace std

STL namespace.

file visitors.h
#include <algorithm>#include <array>#include <iterator>#include <stdexcept>#include <utility>#include “haldls/has_local_data.h”#include “haldls/is_leaf_node.h”#include “hate/empty.h”
file addresses.h
#include “haldls/is_leaf_node.h”#include “haldls/vx/traits.h”#include “hate/type_traits.h”#include “stadls/visitors.h”#include “stadls/vx/supports_empty.h”#include <type_traits>#include <utility>
file constants.h
#include “fisch/vx/constants.h”
file dumper.h
#include “haldls/vx/block_until.h”#include “haldls/vx/container.h”#include “hate/visibility.h”#include “stadls/vx/container_ticket.h”
file dumper.h
#include “haldls/vx/v3/container.h”#include “lola/vx/v3/container.h”#include “stadls/vx/dumper.h”#include “stadls/vx/genpybind.h”#include “stadls/vx/playback_program_builder.h”#include “stadls/vx/v3/coordinate_to_container.h”#include “stadls/vx/v3/dumperdone.h”#include <cereal/macros.hpp>
file encode.h
#include “haldls/is_leaf_node.h”#include “haldls/vx/traits.h”#include “hate/type_traits.h”#include “stadls/visitors.h”#include <type_traits>#include <utility>
file genpybind.h
#include <genpybind.h>

Defines

GENPYBIND_TAG_STADLS_VX
GENPYBIND_TAG_STADLS_VX_V3
file playback_generator.h
#include “hate/nil.h”#include “hate/type_traits.h”#include “hate/visibility.h”#include “stadls/vx/genpybind.h”
file playback_generator.h
#include “stadls/vx/genpybind.h”#include “stadls/vx/playback_generator.h”#include “stadls/vx/v3/playback_program_builder.h”

Functions

parent py::template class_<::stadls::vx::PlaybackGenerator, PyPlaybackGenerator > (parent, "PlaybackGenerator") .def(parent -> py::template init<>()) .def("generate", &::stadls::vx::PlaybackGenerator::generate)
parent def ("generate", [](::stadls::vx::PlaybackGenerator const &self) { return self.generate();}, pybind11::return_value_policy::move)
file playback_program.h
#include <cstdint>#include <memory>#include <optional>#include <string>#include <vector>#include <boost/variant.hpp>#include “fisch/vx/playback_program.h”#include “haldls/vx/common.h”#include “haldls/vx/event.h”#include “hate/type_list.h”#include “hate/visibility.h”#include “hxcomm/vx/target.h”#include “stadls/vx/genpybind.h”#include “stadls/vx/run_time_info.h”#include <cereal/macros.hpp>

Functions

PlaybackProgram (std::shared_ptr< fisch::vx::PlaybackProgram > const &program_impl, std::unordered_set< hxcomm::vx::Target > unsupported_targets) SYMBOL_VISIBLE

Construct PlaybackProgram from implementation.

Used in PlaybackProgramBuilderAdapter

Parameters

  • program_impl – Implementation playback program

  • unsupported_targets – Build-imposed restrictions on targets

template<typename Connection>
RunTimeInfo run(Connection&, PlaybackProgram&)

Variables

std::shared_ptr<fisch::vx::PlaybackProgram> m_program_impl
std::unordered_set<hxcomm::vx::Target> m_unsupported_targets
friend ReinitStackEntry
file playback_program.h
#include “stadls/vx/genpybind.h”#include “stadls/vx/playback_program.h”
file playback_program_builder.h
#include <iosfwd>#include <memory>#include <unordered_set>#include “halco/hicann-dls/vx/barrier.h”#include “haldls/vx/barrier.h”#include “haldls/vx/block_until.h”#include “haldls/vx/common.h”#include “haldls/vx/container.h”#include “hate/visibility.h”#include “hxcomm/vx/target.h”#include “stadls/vx/container_ticket.h”#include “stadls/vx/dumper.h”#include “stadls/vx/genpybind.h”#include “stadls/vx/playback_program.h”

Typedefs

typedef BuilderStorage Builder
typedef hate::type_list<::stadls::vx::v3::Dumper> dumper_types

Functions

~PlaybackProgramBuilderAdapter()
void block_until(haldls::vx::BlockUntil::Coordinate const &coord, haldls::vx::BlockUntil const &condition)

Add instruction to block execution until specified condition is satisfied.

Parameters

  • coord – Coordinate for which to block

  • condition – Condition to block execution for until satisfaction

if constexpr (hate::is_in_type_list< typename std::decay< decltype(p)>::type::Builder, dumper_types >::value)
void copy_back(BuilderStorage const &other)

Copy BuilderStorage to the end of this builder instance.

The copied-from storage is untouched during the process.

Throws

std::runtime_error – On other builder not being write only

Parameters

other – BuilderStorage to copy to this instance at the back

void copy_back(PlaybackProgramBuilderAdapter const &other)

Copy other PlaybackProgramBuilderAdapter to the end of this builder instance.

The copied-from builder is untouched during the process.

Throws

std::runtime_error – On other builder not being write only

Parameters

other – Builder to copy to this instance at the back

parent def ("__str__", [](GENPYBIND_PARENT_TYPE const &p) { std::stringstream ss;ss<< p;return ss.str();})
DoneType done()

Close PlaybackProgram build process and return executable program.

Returns

Executable PlaybackProgram

void merge_back(BuilderStorage &&other)

Merge BuilderStorage to the end of this builder instance.

The moved-from storage is emptied during the process.

Parameters

other – BuilderStorage to move to this instance at the back

void merge_back(BuilderStorage &other)

Merge BuilderStorage to the end of this builder instance.

The moved-from storage is emptied during the process.

Parameters

other – BuilderStorage to move to this instance at the back

void merge_back(PlaybackProgramBuilderAdapter &&other)

Merge other PlaybackProgramBuilderAdapter to the end of this builder instance.

The moved-from builder is emptied during the process.

Parameters

other – Builder to move to this instance at the back

void merge_back(PlaybackProgramBuilderAdapter &other)

Merge other PlaybackProgramBuilderAdapter to the end of this builder instance.

The moved-from builder is emptied during the process.

Parameters

other – Builder to move to this instance at the back

template<typename T, typename U>
std::ostream &operator<<(std::ostream &os, PlaybackProgramBuilderAdapter<T, U> const &builder)
PlaybackProgramBuilderAdapter &operator=(PlaybackProgramBuilderAdapter &&other)
PlaybackProgramBuilderAdapter()

Construct builder.

PlaybackProgramBuilderAdapter(PlaybackProgramBuilderAdapter &&other)
PlaybackProgramBuilderAdapter(PlaybackProgramBuilderAdapter const&) = delete
ContainerTicket read(haldls::vx::Container::Coordinate const &coord)

Add instructions to read container data from given location.

Parameters

coord – Coordinate value selecting location

ContainerTicket read(haldls::vx::Container::Coordinate const &coord, haldls::vx::Backend backend)

Add instructions to read container data from given location.

Parameters

  • coord – Coordinate value selecting location

  • backend – Backend selection

return ss str ()
void write(haldls::vx::Container::Coordinate const &coord, haldls::vx::Container const &config)

Add instructions to write given container to given location.

Parameters

  • coord – Coordinate value selecting location

  • config – Container configuration data

void write(haldls::vx::Container::Coordinate const &coord, haldls::vx::Container const &config, haldls::vx::Backend backend)

Add instructions to write given container to given location.

Parameters

  • coord – Coordinate value selecting location

  • config – Container configuration data

  • backend – Backend selection

void write(haldls::vx::Container::Coordinate const &coord, haldls::vx::Container const &config, haldls::vx::Container const &config_reference)

Add instructions to write given container to given location.

Parameters

  • coord – Coordinate value selecting location

  • config – Container configuration data

  • config_reference – Reference configuration for differential write

void write(haldls::vx::Container::Coordinate const &coord, haldls::vx::Container const &config, haldls::vx::Container const &config_reference, haldls::vx::Backend backend)

Add instructions to write given container to given location.

Parameters

  • coord – Coordinate value selecting location

  • config – Container configuration data

  • config_reference – Reference configuration for differential write

  • backend – Backend selection

Variables

else   = { ss << "PlaybackProgramBuilder(to FPGA size: " << p.size_to_fpga()        << ", is write only: " << std::boolalpha << p.is_write_only() << ")"
file playback_program_builder.h
#include “haldls/vx/v3/container.h”#include “lola/vx/v3/container.h”#include “stadls/vx/genpybind.h”#include “stadls/vx/playback_program_builder.h”#include “stadls/vx/v3/coordinate_to_container.h”#include “stadls/vx/v3/dumper.h”#include <cereal/macros.hpp>
file run.h
#include “stadls/vx/genpybind.h”#include “stadls/vx/run_time_info.h”#include “stadls/vx/run.tcc”
file run.h
#include “stadls/vx/genpybind.h”#include “stadls/vx/run.h”
file run_time_info.h
#include “fisch/vx/run_time_info.h”#include “stadls/vx/genpybind.h”
file set_decode.h
#include “haldls/vx/common.h”#include “hate/type_traits.h”#include “stadls/visitors.h”#include “stadls/vx/supports_empty.h”#include <type_traits>
file stadls.h
#include “stadls/vx/constants.h”#include “stadls/vx/init_generator.h”#include “stadls/vx/playback_generator.h”#include “stadls/vx/playback_program.h”#include “stadls/vx/playback_program_builder.h”#include “stadls/vx/reinit_stack_entry.h”#include “stadls/vx/run.h”
file stadls.h
#include “stadls/vx/v3/container_ticket.h”#include “stadls/vx/v3/dumper.h”#include “stadls/vx/v3/init_generator.h”#include “stadls/vx/v3/playback_generator.h”#include “stadls/vx/v3/playback_program.h”#include “stadls/vx/v3/playback_program_builder.h”#include “stadls/vx/v3/reinit_stack_entry.h”#include “stadls/vx/v3/run.h”
file supports_empty.h
#include “haldls/vx/common.h”#include “hate/type_traits.h”
file container_ticket.h
#include “fisch/vx/container.h”#include “fisch/vx/container_ticket.h”#include “haldls/vx/container.h”#include “haldls/vx/event.h”#include “hate/visibility.h”#include “stadls/vx/genpybind.h”#include <cstdbool>#include <memory>#include <variant>#include <vector>#include “fisch/vx/container.def”

Defines

LAST_PLAYBACK_CONTAINER(Name, Type)
PLAYBACK_CONTAINER(Name, Type)

Typedefs

std::variant<#define PLAYBACK_CONTAINER(Name, Type) #define LAST_PLAYBACK_CONTAINER(Name, Type) > ticket_impl_type

Functions

ContainerTicket(ContainerTicket &&other) = default
ContainerTicket (ContainerTicket const &other) SYMBOL_VISIBLE
ContainerTicket(std::unique_ptr<haldls::vx::Container::Coordinate> coord, std::unique_ptr<haldls::vx::Container> config, ticket_impl_type ticket_impl)
haldls::vx::Container const & get () const SYMBOL_VISIBLE

Get container data if available.

Returns constant reference to owned container instance.

Throws

std::runtime_error – On container data not available yet

Returns

Container data

haldls::vx::FPGATime get_fpga_time () const SYMBOL_VISIBLE

Get FPGA executor timestamp of last container response if time annotation is enabled.

If time annotation is not enabled, get message count since last time annotation or from the beginning of the response stream.

Returns

FPGATime value

ContainerTicket &operator=(ContainerTicket &&other) = default
ContainerTicket & operator= (ContainerTicket const &other) SYMBOL_VISIBLE

Variables

mutable std::unique_ptr<haldls::vx::Container> m_config
std::unique_ptr<haldls::vx::Container::Coordinate> m_coord
ticket_impl_type m_ticket_impl
file container_ticket.h
#include “stadls/vx/container_ticket.h”#include “stadls/vx/genpybind.h”
file coordinate_to_container.h
#include “haldls/vx/v3/container.h”#include “hate/type_list.h”#include “lola/vx/v3/container.h”#include “haldls/vx/v3/container.def”#include “lola/vx/v3/container.def”

Defines

LAST_PLAYBACK_CONTAINER(Name, Type)
LAST_PLAYBACK_CONTAINER(Name, Type)
PLAYBACK_CONTAINER(Name, Type)
PLAYBACK_CONTAINER(Name, Type)
PLAYBACK_CONTAINER(Name, Type)
PLAYBACK_CONTAINER(Name, Type)
file decode.h
#include <limits>#include <random>#include “fisch/vx/container.h”#include “fisch/vx/container_cast.h”#include “fisch/vx/fill.h”#include “halco/hicann-dls/vx/capmem.h”#include “halco/hicann-dls/vx/ppu.h”#include “haldls/vx/common.h”#include “haldls/vx/jtag.h”#include “haldls/vx/traits.h”#include “lola/vx/capmem.h”#include “stadls/visitors.h”#include “haldlsID(/)vxID(/)vID(CHIP_REVISION)/capmem.h”

Defines

CONCAT(w, x, y, z)
ID(x)
STR(x)
XSTR(x)
file decode.h
#include “stadls/vx/decode.h”#include “lola/vx/v3/chip.h”

Defines

CHIP_REVISION
file dumperdone.h
#include “haldls/vx/encodable.h”#include “hate/visibility.h”#include “lola/vx/v3/chip.h”#include “stadls/vx/genpybind.h”#include <memory>#include <vector>#include <cereal/macros.hpp>

Functions

lola::vx::v3::Chip convert_to_chip (DumperDone const &dumperdone) SYMBOL_VISIBLE

Convert the dumper result to a Chip config.

This conversion is not bijective.

Parameters

dumperdone – Dumper result

lola::vx::v3::Chip convert_to_chip (DumperDone const &dumperdone, lola::vx::v3::Chip const &previous) SYMBOL_VISIBLE

Convert the dumper result to a Chip config.

This conversion is not bijective.

Parameters

  • dumperdone – Dumper result

  • previous – Optional previous ChipConfig to apply changes to

file init_generator.h
#include “hate/visibility.h”#include “stadls/vx/v3/playback_generator.h”#include “stadls/vx/v3/playback_program_builder.h”
file read.h
#include “fisch/vx/word_access/type/omnibus.h”#include “halco/hicann-dls/vx/omnibus.h”#include “haldls/vx/coordinate_to_container.h”#include “libnux/vx/omnibus.h”#include “stadls/vx/addresses.h”#include “stadls/vx/set_decode.h”#include <array>#include <vector>
file read.h
#include “stadls/vx/ppu/read.h”#include “stadls/vx/v3/coordinate_to_container.h”

Defines

CHIP_REVISION
file write.h
#include “fisch/vx/word_access/type/omnibus.h”#include “halco/hicann-dls/vx/omnibus.h”#include “haldls/vx/coordinate_to_container.h”#include “libnux/system.h”#include “libnux/vx/omnibus.h”#include “stadls/vx/addresses.h”#include “stadls/vx/encode.h”#include <algorithm>#include <array>#include <vector>
file write.h
#include “stadls/vx/ppu/write.h”#include “stadls/vx/v3/coordinate_to_container.h”

Defines

CHIP_REVISION
file pystadls.h
#include <pybind11/pybind11.h>#include “cereal/types/stadls/vx/v3/stadls.h”#include “stadls/vx/genpybind.h”#include “stadls/vx/v3/stadls.h”
file reinit_stack_entry.h
#include “hate/visibility.h”#include “stadls/vx/genpybind.h”#include “stadls/vx/playback_program.h”#include <memory>#include <optional>#include “stadls/vx/reinit_stack_entry.tcc”
file reinit_stack_entry.h
#include “stadls/vx/genpybind.h”#include “stadls/vx/reinit_stack_entry.h”
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls/include
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls/include/stadls/vx/ppu
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls/include/stadls/vx/v3/ppu
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls/include/stadls
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls/include/stadls/vx/v3
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/haldls/include/stadls/vx