API Reference: grenade

struct grenade::vx::CachingCompiler : public grenade::vx::Compiler

#include <ppu.h>

Compiler with global cache of compiled programs.

Public Functions

Program compile(std::vector<std::string> sources)

Compile sources into target program or return from cache if already compiled.

Public Members

std::vector<std::string> options_after_source = {"-Bstatic", get_library_paths(), "-lgcc", "-lnux_vx_v3", "-lgrenade_ppu_vx", "-lhalco_common_ppu_vx", "-lhalco_hicann_dls_ppu_vx", "-lhalco_hicann_dls_ppu_vx_v3", "-lfisch_ppu_vx", "-lhaldls_ppu_vx_v3", "-lnux_vx_v3", "-Wl,--whole-archive", get_libnux_runtime("nux_runtime_vx_v3.o"), "-Wl,--no-whole-archive", "-lc", "-lgcc", "-Bdynamic",}

std::vector<std::string> options_before_source = {"-std=gnu++17", "-fdiagnostics-color=always", "-O2", "-g", "-fno-omit-frame-pointer", "-fno-strict-aliasing", "-Wall", "-Wextra", "-pedantic", "-ffreestanding", "-mcpu=nux", "-fno-exceptions", "-fno-rtti", "-fno-non-call-exceptions", "-fno-common", "-ffunction-sections", "-fdata-sections", "-fno-threadsafe-statics", "-fstack-usage", "-mcpu=s2pp_hx", get_include_paths(), "-DSYSTEM_HICANN_DLS_MINI", "-DLIBNUX_TIME_RESOLUTION_SHIFT=0", "-fuse-ld=bfd", "-Wl,--gc-sections", "-nostdlib", "-T" + get_linker_file("elf32nux.x"), "-Wl,--defsym=mailbox_size=4096",}

Public Static Attributes

static constexpr auto name = "powerpc-ppu-g++"

Private Static Functions

static ProgramCache &get_program_cache()

struct grenade::vx::CachingCompiler::ProgramCache

#include <ppu.h>

Cache for compiled PPU programs.

The program information is indexed by hashed compilation options and the source code supplied on top of the base program. It assumes, that the base source and included headers are not modified concurrently.

Public Members

std::map<std::string, Program> data

std::mutex data_mutex

struct grenade::vx::CachingCompiler::ProgramCache::Source

#include <ppu.h>

Sources used for compilation of program serving as hash source into the cache.

Public Functions

std::string sha1() const

Public Members

std::vector<std::string> options_after_source

Compiler options after the source location specification.

std::vector<std::string> options_before_source

Compiler options before the source location specification.

std::vector<std::string> source_codes

Source code additional to the constant base program sources.

template<typename T>
class grenade::vx::common::detail::NullOutputIterator : public std::iterator<std::output_iterator_tag, void, void, void, void>

#include <null_output_iterator.h>

Output iterator dropping all mutable operations.

Public Functions

inline NullOutputIterator &operator*()

inline NullOutputIterator &operator++()

inline NullOutputIterator operator++(int)

inline NullOutputIterator &operator=(T const&)

struct grenade::vx::common::EntityOnChip

#include <entity_on_chip.h>

Entity on chip mixin carrying chip id information.

Subclassed by grenade::vx::network::BackgroundSourcePopulation, grenade::vx::network::ExternalSourcePopulation, grenade::vx::network::NeuronRecording, grenade::vx::network::PadRecording, grenade::vx::network::Population, grenade::vx::network::Projection, grenade::vx::signal_flow::vertex::EntityOnChip

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

Public Functions

explicit EntityOnChip(ChipCoordinate const &chip_coordinate = ChipCoordinate())

bool operator!=(EntityOnChip const &other) const

bool operator==(EntityOnChip const &other) const

Public Members

ChipCoordinate chip_coordinate

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, EntityOnChip const &entity)

struct grenade::vx::common::ExecutionInstanceID : public halco::common::detail::BaseType<ExecutionInstanceID, size_t>

#include <execution_instance_id.h>

Execution instance identifier.

An execution instance describes a unique physically placed isolated execution.

Public Functions

inline explicit constexpr ExecutionInstanceID(value_type const value = 0)

struct grenade::vx::common::Time : public halco::common::detail::BaseType<Time, uint64_t>

#include <time.h>

Arithmetic type used for time measurements both to and from the hardware.

Representation is implemented as 64 bit wide unsigned integer of units [FPGA clock cycles]. TODO: Think about using std::chrono instead of our wrapper type.

Public Functions

inline explicit constexpr Time(value_type const value = 0)

haldls::vx::v3::ChipTime toChipTime() const

haldls::vx::v3::FPGATime toFPGATime() const

haldls::vx::v3::Timer::Value toTimerOnFPGAValue() const

Public Static Attributes

static const Time fpga_clock_cycles_per_us

template<typename T>
struct grenade::vx::common::TimedData

#include <timed_data.h>

Public Types

typedef T Data

Public Functions

TimedData() = default

TimedData(Time const &time, T const &data)

bool operator!=(TimedData const &other) const

bool operator==(TimedData const &other) const

Public Members

T data

Time time

struct grenade::vx::Compiler

#include <ppu.h>

Compiler for PPU programs.

Subclassed by grenade::vx::CachingCompiler

Public Functions

Compiler()

Program compile(std::vector<std::string> sources)

Compile sources into target program.

Public Members

std::vector<std::string> options_after_source = {"-Bstatic", get_library_paths(), "-lgcc", "-lnux_vx_v3", "-lgrenade_ppu_vx", "-lhalco_common_ppu_vx", "-lhalco_hicann_dls_ppu_vx", "-lhalco_hicann_dls_ppu_vx_v3", "-lfisch_ppu_vx", "-lhaldls_ppu_vx_v3", "-lnux_vx_v3", "-Wl,--whole-archive", get_libnux_runtime("nux_runtime_vx_v3.o"), "-Wl,--no-whole-archive", "-lc", "-lgcc", "-Bdynamic",}

std::vector<std::string> options_before_source = {"-std=gnu++17", "-fdiagnostics-color=always", "-O2", "-g", "-fno-omit-frame-pointer", "-fno-strict-aliasing", "-Wall", "-Wextra", "-pedantic", "-ffreestanding", "-mcpu=nux", "-fno-exceptions", "-fno-rtti", "-fno-non-call-exceptions", "-fno-common", "-ffunction-sections", "-fdata-sections", "-fno-threadsafe-statics", "-fstack-usage", "-mcpu=s2pp_hx", get_include_paths(), "-DSYSTEM_HICANN_DLS_MINI", "-DLIBNUX_TIME_RESOLUTION_SHIFT=0", "-fuse-ld=bfd", "-Wl,--gc-sections", "-nostdlib", "-T" + get_linker_file("elf32nux.x"), "-Wl,--defsym=mailbox_size=4096",}

Public Static Attributes

static constexpr auto name = "powerpc-ppu-g++"

struct grenade::vx::Compiler::Program

#include <ppu.h>

PPU program result of compilation.

Public Members

lola::vx::v3::PPUElfFile::Memory memory

Program memory image.

std::optional<std::string> objdump

Optional objdump -d output of program.

Generation is performed for loglevel trace.

std::optional<std::string> readelf

Optional readelf -a output of program.

Generation is performed for loglevel debug.

std::optional<std::string> stack_sizes

Optional stack size output of functions of program.

Generation is performed for loglevel debug.

lola::vx::v3::PPUElfFile::symbols_type symbols

Program symbols.

class grenade::vx::compute::Addition

#include <addition.h>

Compute an addition of a constant to given data batches of type signal_flow::Int8.

Public Functions

Addition() = default

Addition(std::vector<signal_flow::Int8> const &other)

Create single Addition compute graph wrapper.

Parameters

other – Value to add to given data.

size_t input_size() const

size_t output_size() const

std::vector<std::vector<signal_flow::Int8>> run(std::vector<std::vector<signal_flow::Int8>> const &inputs, lola::vx::v3::Chip const &config, execution::JITGraphExecutor &executor) const

Run given operation.

Parameters

• inputs – Input values to use

• config – Static chip configuration to be used

• executor – Executor backend to use

Returns

Resulting values

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

signal_flow::Graph m_graph = {}

signal_flow::Graph::vertex_descriptor m_input_vertex = {}

std::vector<signal_flow::Int8> m_other = {}

signal_flow::Graph::vertex_descriptor m_other_vertex = {}

signal_flow::Graph::vertex_descriptor m_output_vertex = {}

Friends

friend struct cereal::access

class grenade::vx::compute::ArgMax

#include <argmax.h>

Compute a argmax operation.

The returned index type is 32bit unsigned integer.

Public Functions

ArgMax() = default

ArgMax(size_t size)

Create single ArgMax compute graph wrapper.

Parameters

size – Size of operation.

size_t input_size() const

size_t output_size() const

std::vector<std::vector<signal_flow::UInt32>> run(std::vector<std::vector<signal_flow::Int8>> const &inputs, lola::vx::v3::Chip const &config, execution::JITGraphExecutor &executor) const

Run given operation.

Parameters

• inputs – Input values to use

• config – Static chip configuration to be used

• executor – Executor backend to use

Returns

Resulting values

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

signal_flow::Graph m_graph

signal_flow::Graph::vertex_descriptor m_input_vertex = {}

signal_flow::Graph::vertex_descriptor m_output_vertex = {}

Friends

friend struct cereal::access

class grenade::vx::compute::Conv1d

#include <conv1d.h>

Compute a multiply-accumulate operation with signed weights.

Neurons and synapse rows are filled monotonously. If more synapses are needed than fit on a single chip sequential unrolling is used.

Public Types

typedef std::vector<std::vector<signal_flow::UInt5>> Activations

Activations with batch as outer dimension and (in_channels, values) in row-major as inner dimension.

typedef MAC::Weight Weight

typedef std::vector<std::vector<std::vector<Weight>>> Weights

Weights of shape (out_channels, in_channels, size)

Public Functions

Conv1d() = default

template<typename WeightsT>
Conv1d(WeightsT &&weights, size_t input_size, size_t stride, size_t num_sends = 1, common::Time wait_between_events = common::Time(25), bool enable_loopback = false)

Create single Conv1d compute graph wrapper.

Parameters

• weights – Weight matrix.

• input_size – Size of one input trace

• stride – Stride of convolution

• num_sends – Number of times a input activation is sent to the specific row

• wait_between_events – Wait time between input events in FPGA cycles

• enable_loopback – Enable loopback of events with statistic analysis

size_t input_size() const

size_t output_size() const

std::vector<std::vector<signal_flow::Int8>> run(Activations const &inputs, lola::vx::v3::Chip const &config, execution::JITGraphExecutor &executor) const

Run given set of activations given the weights from construction.

Parameters

• inputs – Input activations to use

• config – Static chip configuration to be used

• executor – Executor backend to use

Returns

Resulting accumulated membrane potentials

Private Functions

void build_mac(Weights &&weights)

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

bool m_enable_loopback = {false}

signal_flow::Graph m_graph = {}

size_t m_in_channels = {}

size_t m_input_size = {}

size_t m_kernel_size = {}

MAC m_mac = {}

size_t m_num_sends = {}

size_t m_out_channels = {}

size_t m_stride = {}

common::Time m_wait_between_events = {}

Friends

friend struct cereal::access

class grenade::vx::compute::ConvertingReLU

#include <converting_relu.h>

Compute a rectified linear unit operation converting from signal_flow::Int8 to signal_flow::UInt5.

Public Functions

ConvertingReLU() = default

ConvertingReLU(size_t size, uint32_t shift)

Create single ConvertingReLU compute graph wrapper.

Parameters

• size – Size of operation

• shift – Power-of-two (bitshift) scaling parameter before clamping, i.e. saturation to signal_flow::UInt5 value range

size_t input_size() const

size_t output_size() const

std::vector<std::vector<signal_flow::UInt5>> run(std::vector<std::vector<signal_flow::Int8>> const &inputs, lola::vx::v3::Chip const &config, execution::JITGraphExecutor &executor) const

Run given operation.

Parameters

• inputs – Input values to use

• config – Static chip configuration to be used

• executor – Executor backend to use

Returns

Resulting values

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

signal_flow::Graph m_graph = {}

signal_flow::Graph::vertex_descriptor m_input_vertex = {}

signal_flow::Graph::vertex_descriptor m_output_vertex = {}

Friends

friend struct cereal::access

class grenade::vx::compute::detail::RangeSplit

#include <range_split.h>

Split one-dimensional range into ranges of maximal given size.

Public Functions

explicit RangeSplit(size_t split_size)

Construct range split with maximal size of ranges to split into.

Parameters

split_size – Maximal size of ranges to split into

std::vector<SubRange> operator()(size_t size) const

Split given range [0, size) into ranges.

Parameters

size – Size of range to split

Returns

Sub-ranges adhering to maximal size

Private Members

size_t m_split_size

struct grenade::vx::compute::detail::RangeSplit::SubRange

#include <range_split.h>

Sub-range consisting of local size and offset.

Public Members

size_t offset

size_t size

class grenade::vx::compute::detail::SingleChipExecutionInstanceManager

#include <single_chip_execution_instance_manager.h>

Manager for execution instances of a single chip.

Execution indices are allocated linearly and hemispheres are used alternatingly.

Public Functions

SingleChipExecutionInstanceManager() = default

halco::hicann_dls::vx::v3::HemisphereOnDLS get_current_hemisphere() const

Get current hemisphere.

common::ExecutionInstanceID next()

Get next execution instance.

common::ExecutionInstanceID next_index()

Get next execution instance forcing a change of the execution index.

Private Members

halco::hicann_dls::vx::v3::HemisphereOnDLS m_current_hemisphere

common::ExecutionInstanceID m_current_instance

class grenade::vx::compute::MAC

#include <mac.h>

Compute a multiply-accumulate operation with signed weights.

Neurons and synapse rows are filled monotonously. If more synapses are needed than fit on a single chip sequential unrolling is used.

Public Types

typedef std::vector<std::vector<signal_flow::UInt5>> Activations

Activations with batch as outer dimension and weight row size as inner dimension.

typedef std::vector<std::vector<Weight>> Weights

Public Functions

MAC() = default

template<typename WeightsT>
MAC(WeightsT &&weights, size_t num_sends = 1, common::Time wait_between_events = common::Time(25), bool enable_loopback = false, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS const &madc_recording_neuron = halco::hicann_dls::vx::v3::AtomicNeuronOnDLS(), std::string madc_recording_path = "")

Create single MAC compute graph wrapper.

Parameters

• weights – Weight matrix.

• num_sends – Number of times a input activation is sent to the specific row

• wait_between_events – Wait time between input events in FPGA cycles

• enable_loopback – Enable loopback of events with statistic analysis

• madc_recording_neuron – Neuron ID to record via MADC

• madc_recording_path – Path to which to store MADC neuron membrane recordings in CSV format. If file exists new data is appended. By default recording is disabled.

size_t input_size() const

size_t output_size() const

std::vector<std::vector<signal_flow::Int8>> run(Activations const &inputs, lola::vx::v3::Chip const &config, execution::JITGraphExecutor &executor) const

Run given set of activations weights given on construction.

Parameters

• inputs – Input activations to use

• config – Static chip configuration to be used

• executor – Executor backend to use

Returns

Resulting accumulated membrane potentials

Private Functions

void build_graph()

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

bool m_enable_loopback = {false}

signal_flow::Graph m_graph = {}

signal_flow::Graph::vertex_descriptor m_input_vertex = {}

halco::hicann_dls::vx::v3::AtomicNeuronOnDLS m_madc_recording_neuron

std::string m_madc_recording_path

std::map<common::ExecutionInstanceID, signal_flow::Graph::vertex_descriptor> m_madc_recording_vertices

size_t m_num_sends = {}

signal_flow::Graph::vertex_descriptor m_output_vertex = {}

common::Time m_wait_between_events = {}

Weights m_weights = {}

Private Static Functions

static std::pair<signal_flow::Graph::vertex_descriptor, std::optional<signal_flow::Graph::vertex_descriptor>> insert_synram(signal_flow::Graph &graph, Weights &&weights, common::ExecutionInstanceID const &instance, halco::hicann_dls::vx::v3::HemisphereOnDLS const &hemisphere, std::optional<halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> const &madc_recording_neuron, signal_flow::Graph::vertex_descriptor crossbar_input_vertex)

Insert a matrix multiplication operation on a synram.

Parameters

• graph – Graph to insert into

• weights – Weights to use

• instance – Execution instance to place onto

• hemisphere – Hemisphere to place onto

• madc_recording_neuron – Optional location of neuron to record via MADC

• crossbar_input_vertex – Incoming crossbar input vertex to use

Returns

Data output vertex to measured membrane potential values

Friends

friend struct cereal::access

struct grenade::vx::compute::MAC::Weight : public halco::common::detail::RantWrapper<Weight, int_fast8_t, 63, -63>

#include <mac.h>

weight.

Public Types

typedef lola::vx::v3::SynapseMatrix::Weight UnsignedWeight

Public Functions

inline explicit constexpr Weight(intmax_t const val = 0)

UnsignedWeight toExcitatory() const

UnsignedWeight toInhibitory() const

class grenade::vx::compute::ReLU

#include <relu.h>

Compute a rectified linear unit operation.

Public Functions

ReLU() = default

ReLU(size_t size)

Create single ReLU compute graph wrapper.

Parameters

size – Size of operation.

size_t input_size() const

size_t output_size() const

std::vector<std::vector<signal_flow::Int8>> run(std::vector<std::vector<signal_flow::Int8>> const &inputs, lola::vx::v3::Chip const &config, execution::JITGraphExecutor &executor) const

Run given operation.

Parameters

• inputs – Input values to use

• config – Static chip configuration to be used

• executor – Executor backend to use

Returns

Resulting values

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

signal_flow::Graph m_graph = {}

signal_flow::Graph::vertex_descriptor m_input_vertex = {}

signal_flow::Graph::vertex_descriptor m_output_vertex = {}

Friends

friend struct cereal::access

struct grenade::vx::compute::Sequence

#include <sequence.h>

Public Types

typedef std::variant<Addition, ArgMax, Conv1d, MAC, ReLU, ConvertingReLU> Entry

typedef std::variant<std::vector<std::vector<signal_flow::UInt5>>, std::vector<std::vector<signal_flow::Int8>>, std::vector<std::vector<signal_flow::UInt32>>> IOData

Vectorized number data for input and output without timing information.

Outer dimension: batch-entries Inner dimension: values per batch entry

Public Functions

Sequence() = default

IOData run(IOData const &input, lola::vx::v3::Chip const &config, execution::JITGraphExecutor &executor)

Public Members

std::list<Entry> data

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Friends

friend struct cereal::access

struct grenade::vx::execution::backend::Connection

#include <connection.h>

Connection to hardware/simulation ensuring proper initialization.

In addition to the initialized connection a corresponding reinit stack is being held, which requires an equal lifetime.

Public Types

typedef std::variant<stadls::vx::v3::ExperimentInit, stadls::vx::v3::DigitalInit> Init

Accepted initialization generators.

Public Functions

Connection()

Construct connection from environment and initialize with default constructed ExperimentInit.

Connection(hxcomm::vx::ConnectionVariant &&connection)

Construct connection from hxcomm connection and initialize with default constructed ExperimentInit.

Ownership of the hxcomm connection is transferred to this object.

Parameters

connection – Connection from hxcomm to use

Connection(hxcomm::vx::ConnectionVariant &&connection, Init const &init)

Construct connection from hxcomm connection and initialization generator.

Ownership of the hxcomm connection is transferred to this object.

Parameters

• connection – Connection from hxcomm to use

• init – Initialization to use

stadls::vx::v3::ReinitStackEntry create_reinit_stack_entry()

Create entry on reinit stack.

Returns

Created reinit stack entry

std::string get_bitfile_info() const

Get bitfile information.

Returns

Bitfile info

std::string get_remote_repo_state() const

Get server-side remote repository state information.

Only non-empty for hxcomm connection being QuiggeldyConnection.

Returns

Repository state

hxcomm::ConnectionTimeInfo get_time_info() const

Get time information of execution(s).

Returns

Time information

std::string get_unique_identifier(std::optional<std::string> const &hwdb_path) const

Get unique identifier from hwdb.

Parameters

hwdb_path – Optional path to hwdb

Returns

Unique identifier

bool is_quiggeldy() const

Get whether owned hxcomm connection is QuiggeldyConnection.

Returns

Boolean value

hxcomm::vx::ConnectionVariant &&release()

Release ownership of hxcomm connection.

Returns

Previously owned hxcomm connection

Private Members

hxcomm::vx::ConnectionVariant m_connection

size_t m_expected_link_notification_count

Expected highspeed link notification count in run().

During initialization the notification count is expected to match the number of enabled links, afterwards, no (zero) notifications are expected.

stadls::vx::v3::ReinitStackEntry m_init

Reinit stack entry of initialization for reapplication.

Friends

friend stadls::vx::RunTimeInfo run(Connection&, stadls::vx::v3::PlaybackProgram&&)

Execute given playback program using the given connection.

Parameters

• connection – Connection to run on

• program – Program to execute

Returns

Run time information of execution

friend stadls::vx::RunTimeInfo run(Connection&, stadls::vx::v3::PlaybackProgram&)

Execute given playback program using the given connection.

Parameters

• connection – Connection to run on

• program – Program to execute

Returns

Run time information of execution

struct grenade::vx::execution::detail::ConnectionStateStorage

#include <connection_state_storage.h>

Public Functions

ConnectionStateStorage(bool enable_differential_config, backend::Connection &connection)

Construct connection state storage with differential mode flag and connection.

The connection is used to construct the reinit stack entries.

Parameters

• enable_differential_config – Whether to enable differential config mode for this connection

• connection – Connection to construct reinit stack entries from

Public Members

lola::vx::v3::Chip current_config

std::vector<fisch::vx::word_access_type::Omnibus> current_config_words

bool enable_differential_config

std::mutex mutex

stadls::vx::v3::ReinitStackEntry reinit_base

stadls::vx::v3::ReinitStackEntry reinit_capmem_settling_wait

stadls::vx::v3::ReinitStackEntry reinit_differential

stadls::vx::v3::ReinitStackEntry reinit_schedule_out_replacement

stadls::vx::v3::ReinitStackEntry reinit_trigger

class grenade::vx::execution::detail::ExecutionInstanceBuilder

#include <execution_instance_builder.h>

Builder for a single ExecutionInstance.

Vertices are processed resulting in a playback sequence and result structure. Once executed, the result structure stores resulting measurements which can be processed to be fed back into a graph executor.

Public Functions

ExecutionInstanceBuilder(signal_flow::Graph const &graph, common::ExecutionInstanceID const &execution_instance, signal_flow::InputData const &input_list, signal_flow::Data const &data_output, std::optional<lola::vx::v3::PPUElfFile::symbols_type> const &ppu_symbols, signal_flow::ExecutionInstanceHooks &hooks)

Construct builder.

Parameters

• graph – Graph to use for locality and property lookup

• execution_instance – Local execution instance to build for

• input_list – Input list to use for input data lookup

• data_output – Data output from depended-on executions to use for data lookup

• chip_config – Chip configuration to use

• hooks – Playback sequences to inject

Ret generate(Usages before, Usages after)

Generate playback sequence.

Returns

PlaybackPrograms generated via local graph traversal

void post_process(signal_flow::Graph::vertex_descriptor const vertex)

signal_flow::OutputData post_process(std::vector<stadls::vx::v3::PlaybackProgram> const &realtime)

Postprocess by visit of all local vertices to be post processed after execution.

This resets the internal state of the builder to be ready for the next time step.

Returns

signal_flow::OutputData of locally computed results

Usages pre_process()

Preprocess by single visit of all local vertices.

Public Members

bool enable_cadc_baseline = true

Switch to enable CADC baseline read before each sent input vector.

If disabled, the membrane resting potential is assumed to reside at CADC value 128.

Private Types

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::v3::HemisphereOnDLS> ticket_request_type

Private Functions

template<typename T>
void filter_events(std::vector<std::vector<T>> &filtered_data, std::vector<T> &&data) const

Filter events via batch entry runtime and recording interval.

The input data is to be modified because of sorting in-place.

Parameters

• filtered_data – Filtered data per batch

• data – Event sequence

Returns

Event sequences split for the batch entries with relative chip times

bool has_complete_input_list() const

Get whether input list is complete for the local execution instance.

Returns

Boolean value

bool inputs_available(signal_flow::Graph::vertex_descriptor const descriptor) const

Check if any incoming vertex requires post processing.

Parameters

descriptor – Vertex descriptor to check for

Returns

Boolean value

template<typename Vertex>
void process(signal_flow::Graph::vertex_descriptor const vertex, Vertex const &data)

Process single vertex.

This function is called in both preprocess and postprocess depending on whether the vertex requires post-execution processing.

Parameters

• vertex – Vertex descriptor

• data – Data associated with vertex

Private Members

std::vector<BatchEntry> m_batch_entries

std::optional<signal_flow::vertex::CADCMembraneReadoutView::Mode> m_cadc_readout_mode

std::vector<stadls::vx::v3::PlaybackProgram> m_chunked_program

signal_flow::Data const &m_data_output

std::optional<signal_flow::Graph::vertex_descriptor> m_event_input_vertex

std::optional<signal_flow::Graph::vertex_descriptor> m_event_output_vertex

common::ExecutionInstanceID m_execution_instance

signal_flow::Graph const &m_graph

bool m_has_plasticity_rule = {false}

signal_flow::ExecutionInstanceHooks &m_hooks

signal_flow::InputData const &m_input_list

signal_flow::Data m_local_data

signal_flow::OutputData m_local_data_output

std::optional<signal_flow::Graph::vertex_descriptor> m_madc_readout_vertex

generator::NeuronResetMask m_neuron_resets

std::vector<signal_flow::Graph::vertex_descriptor> m_post_vertices

bool m_postprocessing

std::optional<lola::vx::v3::PPUElfFile::symbols_type> m_ppu_symbols

ticket_request_type m_ticket_requests

struct grenade::vx::execution::detail::ExecutionInstanceBuilder::BatchEntry

Public Types

typedef std::optional<stadls::vx::AbsoluteTimePlaybackProgramContainerTicket> event_guard_ticket_type

typedef std::map<std::string, std::variant<std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, stadls::vx::v3::ContainerTicket>, stadls::vx::v3::ContainerTicket>> ppu_symbol_ticket_type

typedef halco::common::typed_array<std::optional<stadls::vx::v3::ContainerTicket>, halco::hicann_dls::vx::PPUOnDLS> ticket_extmem_type

typedef halco::common::typed_array<std::optional<stadls::vx::v3::ContainerTicket>, halco::hicann_dls::vx::PPUOnDLS> ticket_ppu_type

Public Members

ticket_extmem_type m_extmem_result

std::map<signal_flow::Graph::vertex_descriptor, std::optional<stadls::vx::v3::ContainerTicket>> m_plasticity_rule_recorded_scratchpad_memory

ticket_ppu_type m_ppu_mailbox

halco::common::typed_array<std::optional<stadls::vx::AbsoluteTimePlaybackProgramContainerTicket>, halco::hicann_dls::vx::PPUOnDLS> m_ppu_result

ticket_ppu_type m_ppu_scheduler_event_drop_count

ticket_ppu_type m_ppu_scheduler_finished

std::vector<ticket_ppu_type> m_ppu_timer_event_drop_count

event_guard_ticket_type m_ticket_events_begin

event_guard_ticket_type m_ticket_events_end

ppu_symbol_ticket_type ppu_symbols

struct grenade::vx::execution::detail::ExecutionInstanceBuilder::RealtimeSnippet

#include <execution_instance_builder.h>

Public Members

stadls::vx::v3::AbsoluteTimePlaybackProgramBuilder builder

stadls::vx::v3::PlaybackProgramBuilder ppu_finish_builder

haldls::vx::v3::Timer::Value pre_realtime_duration

haldls::vx::v3::Timer::Value realtime_duration

struct grenade::vx::execution::detail::ExecutionInstanceBuilder::Ret

#include <execution_instance_builder.h>

Public Members

stadls::vx::v3::PlaybackProgramBuilder arm_madc

std::vector<RealtimeSnippet> realtimes

stadls::vx::v3::PlaybackProgramBuilder start_ppu

stadls::vx::v3::PlaybackProgramBuilder stop_ppu

struct grenade::vx::execution::detail::ExecutionInstanceBuilder::Usages

#include <execution_instance_builder.h>

Public Members

bool event_recording

bool madc_recording

class grenade::vx::execution::detail::ExecutionInstanceConfigVisitor

#include <execution_instance_config_visitor.h>

Visitor of graph vertices of a single execution instance for construction of the initial configuration.

The result is applied to a given configuration object.

Public Functions

ExecutionInstanceConfigVisitor(signal_flow::Graph const &graph, common::ExecutionInstanceID const &execution_instance, lola::vx::v3::Chip &config)

Construct visitor.

Parameters

• graph – Graph to use for locality and property lookup

• execution_instance – Local execution instance to visit

• config – Configuration to alter

std::tuple<lola::vx::v3::Chip&, std::optional<lola::vx::v3::PPUElfFile::symbols_type>> operator()()

Perform visit operation and generate initial configuration.

Returns

Reference to altered chip object and optional PPU program symbols

Private Functions

void pre_process()

Preprocess by single visit of all local vertices.

template<typename Vertex>
void process(signal_flow::Graph::vertex_descriptor const vertex, Vertex const &data)

Process single vertex.

This function is called in preprocess.

Parameters

• vertex – Vertex descriptor

• data – Data associated with vertex

Private Members

lola::vx::v3::Chip &m_config

halco::common::typed_array<bool, halco::hicann_dls::vx::v3::NeuronResetOnDLS> m_enabled_neuron_resets

common::ExecutionInstanceID m_execution_instance

signal_flow::Graph const &m_graph

bool m_has_periodic_cadc_readout

std::vector<std::tuple<signal_flow::Graph::vertex_descriptor, signal_flow::vertex::PlasticityRule, std::vector<std::pair<halco::hicann_dls::vx::v3::SynramOnDLS, ppu::SynapseArrayViewHandle>>, std::vector<std::pair<halco::hicann_dls::vx::v3::NeuronRowOnDLS, ppu::NeuronViewHandle>>>> m_plasticity_rules

bool m_requires_ppu

bool m_used_madc

struct grenade::vx::execution::detail::ExecutionInstanceNode

#include <execution_instance_node.h>

Content of a execution node.

On invocation a node preprocesses a local part of the graph, builds a playback program for execution, executes it and postprocesses result data. Execution is triggered by an incoming message.

Public Functions

ExecutionInstanceNode(std::vector<signal_flow::OutputData> &data_maps, std::vector<std::reference_wrapper<signal_flow::InputData const>> const &input_data_maps, std::vector<std::reference_wrapper<signal_flow::Graph const>> const &graphs, common::ExecutionInstanceID const &execution_instance, halco::hicann_dls::vx::v3::DLSGlobal const &dls_global, std::vector<std::reference_wrapper<lola::vx::v3::Chip const>> const &configs, backend::Connection &connection, ConnectionStateStorage &connection_state_storage, signal_flow::ExecutionInstanceHooks &hooks)

void operator()(tbb::flow::continue_msg)

Private Members

std::vector<std::reference_wrapper<lola::vx::v3::Chip const>> configs

backend::Connection &connection

ConnectionStateStorage &connection_state_storage

std::vector<signal_flow::OutputData> &data_maps

halco::hicann_dls::vx::v3::DLSGlobal dls_global

common::ExecutionInstanceID execution_instance

std::vector<std::reference_wrapper<signal_flow::Graph const>> const &graphs

signal_flow::ExecutionInstanceHooks &hooks

std::vector<std::reference_wrapper<signal_flow::InputData const>> const &input_data_maps

log4cxx::LoggerPtr logger

struct grenade::vx::execution::detail::ExecutionInstanceNode::PlaybackPrograms

Public Members

bool has_hook_around_realtime

bool has_plasticity

std::vector<stadls::vx::v3::PlaybackProgram> realtime

struct grenade::vx::execution::detail::generator::MADCArm

#include <madc.h>

Generator for a playback program snippet from arming the MADC.

Public Types

typedef stadls::vx::v3::AbsoluteTimePlaybackProgramBuilder Builder

typedef haldls::vx::v3::Timer::Value Result

Protected Functions

stadls::vx::PlaybackGeneratorReturn<Builder, Result> generate() const

Friends

friend auto generate(MADCArm const&)

struct grenade::vx::execution::detail::generator::MADCStart

#include <madc.h>

Generator for a playback program snippet from starting the MADC.

Public Types

typedef stadls::vx::v3::AbsoluteTimePlaybackProgramBuilder Builder

typedef haldls::vx::v3::Timer::Value Result

Protected Functions

stadls::vx::PlaybackGeneratorReturn<Builder, Result> generate() const

Friends

friend auto generate(MADCStart const&)

struct grenade::vx::execution::detail::generator::MADCStop

#include <madc.h>

Generator for a playback program snippet from stopping the MADC.

Public Types

typedef stadls::vx::v3::AbsoluteTimePlaybackProgramBuilder Builder

typedef haldls::vx::v3::Timer::Value Result

Public Members

bool enable_power_down_after_sampling = {false}

Protected Functions

stadls::vx::PlaybackGeneratorReturn<Builder, Result> generate() const

Friends

friend auto generate(MADCStop const&)

class grenade::vx::execution::detail::generator::NeuronResetMask

#include <neuron_reset_mask.h>

Generator for neuron resets.

If all resets in a quad are to be resetted, more efficient packing is used.

Public Types

typedef stadls::vx::v3::AbsoluteTimePlaybackProgramBuilder Builder

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::v3::NeuronResetOnDLS> enable_resets_type

typedef haldls::vx::v3::Timer::Value Result

Public Functions

NeuronResetMask()

Public Members

halco::common::typed_array<bool, halco::hicann_dls::vx::v3::NeuronResetOnDLS> enable_resets

Enable reset value per neuron.

Protected Functions

stadls::vx::PlaybackGeneratorReturn<Builder, Result> generate() const

Friends

friend auto generate(NeuronResetMask const&)

struct grenade::vx::execution::detail::generator::PPUCommand

#include <ppu.h>

Generator for a playback program snippet from inserting a PPU command and blocking until completion.

Public Types

typedef stadls::vx::v3::AbsoluteTimePlaybackProgramBuilder Builder

typedef haldls::vx::v3::Timer::Value Result

Public Functions

inline PPUCommand(halco::hicann_dls::vx::v3::PPUMemoryWordOnPPU const &coord, grenade::vx::ppu::detail::Status const status)

Construct blocking PPU command.

Parameters

• coord – PPU memory location at chich to place the command and to poll

• status – Command to place

Protected Functions

stadls::vx::PlaybackGeneratorReturn<Builder, Result> generate() const

Private Members

halco::hicann_dls::vx::v3::PPUMemoryWordOnPPU m_coord

grenade::vx::ppu::detail::Status m_status

Friends

friend auto generate(PPUCommand const&)

class grenade::vx::execution::detail::generator::TimedSpikeToChipSequence

#include <timed_spike_to_chip_sequence.h>

Generator for a playback program snippet from a timed spike sequence.

Public Types

typedef stadls::vx::v3::AbsoluteTimePlaybackProgramBuilder Builder

typedef haldls::vx::v3::Timer::Value Result

Public Functions

inline TimedSpikeToChipSequence(signal_flow::TimedSpikeToChipSequence const &values)

Protected Functions

stadls::vx::PlaybackGeneratorReturn<Builder, Result> generate() const

Private Members

signal_flow::TimedSpikeToChipSequence const &m_values

Friends

friend auto generate(TimedSpikeToChipSequence const&)

class grenade::vx::execution::detail::PPUProgramGenerator

#include <ppu_program_generator.h>

Public Functions

PPUProgramGenerator() = default

void add(signal_flow::Graph::vertex_descriptor descriptor, signal_flow::vertex::PlasticityRule const &rule, std::vector<std::pair<halco::hicann_dls::vx::v3::SynramOnDLS, ppu::SynapseArrayViewHandle>> const &synapses, std::vector<std::pair<halco::hicann_dls::vx::v3::NeuronRowOnDLS, ppu::NeuronViewHandle>> const &neurons)

std::vector<std::string> done()

Public Members

bool has_periodic_cadc_readout = false

Private Members

std::vector<std::tuple<signal_flow::Graph::vertex_descriptor, signal_flow::vertex::PlasticityRule, std::vector<std::pair<halco::hicann_dls::vx::v3::SynramOnDLS, ppu::SynapseArrayViewHandle>>, std::vector<std::pair<halco::hicann_dls::vx::v3::NeuronRowOnDLS, ppu::NeuronViewHandle>>>> m_plasticity_rules

class grenade::vx::execution::JITGraphExecutor

#include <jit_graph_executor.h>

Just-in-time graph executor.

No partial playback stream is pre-generated and nothing is reused for another run with e.g. different input. This especially allows implementation without promise support, since before processing each new chip instance, all necessary results are already available by value.

Public Types

typedef std::map<common::ExecutionInstanceID, lola::vx::v3::Chip> ChipConfigs

typedef std::map<common::ExecutionInstanceID, std::shared_ptr<signal_flow::ExecutionInstanceHooks>> Hooks

typedef std::tuple<bool> init_parameters_type

Public Functions

JITGraphExecutor(bool enable_differential_config = true)

Construct executor with active connections from environment.

Parameters

enable_differential_config – Whether to enable differential configuration writes instead of full ones

JITGraphExecutor(std::map<halco::hicann_dls::vx::v3::DLSGlobal, backend::Connection> &&connections, bool enable_differential_config = true)

Construct executor with given active connections.

Parameters

• connections – Connections to acquire and provide

• enable_differential_config – Whether to enable differential configuration writes instead of full ones

std::set<halco::hicann_dls::vx::v3::DLSGlobal> contained_connections() const

Get identifiers of connections contained in executor.

Returns

Set of connection identifiers

std::map<halco::hicann_dls::vx::v3::DLSGlobal, std::string> get_bitfile_info() const

std::map<halco::hicann_dls::vx::v3::DLSGlobal, std::string> get_remote_repo_state() const

std::map<halco::hicann_dls::vx::v3::DLSGlobal, hxcomm::ConnectionTimeInfo> get_time_info() const

std::map<halco::hicann_dls::vx::v3::DLSGlobal, std::string> get_unique_identifier(std::optional<std::string> const &hwdb_path) const

std::map<halco::hicann_dls::vx::v3::DLSGlobal, backend::Connection> &&release_connections()

Release contained connections.

Returns

Connections to the associated hardware

Public Static Attributes

static constexpr char name[] = "JITGraphExecutor"

Private Functions

void check(signal_flow::Graph const &graph)

Check that graph can be executed.

This function combines is_executable_on and has_dangling_inputs.

Parameters

graph – Graph to check

bool is_executable_on(signal_flow::Graph const &graph)

Check whether the given graph can be executed.

Parameters

graph – Graph instance

Private Members

std::map<halco::hicann_dls::vx::v3::DLSGlobal, detail::ConnectionStateStorage> m_connection_state_storages

std::map<halco::hicann_dls::vx::v3::DLSGlobal, backend::Connection> m_connections

bool m_enable_differential_config

Friends

friend std::vector<signal_flow::OutputData> run(JITGraphExecutor &executor, std::vector<std::reference_wrapper<signal_flow::Graph const>> const &graphs, std::vector<std::reference_wrapper<ChipConfigs const>> const &configs, std::vector<std::reference_wrapper<signal_flow::InputData const>> const &inputs, Hooks &&hooks)

struct grenade::vx::network::AtomicNeuronOnExecutionInstance

#include <atomic_neuron_on_execution_instance.h>

Public Functions

AtomicNeuronOnExecutionInstance() = default

AtomicNeuronOnExecutionInstance(PopulationOnExecutionInstance population, size_t neuron_on_population, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron compartment_on_neuron, size_t atomic_neuron_on_compartment)

bool operator!=(AtomicNeuronOnExecutionInstance const &other) const

bool operator<(AtomicNeuronOnExecutionInstance const &other) const

bool operator<=(AtomicNeuronOnExecutionInstance const &other) const

bool operator==(AtomicNeuronOnExecutionInstance const &other) const

bool operator>(AtomicNeuronOnExecutionInstance const &other) const

bool operator>=(AtomicNeuronOnExecutionInstance const &other) const

Public Members

size_t atomic_neuron_on_compartment = {0}

halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron compartment_on_neuron = {}

size_t neuron_on_population = {0}

PopulationOnExecutionInstance population = {}

Friends

friend std::ostream &operator<<(std::ostream &os, AtomicNeuronOnExecutionInstance const &value)

struct grenade::vx::network::AtomicNeuronOnNetwork

#include <atomic_neuron_on_network.h>

Public Functions

AtomicNeuronOnNetwork() = default

AtomicNeuronOnNetwork(AtomicNeuronOnExecutionInstance const &atomic_neuron_on_execution_instance, common::ExecutionInstanceID const &execution_instance)

AtomicNeuronOnNetwork(PopulationOnNetwork population, size_t neuron_on_population, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron compartment_on_neuron, size_t atomic_neuron_on_compartment)

bool operator!=(AtomicNeuronOnNetwork const &other) const

bool operator<(AtomicNeuronOnNetwork const &other) const

bool operator<=(AtomicNeuronOnNetwork const &other) const

bool operator==(AtomicNeuronOnNetwork const &other) const

bool operator>(AtomicNeuronOnNetwork const &other) const

bool operator>=(AtomicNeuronOnNetwork const &other) const

Public Members

size_t atomic_neuron_on_compartment = {0}

halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron compartment_on_neuron = {}

size_t neuron_on_population = {0}

PopulationOnNetwork population = {}

Friends

friend std::ostream &operator<<(std::ostream &os, AtomicNeuronOnNetwork const &value)

struct grenade::vx::network::BackgroundSourcePopulation : public grenade::vx::common::EntityOnChip

#include <background_source_population.h>

Background source population.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

typedef std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, halco::hicann_dls::vx::v3::PADIBusOnPADIBusBlock> Coordinate

Placement of the source.

Public Functions

BackgroundSourcePopulation() = default

BackgroundSourcePopulation(size_t size, Coordinate const &coordinate, Config const &config, common::EntityOnChip::ChipCoordinate chip_coordinate = common::EntityOnChip::ChipCoordinate())

bool operator!=(BackgroundSourcePopulation const &other) const

bool operator!=(EntityOnChip const &other) const

bool operator==(BackgroundSourcePopulation const &other) const

bool operator==(EntityOnChip const &other) const

Public Members

ChipCoordinate chip_coordinate

struct grenade::vx::network::BackgroundSourcePopulation::Config config

Coordinate coordinate

size_t size = {0}

Number of individual sources.

Friends

friend std::ostream &operator<<(std::ostream &os, BackgroundSourcePopulation const &population)

struct grenade::vx::network::BackgroundSourcePopulation::Config

#include <background_source_population.h>

Configuration of the source.

Public Functions

bool operator!=(Config const &other) const

bool operator==(Config const &other) const

Public Members

bool enable_random

haldls::vx::v3::BackgroundSpikeSource::Period period

haldls::vx::v3::BackgroundSpikeSource::Rate rate

haldls::vx::v3::BackgroundSpikeSource::Seed seed

Friends

friend std::ostream &operator<<(std::ostream &os, Config const &config)

struct grenade::vx::network::CADCRecording : public grenade::vx::network::NeuronRecording

#include <cadc_recording.h>

CADC recording of a collection of neurons.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

Public Functions

CADCRecording() = default

CADCRecording(std::vector<Neuron> const &neurons, common::EntityOnChip::ChipCoordinate chip_coordinate = common::EntityOnChip::ChipCoordinate())

bool operator!=(EntityOnChip const &other) const

bool operator!=(NeuronRecording const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(NeuronRecording const &other) const

Public Members

ChipCoordinate chip_coordinate

std::vector<Neuron> neurons = {}

struct grenade::vx::network::ConnectionToHardwareRoutes

#include <connection_routing_result.h>

Translation of a single connection to a collection of hardware synapse routes to an atomic neuron circuit of the logical neuron’s target compartment.

Public Functions

bool operator!=(ConnectionToHardwareRoutes const &other) const

bool operator==(ConnectionToHardwareRoutes const &other) const

Public Members

std::vector<size_t> atomic_neurons_on_target_compartment

Indices of atomic neurons in target compartment.

Friends

friend std::ostream &operator<<(std::ostream &os, ConnectionToHardwareRoutes const &routes)

struct grenade::vx::network::Connectum

#include <connectum.h>

Public Functions

bool operator!=(Connectum const &other) const

bool operator==(Connectum const &other) const

Public Members

std::map<common::ExecutionInstanceID, std::vector<ConnectumConnection>> execution_instances

Friends

friend std::ostream &operator<<(std::ostream &os, Connectum const &connectum)

struct grenade::vx::network::ConnectumConnection

#include <connectum.h>

Public Types

typedef std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron> Source

Public Functions

bool operator!=(ConnectumConnection const &other) const

bool operator<(ConnectumConnection const &other) const

bool operator==(ConnectumConnection const &other) const

Public Members

size_t connection_on_projection

ProjectionOnNetwork projection

Receptor::Type receptor_type

Source source

halco::hicann_dls::vx::v3::SynapseOnSynapseRow synapse_on_row

halco::hicann_dls::vx::v3::SynapseRowOnDLS synapse_row

halco::hicann_dls::vx::v3::AtomicNeuronOnDLS target

lola::vx::v3::SynapseMatrix::Weight weight

Friends

friend std::ostream &operator<<(std::ostream &os, ConnectumConnection const &config)

struct grenade::vx::network::ExternalSourcePopulation : public grenade::vx::common::EntityOnChip

#include <external_source_population.h>

External source population.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

Public Functions

ExternalSourcePopulation() = default

ExternalSourcePopulation(size_t size, common::EntityOnChip::ChipCoordinate chip_coordinate = common::EntityOnChip::ChipCoordinate())

bool operator!=(EntityOnChip const &other) const

bool operator!=(ExternalSourcePopulation const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(ExternalSourcePopulation const &other) const

Public Members

ChipCoordinate chip_coordinate

size_t size = {0}

Number of individual sources.

Friends

friend std::ostream &operator<<(std::ostream &os, ExternalSourcePopulation const &population)

class grenade::vx::network::InputGenerator

#include <generate_input.h>

Public Functions

InputGenerator(NetworkGraph const &network_graph, size_t batch_size = 1)

void add(std::vector<common::Time> const &times, PopulationOnNetwork population)

void add(std::vector<std::vector<common::Time>> const &times, PopulationOnNetwork population)

void add(std::vector<std::vector<std::vector<common::Time>>> const &times, PopulationOnNetwork population)

signal_flow::InputData done()

Private Members

signal_flow::InputData m_data = {}

NetworkGraph const &m_network_graph

struct grenade::vx::network::InterExecutionInstanceProjection

#include <inter_execution_instance_projection.h>

InterExecutionInstanceProjection between populations.

Public Types

typedef std::vector<Connection> Connections

Point-to-point neuron connections type.

Public Functions

InterExecutionInstanceProjection() = default

InterExecutionInstanceProjection(Connections &&connections, PopulationOnNetwork population_pre, PopulationOnNetwork population_post)

InterExecutionInstanceProjection(Connections const &connections, PopulationOnNetwork population_pre, PopulationOnNetwork population_post)

bool operator!=(InterExecutionInstanceProjection const &other) const

bool operator==(InterExecutionInstanceProjection const &other) const

Public Members

Connections connections = {}

Point-to-point neuron connections.

PopulationOnNetwork population_post = {}

Descriptor to post-synaptic population.

PopulationOnNetwork population_pre = {}

Descriptor to pre-synaptic population.

Friends

friend std::ostream &operator<<(std::ostream &os, InterExecutionInstanceProjection const &projection)

struct grenade::vx::network::InterExecutionInstanceProjection::Connection

#include <inter_execution_instance_projection.h>

Single neuron connection.

Public Types

typedef std::pair<size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron> Index

Public Functions

Connection() = default

Connection(Index const &index_pre, Index const &index_post)

bool operator!=(Connection const &other) const

bool operator==(Connection const &other) const

Public Members

Index index_post

Index of neuron in post-synaptic population.

Index index_pre

Index of neuron in pre-synaptic population.

Friends

friend std::ostream &operator<<(std::ostream &os, Connection const &connection)

struct grenade::vx::network::InterExecutionInstanceProjectionOnNetwork : public halco::common::detail::RantWrapper<InterExecutionInstanceProjectionOnNetwork, size_t, (1ull << 32) - 1, 0>

#include <inter_execution_instance_projection_on_network.h>

Descriptor to be used to identify an inter-execution-instance projection on a network.

Public Functions

inline explicit constexpr InterExecutionInstanceProjectionOnNetwork(size_t const value = 0)

class grenade::vx::network::InvalidNetworkGraph : public virtual std::exception

#include <exception.h>

Exception describing an invalid network graph.

Public Functions

explicit InvalidNetworkGraph(std::string const &message)

Construct from cause message.

Parameters

message – Exception cause

virtual const char *what() const noexcept override

Get exception cause.

Returns

String describing cause of exception

Private Members

std::string const m_message

struct grenade::vx::network::MADCRecording : public grenade::vx::network::NeuronRecording

#include <madc_recording.h>

MADC recording of a single neuron.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

Public Functions

MADCRecording() = default

MADCRecording(std::vector<Neuron> const &neurons, common::EntityOnChip::ChipCoordinate chip_coordinate = common::EntityOnChip::ChipCoordinate())

bool operator!=(EntityOnChip const &other) const

bool operator!=(NeuronRecording const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(NeuronRecording const &other) const

Public Members

ChipCoordinate chip_coordinate

std::vector<Neuron> neurons = {}

struct grenade::vx::network::Network

#include <network.h>

Placed but not routed network consisting of populations and projections.

Public Functions

bool operator!=(Network const &other) const

bool operator==(Network const &other) const

Public Members

std::chrono::microseconds const construction_duration

Duration spent during construction of network.

This value is not compared in operator{==,!=}.

std::map<common::ExecutionInstanceID, ExecutionInstance> const execution_instances

std::map<InterExecutionInstanceProjectionOnNetwork, InterExecutionInstanceProjection> const inter_execution_instance_projections

std::vector<common::ExecutionInstanceID> const topologically_sorted_execution_instance_ids

Friends

friend std::ostream &operator<<(std::ostream &os, Network const &network)

struct grenade::vx::network::Network::ExecutionInstance

#include <network.h>

Part of network requiring synchronized execution and realtime communication.

Public Functions

bool operator!=(ExecutionInstance const &other) const

bool operator==(ExecutionInstance const &other) const

Public Members

std::optional<CADCRecording> cadc_recording

std::optional<MADCRecording> madc_recording

std::optional<PadRecording> pad_recording

std::map<PlasticityRuleOnExecutionInstance, PlasticityRule> plasticity_rules

std::map<PopulationOnExecutionInstance, std::variant<Population, ExternalSourcePopulation, BackgroundSourcePopulation>> populations

std::map<ProjectionOnExecutionInstance, Projection> projections

Friends

friend std::ostream &operator<<(std::ostream &os, ExecutionInstance const &execution_instance)

class grenade::vx::network::NetworkBuilder

#include <network_builder.h>

Public Functions

NetworkBuilder()

PopulationOnNetwork add(BackgroundSourcePopulation const &population, common::ExecutionInstanceID const &execution_instance = common::ExecutionInstanceID())

Add on-chip background spike source population.

Parameters

population – Population to add

void add(CADCRecording const &cadc_recording, common::ExecutionInstanceID const &execution_instance = common::ExecutionInstanceID())

Add CADC recording of a collection of neurons.

Only one CADC recording per network is allowed. If another recording is present at a recorded neuron, their source specification is required to match.

Parameters

cadc_recording – CADC recording to add

PopulationOnNetwork add(ExternalSourcePopulation const &population, common::ExecutionInstanceID const &execution_instance = common::ExecutionInstanceID())

Add off-chip population.

Parameters

population – Population to add

InterExecutionInstanceProjectionOnNetwork add(InterExecutionInstanceProjection const &projection)

Add inter-execution-instance projection between already added populations.

The projection is expected to be connecting different execution instances.

Parameters

projection – Projection to add

void add(MADCRecording const &madc_recording, common::ExecutionInstanceID const &execution_instance = common::ExecutionInstanceID())

Add MADC recording of a single neuron.

Only one MADC recording per network is allowed. If another recording is present at the recorded neuron, their source specification is required to match.

Parameters

madc_recording – MADC recording to add

void add(PadRecording const &pad_recording, common::ExecutionInstanceID const &execution_instance = common::ExecutionInstanceID())

Add pad recording of a collection of neurons.

Only one pad recording per network is allowed. If another recording is present at a recorded neuron, their source specification is required to match.

Parameters

pad_recording – pad recording to add

PlasticityRuleOnNetwork add(PlasticityRule const &plasticity_rule, common::ExecutionInstanceID const &execution_instance = common::ExecutionInstanceID())

PopulationOnNetwork add(Population const &population, common::ExecutionInstanceID const &execution_instance = common::ExecutionInstanceID())

Add on-chip population.

The population is expected to feature unique and unused neuron locations.

Parameters

population – Population to add

ProjectionOnNetwork add(Projection const &projection, common::ExecutionInstanceID const &execution_instance = common::ExecutionInstanceID())

Add projection between already added populations.

The projection is expected to be free of single connections present in already added projections. A single connection is considered equal, if it connects the same pre- and post-synaptic neurons and features the same receptor type.

Parameters

projection – Projection to add

std::shared_ptr<Network> done()

Private Types

typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::bidirectionalS, boost::no_property, boost::no_property> ExecutionInstanceGraph

Private Members

std::chrono::microseconds m_duration

ExecutionInstanceGraph m_execution_instance_graph

std::map<common::ExecutionInstanceID, ExecutionInstanceGraph::vertex_descriptor> m_execution_instance_vertices

std::map<common::ExecutionInstanceID, Network::ExecutionInstance> m_execution_instances

std::map<InterExecutionInstanceProjectionOnNetwork, InterExecutionInstanceProjection> m_inter_execution_instance_projections

log4cxx::LoggerPtr m_logger

struct grenade::vx::network::NetworkGraph

#include <network_graph.h>

Logical network representation.

Public Types

typedef std::vector<std::vector<PlacedConnection>> PlacedConnections

Public Functions

NetworkGraph() = default

signal_flow::Graph const &get_graph() const

Graph representing the network.

GraphTranslation const &get_graph_translation() const

Translation between unrouted and routed graph representation.

std::shared_ptr<Network> const &get_network() const

Underlying network.

std::vector<PlacedConnection> get_placed_connection(ProjectionOnNetwork descriptor, size_t index) const

PlacedConnections get_placed_connections(ProjectionOnNetwork descriptor) const

bool valid() const

Checks validity of hardware graph representation in relation to the abstract network.

This ensures all required elements and information being present as well as a functionally correct mapping and routing.

Private Members

std::chrono::microseconds m_construction_duration

signal_flow::Graph m_graph

GraphTranslation m_graph_translation

std::shared_ptr<Network> m_network

std::chrono::microseconds m_routing_duration

std::chrono::microseconds m_verification_duration

Friends

friend NetworkGraph build_network_graph(std::shared_ptr<Network> const &network, RoutingResult const &routing_result)

Build a hardware network representation for a given network.

Parameters

• network – Network for which to build hardware network representation

• routing_result – Routing result to use to build hardware network representation

friend NetworkGraphStatistics extract_statistics(NetworkGraph const &network_graph)

Extract statistics from network graph.

friend void update_network_graph(NetworkGraph &network_graph, std::shared_ptr<Network> const &network)

Update an exisiting hardware graph representation.

For this to work, no new routing has to have been required.

Parameters

• network_graph – Existing hardware graph representation to update or fill with newly built instance

• network – New network for which to update or build

struct grenade::vx::network::NetworkGraph::GraphTranslation

#include <network_graph.h>

Translation between unrouted and routed graph representation.

Public Members

std::map<common::ExecutionInstanceID, ExecutionInstance> execution_instances

struct grenade::vx::network::NetworkGraph::GraphTranslation::ExecutionInstance

#include <network_graph.h>

Public Types

typedef std::map<PopulationOnExecutionInstance, std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<std::pair<signal_flow::Graph::vertex_descriptor, size_t>>>>> Populations

Translation of Population neurons to (multiple) atomic neurons in signal-flow graph.

For each population (descriptor) a vector with equal ordering to the neurons of the population contains for each compartment on the logical neuron and for each atomic neuron on the logical neuron compartment a pair of signal-flow graph vertex descriptor and index of the corresponding atomic neuron on the signal-flow graph vertex property.

typedef std::map<ProjectionOnExecutionInstance, std::vector<std::vector<std::pair<signal_flow::Graph::vertex_descriptor, size_t>>>> Projections

Translation of Projection::Connection to synapses in signal-flow graph.

For each projection (descriptor) a vector with equal ordering to the connections of the projection contains possibly multiple signal-flow graph vertex descriptors and indices on synapses on the signal-flow graph vertex property.

typedef std::map<PopulationOnExecutionInstance, std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<std::optional<halco::hicann_dls::vx::v3::SpikeLabel>>>>> SpikeLabels

Spike labels corresponding to each neuron in a population.

For external populations these are the input spike labels, for internal population this is only given for populations with enabled recording.

Public Members

std::map<PopulationOnExecutionInstance, std::map<halco::hicann_dls::vx::HemisphereOnDLS, signal_flow::Graph::vertex_descriptor>> background_spike_source_vertices

Vertex descriptors of background spike sources.

std::vector<signal_flow::Graph::vertex_descriptor> cadc_sample_output_vertex

Vertex descriptor from which to extract recorded cadc sample data.

std::optional<signal_flow::Graph::vertex_descriptor> event_input_vertex

Vertex descriptor at which to insert external spike data.

std::optional<signal_flow::Graph::vertex_descriptor> event_output_vertex

Vertex descriptor from which to extract recorded spike data.

std::optional<signal_flow::Graph::vertex_descriptor> madc_sample_output_vertex

Vertex descriptor from which to extract recorded madc sample data.

std::map<PopulationOnExecutionInstance, std::map<halco::hicann_dls::vx::HemisphereOnDLS, signal_flow::Graph::vertex_descriptor>> neuron_vertices

Vertex descriptors of neuron views.

std::map<PlasticityRuleOnExecutionInstance, signal_flow::Graph::vertex_descriptor> plasticity_rule_output_vertices

Vertex descriptor from which to extract recorded plasticity rule scratchpad memory.

std::map<PlasticityRuleOnExecutionInstance, signal_flow::Graph::vertex_descriptor> plasticity_rule_vertices

Vertex descriptor of plasticity rules.

Populations populations

Projections projections

SpikeLabels spike_labels

std::map<ProjectionOnExecutionInstance, std::map<halco::hicann_dls::vx::HemisphereOnDLS, signal_flow::Graph::vertex_descriptor>> synapse_vertices

Vertex descriptors of synapse views.

struct grenade::vx::network::NetworkGraph::PlacedConnection

#include <network_graph.h>

Public Members

halco::hicann_dls::vx::v3::SynapseOnSynapseRow synapse_on_row

Horizontal location.

halco::hicann_dls::vx::v3::SynapseRowOnDLS synapse_row

Vertical location.

lola::vx::v3::SynapseMatrix::Weight weight

Weight of connection.

Friends

friend std::ostream &operator<<(std::ostream&, PlacedConnection const&)

class grenade::vx::network::NetworkGraphBuilder

#include <network_graph_builder.h>

Network graph builder wrapper for network.

Public Functions

NetworkGraphBuilder(Network const &network)

void add_background_spike_sources(signal_flow::Graph &graph, Resources &resources, common::ExecutionInstanceID const &instance, RoutingResult const &routing_result) const

void add_cadc_recording(signal_flow::Graph &graph, Resources &resources, CADCRecording const &cadc_recording, common::ExecutionInstanceID const &instance) const

void add_crossbar_node(signal_flow::Graph &graph, Resources &resources, halco::hicann_dls::vx::CrossbarNodeOnDLS const &coordinate, RoutingResult const &connection_result, common::ExecutionInstanceID const &instance) const

void add_external_input(signal_flow::Graph &graph, Resources &resources, common::ExecutionInstanceID const &instance) const

void add_external_output(signal_flow::Graph &graph, Resources &resources, RoutingResult const &connection_result, common::ExecutionInstanceID const &instance) const

void add_madc_recording(signal_flow::Graph &graph, Resources &resources, MADCRecording const &madc_recording, common::ExecutionInstanceID const &instance) const

void add_neuron_event_output(signal_flow::Graph &graph, Resources &resources, halco::hicann_dls::vx::NeuronEventOutputOnDLS const &coordinate, common::ExecutionInstanceID const &instance) const

void add_neuron_event_outputs(signal_flow::Graph &graph, Resources &resources, common::ExecutionInstanceID const &instance) const

void add_pad_recording(signal_flow::Graph &graph, Resources const &resources, PadRecording const &cadc_recording, common::ExecutionInstanceID const &instance) const

void add_padi_bus(signal_flow::Graph &graph, Resources &resources, halco::hicann_dls::vx::PADIBusOnDLS const &coordinate, common::ExecutionInstanceID const &instance) const

void add_plasticity_rules(signal_flow::Graph &graph, Resources &resources, common::ExecutionInstanceID const &instance) const

void add_population(signal_flow::Graph &graph, Resources &resources, std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, std::vector<signal_flow::Input>> const &input, PopulationOnExecutionInstance const &descriptor, RoutingResult const &connection_result, common::ExecutionInstanceID const &instance) const

void add_populations(signal_flow::Graph &graph, Resources &resources, RoutingResult const &connection_result, common::ExecutionInstanceID const &instance) const

std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, signal_flow::Input> add_projection_from_background_spike_source(signal_flow::Graph &graph, Resources &resources, ProjectionOnExecutionInstance const &descriptor, RoutingResult const &connection_result, common::ExecutionInstanceID const &instance) const

std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, signal_flow::Input> add_projection_from_external_input(signal_flow::Graph &graph, Resources &resources, ProjectionOnExecutionInstance const &descriptor, RoutingResult const &connection_result, common::ExecutionInstanceID const &instance) const

std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, signal_flow::Input> add_projection_from_internal_input(signal_flow::Graph &graph, Resources &resources, ProjectionOnExecutionInstance const &descriptor, RoutingResult const &connection_result, common::ExecutionInstanceID const &instance) const

void add_synapse_array_view_sparse(signal_flow::Graph &graph, Resources &resources, ProjectionOnExecutionInstance descriptor, RoutingResult const &connection_result, common::ExecutionInstanceID const &instance) const

void add_synapse_driver(signal_flow::Graph &graph, Resources &resources, halco::hicann_dls::vx::SynapseDriverOnDLS const &coordinate, RoutingResult const &connection_result, common::ExecutionInstanceID const &instance) const

void calculate_spike_labels(Resources &resources, RoutingResult const &connection_result, common::ExecutionInstanceID const &instance) const

common::EntityOnChip::ChipCoordinate get_chip_coordinate(common::ExecutionInstanceID const &instance) const

Public Static Functions

static std::vector<signal_flow::Input> get_inputs(signal_flow::Graph const &graph, signal_flow::Graph::vertex_descriptor descriptor)

Private Members

log4cxx::LoggerPtr m_logger

Network const &m_network

struct grenade::vx::network::NetworkGraphBuilder::Resources

#include <network_graph_builder.h>

Public Members

std::map<common::ExecutionInstanceID, ExecutionInstance> execution_instances

struct grenade::vx::network::NetworkGraphBuilder::Resources::ExecutionInstance

#include <network_graph_builder.h>

Public Members

std::optional<signal_flow::Graph::vertex_descriptor> crossbar_l2_input

std::map<halco::hicann_dls::vx::v3::CrossbarNodeOnDLS, signal_flow::Graph::vertex_descriptor> crossbar_nodes

NetworkGraph::GraphTranslation::ExecutionInstance graph_translation

std::map<halco::hicann_dls::vx::v3::NeuronEventOutputOnDLS, signal_flow::Graph::vertex_descriptor> neuron_event_outputs

std::map<halco::hicann_dls::vx::v3::PADIBusOnDLS, signal_flow::Graph::vertex_descriptor> padi_busses

std::map<PopulationOnExecutionInstance, PlacedPopulation> populations

std::map<ProjectionOnExecutionInstance, PlacedProjection> projections

std::map<halco::hicann_dls::vx::v3::SynapseDriverOnDLS, signal_flow::Graph::vertex_descriptor> synapse_drivers

struct grenade::vx::network::NetworkGraphBuilder::Resources::ExecutionInstance::PlacedPopulation

#include <network_graph_builder.h>

Public Members

std::map<halco::hicann_dls::vx::HemisphereOnDLS, signal_flow::Graph::vertex_descriptor> neurons

struct grenade::vx::network::NetworkGraphBuilder::Resources::ExecutionInstance::PlacedProjection

#include <network_graph_builder.h>

Public Members

std::map<halco::hicann_dls::vx::HemisphereOnDLS, signal_flow::Graph::vertex_descriptor> synapses

struct grenade::vx::network::NetworkGraphStatistics

#include <network_graph_statistics.h>

Statistics of network graph.

Public Functions

NetworkGraphStatistics() = default

std::chrono::microseconds get_abstract_network_construction_duration() const

Get duration spent constructing abstract network (Network).

std::map<common::ExecutionInstanceID, ExecutionInstance> const &get_execution_instances() const

std::chrono::microseconds get_hardware_network_construction_duration() const

Get duration spent constructing hardware network (NetworkGraph) given a routing result and abstract network.

std::chrono::microseconds get_routing_duration() const

Get duration spent routing the abstract network (Network).

std::chrono::microseconds get_verification_duration() const

Get duration spent verifying hardware network (NetworkGraph) for correct routing.

Private Members

std::chrono::microseconds m_abstract_network_construction_duration = {0}

std::map<common::ExecutionInstanceID, ExecutionInstance> m_execution_instances

std::chrono::microseconds m_hardware_network_construction_duration = {0}

std::chrono::microseconds m_routing_duration = {0}

std::chrono::microseconds m_verification_duration = {0}

Friends

friend NetworkGraphStatistics extract_statistics(NetworkGraph const &network_graph)

Extract statistics from network graph.

friend std::ostream &operator<<(std::ostream &os, NetworkGraphStatistics const &value)

struct grenade::vx::network::NetworkGraphStatistics::ExecutionInstance

#include <network_graph_statistics.h>

Public Functions

double get_neuron_usage() const

Get used fraction of neurons vs.

all hardware circuits.

size_t get_num_neurons() const

Get number of neurons in network graph.

This is the same amount as hardware circuits.

size_t get_num_populations() const

Get number of populations in network graph.

size_t get_num_projections() const

Get number of projections in network graph.

size_t get_num_synapse_drivers() const

Get number of synapse drivers in network graph.

This is the same amount as hardware circuits.

size_t get_num_synapses() const

Get number of synapses in network graph.

This is the same amount as hardware circuits.

double get_synapse_driver_usage() const

Get used fraction of synapse drivers vs.

all hardware circuits.

double get_synapse_usage() const

Get used fraction of synapses vs.

all hardware circuits.

Private Members

double m_neuron_usage = {0.}

size_t m_num_neurons = {0}

size_t m_num_populations = {0}

size_t m_num_projections = {0}

size_t m_num_synapse_drivers = {0}

size_t m_num_synapses = {0}

double m_synapse_driver_usage = {0.}

double m_synapse_usage = {0.}

Friends

friend NetworkGraphStatistics extract_statistics(NetworkGraph const &network_graph)

Extract statistics from network graph.

friend std::ostream &operator<<(std::ostream &os, ExecutionInstance const &value)

struct grenade::vx::network::NeuronRecording : public grenade::vx::common::EntityOnChip

#include <neuron_recording.h>

Neuron recording base class for MADC and CADC recording.

Subclassed by grenade::vx::network::CADCRecording, grenade::vx::network::MADCRecording

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

Public Functions

NeuronRecording() = default

NeuronRecording(std::vector<Neuron> const &neurons, common::EntityOnChip::ChipCoordinate chip_coordinate = common::EntityOnChip::ChipCoordinate())

bool operator!=(EntityOnChip const &other) const

bool operator!=(NeuronRecording const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(NeuronRecording const &other) const

Public Members

ChipCoordinate chip_coordinate

std::vector<Neuron> neurons = {}

struct grenade::vx::network::NeuronRecording::Neuron

#include <neuron_recording.h>

Public Types

typedef lola::vx::v3::AtomicNeuron::Readout::Source Source

Public Functions

Neuron() = default

Neuron(AtomicNeuronOnExecutionInstance const &coordinate, Source source)

bool operator!=(Neuron const &other) const

bool operator==(Neuron const &other) const

Public Members

AtomicNeuronOnExecutionInstance coordinate = {}

Source source = {Source::membrane}

struct grenade::vx::network::OnlyRecordingPlasticityRuleGenerator

#include <plasticity_rule_generator.h>

Public Types

enum class Observable

Observables, which can be recorded.

Values:

enumerator weights

enumerator correlation_causal

enumerator correlation_acausal

Public Functions

OnlyRecordingPlasticityRuleGenerator(std::set<Observable> const &observables)

PlasticityRule generate() const

Generate plasticity rule which only executes given recording.

Timing and projection information is left default/empty.

Private Members

std::set<Observable> m_observables

struct grenade::vx::network::PadRecording : public grenade::vx::common::EntityOnChip

#include <pad_recording.h>

Pad recording of neuron source(s).

This recording only forwards signals to the analog readout pad(s), no recorded data is available after execution.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

typedef std::map<halco::hicann_dls::vx::v3::PadOnDLS, Source> Recordings

Public Functions

PadRecording() = default

PadRecording(Recordings const &recordings, common::EntityOnChip::ChipCoordinate chip_coordinate = common::EntityOnChip::ChipCoordinate())

Construct pad recording.

Parameters

• recordings – Recordings to perform

• chip_coordinate – Chip coordinate to place pad recording on

bool operator!=(EntityOnChip const &other) const

bool operator!=(PadRecording const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(PadRecording const &other) const

Public Members

ChipCoordinate chip_coordinate

Recordings recordings

struct grenade::vx::network::PadRecording::Source

#include <pad_recording.h>

Public Functions

Source() = default

Source(NeuronRecording::Neuron const &neuron, bool enable_buffered)

bool operator!=(Source const &other) const

bool operator==(Source const &other) const

Public Members

bool enable_buffered = {false}

NeuronRecording::Neuron neuron = {}

struct grenade::vx::network::PlasticityRule

#include <plasticity_rule.h>

Plasticity rule.

Public Types

typedef signal_flow::vertex::PlasticityRule::RawRecording RawRecording

typedef signal_flow::vertex::PlasticityRule::RawRecordingData RawRecordingData

Recording data corresponding to a raw recording.

typedef signal_flow::vertex::PlasticityRule::Recording Recording

Recording memory provided to plasticity rule kernel and recorded after execution.

typedef std::variant<RawRecordingData, TimedRecordingData> RecordingData

Recorded data.

typedef signal_flow::vertex::PlasticityRule::TimedRecording TimedRecording

Recording information for execution of the rule.

Recording of exclusive scratchpad memory per rule invocation with time recording and returned data as time-annotated events.

Public Functions

PlasticityRule() = default

bool operator!=(PlasticityRule const &other) const

bool operator==(PlasticityRule const &other) const

Public Members

bool enable_requires_one_source_per_row_in_order = {false}

Enable whether this plasticity rule requires all projections to have one source per row and them being in order.

std::string kernel = {}

Plasticity rule kernel to be compiled into the PPU program.

std::vector<PopulationHandle> populations

std::vector<ProjectionOnExecutionInstance> projections = {}

Descriptor to projections this rule has access to.

All projections are required to be dense and in order.

std::optional<Recording> recording

struct grenade::vx::network::PlasticityRule::Timer timer

Friends

friend std::ostream &operator<<(std::ostream &os, PlasticityRule const &plasticity_rule)

struct grenade::vx::network::PlasticityRule::PopulationHandle

#include <plasticity_rule.h>

Population handle parameters.

Public Types

typedef lola::vx::v3::AtomicNeuron::Readout::Source NeuronReadoutSource

Public Functions

bool operator!=(PopulationHandle const &other) const

bool operator==(PopulationHandle const &other) const

Public Members

PopulationOnExecutionInstance descriptor

Descriptor of population.

std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<std::optional<NeuronReadoutSource>>>> neuron_readout_sources

Readout source specification per neuron circuit used for static configuration such that the plasticity rule can read the specified signal.

Friends

friend std::ostream &operator<<(std::ostream &os, PopulationHandle const &population)

struct grenade::vx::network::PlasticityRule::TimedRecordingData

#include <plasticity_rule.h>

Extracted recorded data of observables corresponding to timed recording.

Public Types

typedef signal_flow::vertex::PlasticityRule::TimedRecordingData::Entry EntryArray

typedef std::variant<std::vector<common::TimedDataSequence<std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<int8_t>>>>>, std::vector<common::TimedDataSequence<std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<uint8_t>>>>>, std::vector<common::TimedDataSequence<std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<int16_t>>>>>, std::vector<common::TimedDataSequence<std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<uint16_t>>>>>> EntryPerNeuron

Recording per logical neuron, where for each sample the outer dimension of the data are the logical neurons of the population and the inner dimensions are the performed recordings of the corresponding hardware neuron(s) per compartment.

typedef std::variant<std::vector<common::TimedDataSequence<std::vector<std::vector<int8_t>>>>, std::vector<common::TimedDataSequence<std::vector<std::vector<uint8_t>>>>, std::vector<common::TimedDataSequence<std::vector<std::vector<int16_t>>>>, std::vector<common::TimedDataSequence<std::vector<std::vector<uint16_t>>>>> EntryPerSynapse

Recording per logical synapse, where for each sample the outer dimension of the data are the logical synapses of the projection and the inner dimension are the performed recordings of the corresponding hardware synapse(s).

Public Members

std::map<std::string, EntryArray> data_array

std::map<std::string, std::map<PopulationOnExecutionInstance, EntryPerNeuron>> data_per_neuron

std::map<std::string, std::map<ProjectionOnExecutionInstance, EntryPerSynapse>> data_per_synapse

struct grenade::vx::network::PlasticityRule::Timer

#include <plasticity_rule.h>

Timing information for execution of the rule.

Public Functions

bool operator!=(Timer const &other) const

bool operator==(Timer const &other) const

Public Members

size_t num_periods

Value period

Value start

Friends

friend std::ostream &operator<<(std::ostream &os, Timer const &timer)

struct grenade::vx::network::PlasticityRule::Timer::Value : public halco::common::detail::RantWrapper<Value, uintmax_t, 0xffffffff, 0>

#include <plasticity_rule.h>

PPU clock cycles.

Public Functions

inline explicit constexpr Value(uintmax_t const value = 0)

struct grenade::vx::network::PlasticityRuleOnExecutionInstance : public halco::common::detail::RantWrapper<PlasticityRuleOnExecutionInstance, size_t, (1ull << 32) - 1, 0>

#include <plasticity_rule_on_execution_instance.h>

Descriptor to be used to identify a plasticity rule on an execution instance.

Public Functions

inline explicit constexpr PlasticityRuleOnExecutionInstance(size_t const value = 0)

struct grenade::vx::network::PlasticityRuleOnNetwork : public common::ExecutionInstanceIDMixin<PlasticityRuleOnNetwork, PlasticityRuleOnExecutionInstance>

#include <plasticity_rule_on_network.h>

Descriptor to be used to identify a plasticity rule on a network.

Public Functions

PlasticityRuleOnNetwork() = default

inline explicit PlasticityRuleOnNetwork(enum_type const &e)

inline explicit PlasticityRuleOnNetwork(PlasticityRuleOnExecutionInstance const &population, common::ExecutionInstanceID const &execution_instance = common::ExecutionInstanceID())

inline PlasticityRuleOnExecutionInstance toPlasticityRuleOnExecutionInstance() const

struct grenade::vx::network::Population : public grenade::vx::common::EntityOnChip

#include <population.h>

Population of on-chip neurons.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

typedef std::vector<Neuron> Neurons

List of on-chip neurons.

Public Functions

Population() = default

Population(Neurons const &neurons, common::EntityOnChip::ChipCoordinate chip_coordinate = common::EntityOnChip::ChipCoordinate())

std::set<halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> get_atomic_neurons() const

size_t get_atomic_neurons_size() const

bool operator!=(EntityOnChip const &other) const

bool operator!=(Population const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(Population const &other) const

bool valid() const

Check validity of projection config.

Public Members

ChipCoordinate chip_coordinate

Neurons neurons = {}

Friends

friend std::ostream &operator<<(std::ostream &os, Population const &population)

struct grenade::vx::network::Population::Neuron

#include <population.h>

On-chip neuron.

Public Types

typedef std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, Compartment> Compartments

typedef halco::hicann_dls::vx::v3::LogicalNeuronOnDLS Coordinate

Location and shape.

Public Functions

Neuron(Coordinate const &coordinate, Compartments const &compartments)

bool operator!=(Neuron const &other) const

bool operator==(Neuron const &other) const

bool valid() const

Check validity of neuron config.

Public Members

Compartments compartments

Coordinate coordinate

Friends

friend std::ostream &operator<<(std::ostream &os, Neuron const &config)

struct grenade::vx::network::Population::Neuron::Compartment

#include <population.h>

Compartment properties.

Public Types

typedef std::vector<std::unordered_set<Receptor>> Receptors

Receptors per atomic neuron on compartment.

Public Functions

Compartment(std::optional<SpikeMaster> const &spike_master, Receptors const &receptors)

bool operator!=(Compartment const &other) const

bool operator==(Compartment const &other) const

Public Members

Receptors receptors

std::optional<SpikeMaster> spike_master

Friends

friend std::ostream &operator<<(std::ostream &os, Compartment const &config)

struct grenade::vx::network::Population::Neuron::Compartment::SpikeMaster

#include <population.h>

The spike master is used for outgoing connections and recording of spikes.

Not every compartment is required to feature a spike master, e.g. if it is passive.

Public Functions

SpikeMaster(size_t neuron_on_compartment, bool enable_record_spikes)

bool operator!=(SpikeMaster const &other) const

bool operator==(SpikeMaster const &other) const

Public Members

bool enable_record_spikes

Enable spike recording.

size_t neuron_on_compartment

Index of neuron on compartment.

Friends

friend std::ostream &operator<<(std::ostream &os, SpikeMaster const &config)

struct grenade::vx::network::PopulationOnExecutionInstance : public halco::common::detail::RantWrapper<PopulationOnExecutionInstance, size_t, (1ull << 32) - 1, 0>

#include <population_on_execution_instance.h>

Descriptor to be used to identify a population on an execution instance.

Public Functions

inline explicit constexpr PopulationOnExecutionInstance(size_t const value = 0)

struct grenade::vx::network::PopulationOnNetwork : public common::ExecutionInstanceIDMixin<PopulationOnNetwork, PopulationOnExecutionInstance>

#include <population_on_network.h>

Descriptor to be used to identify a population on a network.

Public Functions

PopulationOnNetwork() = default

inline explicit PopulationOnNetwork(enum_type const &e)

inline explicit PopulationOnNetwork(PopulationOnExecutionInstance const &population, common::ExecutionInstanceID const &execution_instance = common::ExecutionInstanceID())

inline PopulationOnExecutionInstance toPopulationOnExecutionInstance() const

struct grenade::vx::network::Projection : public grenade::vx::common::EntityOnChip

#include <projection.h>

Projection between populations.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

typedef std::vector<Connection> Connections

Point-to-point neuron connections type.

Public Functions

Projection() = default

Projection(Receptor const &receptor, Connections &&connections, PopulationOnExecutionInstance population_pre, PopulationOnExecutionInstance population_post, common::EntityOnChip::ChipCoordinate chip_coordinate = common::EntityOnChip::ChipCoordinate())

Projection(Receptor const &receptor, Connections const &connections, PopulationOnExecutionInstance population_pre, PopulationOnExecutionInstance population_post, common::EntityOnChip::ChipCoordinate chip_coordinate = common::EntityOnChip::ChipCoordinate())

bool operator!=(EntityOnChip const &other) const

bool operator!=(Projection const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(Projection const &other) const

Public Members

ChipCoordinate chip_coordinate

Connections connections = {}

Point-to-point neuron connections.

PopulationOnExecutionInstance population_post = {}

Descriptor to post-synaptic population.

PopulationOnExecutionInstance population_pre = {}

Descriptor to pre-synaptic population.

Receptor receptor

Receptor type.

Friends

friend std::ostream &operator<<(std::ostream &os, Projection const &projection)

struct grenade::vx::network::Projection::Connection

#include <projection.h>

Single neuron connection.

Public Types

typedef std::pair<size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron> Index

Public Functions

Connection() = default

Connection(Index const &index_pre, Index const &index_post, Weight weight)

bool operator!=(Connection const &other) const

bool operator==(Connection const &other) const

Public Members

Index index_post

Index of neuron in post-synaptic population.

Index index_pre

Index of neuron in pre-synaptic population.

Weight weight

Weight of connection.

Friends

friend std::ostream &operator<<(std::ostream &os, Connection const &connection)

struct grenade::vx::network::Projection::Connection::Weight : public halco::common::detail::BaseType<Weight, size_t>

#include <projection.h>

Public Functions

inline explicit constexpr Weight(value_type const value = 0)

struct grenade::vx::network::ProjectionOnExecutionInstance : public halco::common::detail::RantWrapper<ProjectionOnExecutionInstance, size_t, (1ull << 32) - 1, 0>

#include <projection_on_execution_instance.h>

Descriptor to be used to identify a projection on an execution instance.

Public Functions

inline explicit constexpr ProjectionOnExecutionInstance(size_t const value = 0)

struct grenade::vx::network::ProjectionOnNetwork : public common::ExecutionInstanceIDMixin<ProjectionOnNetwork, ProjectionOnExecutionInstance>

#include <projection_on_network.h>

Descriptor to be used to identify a projection on a network.

Public Functions

ProjectionOnNetwork() = default

inline explicit ProjectionOnNetwork(enum_type const &e)

inline explicit ProjectionOnNetwork(ProjectionOnExecutionInstance const &projection, common::ExecutionInstanceID const &execution_instance = common::ExecutionInstanceID())

inline ProjectionOnExecutionInstance toProjectionOnExecutionInstance() const

struct grenade::vx::network::Receptor

#include <receptor.h>

Receptor description of a neuron (compartment).

Public Types

enum class Type

Receptor type.

Values:

enumerator excitatory

enumerator inhibitory

Public Functions

Receptor() = default

Receptor(ID id, Type type)

size_t hash() const

bool operator!=(Receptor const &other) const

bool operator==(Receptor const &other) const

Public Members

ID id

Type type

Friends

friend size_t hash_value(Receptor const &receptor)

friend std::ostream &operator<<(std::ostream &os, Receptor const &receptor)

struct grenade::vx::network::Receptor::ID : public halco::common::detail::BaseType<ID, size_t>

#include <receptor.h>

ID of receptor.

Public Functions

inline explicit constexpr ID(value_type const value = 0)

struct grenade::vx::network::routing::greedy::detail::SourceOnPADIBusManager

#include <source_on_padi_bus_manager.h>

Public Types

typedef grenade::vx::network::routing::greedy::SourceOnPADIBusManager::BackgroundSource BackgroundSource

typedef grenade::vx::network::routing::greedy::SourceOnPADIBusManager::ExternalSource ExternalSource

typedef grenade::vx::network::routing::greedy::SourceOnPADIBusManager::InternalSource InternalSource

typedef grenade::vx::network::routing::greedy::SourceOnPADIBusManager::Label Label

typedef grenade::vx::network::routing::greedy::SourceOnPADIBusManager::Partition Partition

typedef grenade::vx::network::routing::greedy::SourceOnPADIBusManager::SynapseDriver SynapseDriver

Public Static Functions

static std::optional<halco::common::typed_array<std::vector<std::vector<size_t>>, halco::hicann_dls::vx::v3::PADIBusOnDLS>> distribute_external_sources_linear(std::vector<ExternalSource> const &sources, halco::common::typed_array<size_t, halco::hicann_dls::vx::v3::PADIBusOnDLS> const &used_num_synapse_drivers)

Distribute external sources onto PADI-busses given the distribution of internal and background sources.

The algorithm fills synapse drivers on PADI-busses in Enum-order.

Parameters

• sources – All external sources containing their out-degree to neurons

• used_synapse_drivers – Number of used synapse drivers per PADI-bus

Returns

Indices into external source collection distributed onto PADI-busses. If no distribution is found, returns none.

static std::vector<SynapseDriverOnDLSManager::AllocationRequest> get_allocation_requests_background(std::vector<std::vector<size_t>> const &filter, halco::hicann_dls::vx::v3::PADIBusOnDLS const &padi_bus, std::vector<size_t> const &num_synapse_drivers)

Get allocation requests for filtered background sources.

Parameters

• filter – List of indices into sources, split into chunks

• padi_bus – PADI-bus location

• num_synapse_drivers – Number of synapse driver required for each chunk of sources

Returns

Allocation requests for synapse driver allocation algorithm

static SynapseDriverOnDLSManager::AllocationRequest get_allocation_requests_external(halco::hicann_dls::vx::v3::PADIBusOnDLS const &padi_bus, size_t num_synapse_drivers)

Get allocation requests for external sources.

Parameters

• padi_bus – PADI-bus location

• num_synapse_drivers – Number of synapse driver required for each chunk of sources

Returns

Allocation requests for synapse driver allocation algorithm

static std::vector<SynapseDriverOnDLSManager::AllocationRequest> get_allocation_requests_internal(std::vector<std::vector<size_t>> const &filter, halco::hicann_dls::vx::v3::PADIBusOnPADIBusBlock const &padi_bus, halco::hicann_dls::vx::v3::NeuronBackendConfigBlockOnDLS const &backend_block, halco::common::typed_array<std::vector<size_t>, halco::hicann_dls::vx::v3::PADIBusOnDLS> const &num_synapse_drivers)

Get allocation requests for filtered internal sources.

Parameters

• filter – List of indices into sources, split into chunks

• padi_bus – PADI-bus location

• num_synapse_drivers – Number of synapse driver required for each chunk of sources

Returns

Allocation requests

template<typename S>
static halco::common::typed_array<size_t, halco::hicann_dls::vx::v3::PADIBusBlockOnDLS> get_num_synapse_drivers(std::vector<S> const &sources, std::vector<size_t> const &filter)

Get number of synapse drivers required to place the synapses for the filtered sources.

Parameters

• sources – All sources containing their out-degree to neurons

• filter – List of indices in sources to filter for calculation

Returns

Number of required synapse drivers per PADI-bus

static std::vector<std::vector<size_t>> split_linear(std::vector<size_t> const &filter)

Split list of indices into source vector into chunks of synapse label size.

Split is performed as [0, Label::size), [Label::size, …), … .

Parameters

filter – List of indices to split

Returns

Chunks of lists of indices

struct grenade::vx::network::routing::greedy::detail::SynapseDriverOnDLSManager

#include <synapse_driver_on_dls_manager.h>

Implementation details of the allocation manager for all PADI-busses.

Public Types

typedef grenade::vx::network::routing::greedy::SynapseDriverOnDLSManager::Allocation Allocation

typedef grenade::vx::network::routing::greedy::SynapseDriverOnDLSManager::AllocationPolicy AllocationPolicy

typedef grenade::vx::network::routing::greedy::SynapseDriverOnDLSManager::AllocationRequest AllocationRequest

typedef std::map<halco::hicann_dls::vx::v3::PADIBusOnDLS, std::pair<std::vector<SynapseDriverOnPADIBusManager::AllocationRequest>, std::vector<size_t>>> AllocationRequestPerPADIBus

Allocation requests ordered by PADI-bus.

Template Parameters

• Key – PADI-bus location

• Value – Vector of single allocation requests and indices in the complete list of requested allocations

typedef grenade::vx::network::routing::greedy::SynapseDriverOnDLSManager::Label Label

typedef grenade::vx::network::routing::greedy::SynapseDriverOnDLSManager::SynapseDriver SynapseDriver

Public Static Functions

static std::vector<size_t> get_independent_allocation_requests(std::vector<AllocationRequest> const &requested_allocations, std::set<halco::hicann_dls::vx::v3::PADIBusOnDLS> const &padi_busses)

Get allocation requests on the specified PADI-busses, which are not part of a dependent label group.

Parameters

• requested_allocations – Requested allocations

• padi_busses – PADI-bus collection to filter requests for

Returns

List of indices in requested_allocations

static std::set<std::set<halco::hicann_dls::vx::v3::PADIBusOnDLS>> get_interdependent_padi_busses(std::vector<AllocationRequest> const &requested_allocations)

Get PADI-bus collections for which overarching allocation requests exist.

For example the allocation requests A{PADIBusOnDLS(1), PADIBusOnDLS(3)} and B{PADIBusOnDLS(3), PADIBusOnDLS(4)} lead to the PADI-bus collection {PADIBusOnDLS(1), PADIBusOnDLS(3), PADIBusOnDLS(4)}.

Parameters

requested_allocations – Requested allocations from which to extract interdependent collections

static std::vector<int64_t> get_label_space(std::vector<size_t> const &independent_allocation_requests, std::vector<AllocationRequest::DependentLabelGroup> const &unique_dependent_label_groups, std::vector<AllocationRequest> const &requested_allocations)

Get label space.

The independent allocation requests are placed first in the label space, the dependent label groups are placed afterwards.

Parameters

• independent_allocation_requests – Independent allocation request indices

• unique_dependent_label_groups – Unique dependent label groups

• requested_allocations – Requested allocations

Returns

Label space

static size_t get_label_space_index(std::vector<size_t> const &independent_allocation_requests, std::vector<AllocationRequest::DependentLabelGroup> const &unique_dependent_label_groups, std::vector<AllocationRequest> const &requested_allocations, size_t index)

Get index in label space for specified requested allocation.

Parameters

• independent_allocation_requests – Independent allocation request indices

• unique_dependent_label_groups – Unique dependent label groups

• requested_allocations – Requested allocations

• index – Index into requested allocations

Returns

Index into label space

static AllocationRequestPerPADIBus get_requested_allocations_per_padi_bus(std::vector<AllocationRequest> const &requested_allocations)

Get allocation requests per PADI-bus.

The label value is not filled and will be set according to label indices for each allocation trial.

Parameters

requested_allocations – Requested allocations

Returns

Requested allocations ordered by PADI-busses

static std::vector<AllocationRequest::DependentLabelGroup> get_unique_dependent_label_groups(std::vector<AllocationRequest> const &requested_allocations, std::set<halco::hicann_dls::vx::v3::PADIBusOnDLS> const &padi_busses)

Get unique dependent label groups on specified PADI-busses.

Parameters

• requested_allocations – Requested allocations

• padi_busses – PADI-bus collections to filter request for

static void update_labels(AllocationRequestPerPADIBus::mapped_type &requested_allocation, std::vector<AllocationRequest> const &requested_allocations, std::vector<int64_t> const &label_indices, std::vector<size_t> const &independent_allocation_requests, std::vector<AllocationRequest::DependentLabelGroup> const &unique_dependent_label_groups)

Update label values of PADI-bus-local requested allocations according to indices in label space.

Updating instead of generation is chosen because this operation is performed many times.

Parameters

• requested_allocation – PADI-bus-local requested allocations

• requested_allocations – All requested allocations

• label_indices – Indices in label space for lookup of label values

• independent_allocation_requests – Independent allocation requests required for translation of a value in label_indices to requested allocations

• unique_dependent_label_groups – Unique dependent label groups required for translation of a value in label_indices to requested allocations

static void update_solution(std::vector<Allocation> &allocation, std::vector<SynapseDriverOnPADIBusManager::Allocation> const &local_allocations, AllocationRequestPerPADIBus::mapped_type const &requested_allocation, halco::hicann_dls::vx::v3::PADIBusOnDLS const &padi_bus, std::vector<AllocationRequest> const &requested_allocations, std::vector<int64_t> const &label_indices, std::vector<size_t> const &independent_allocation_requests, std::vector<AllocationRequest::DependentLabelGroup> const &unique_dependent_label_groups)

Update allocation solution for a single PADI-bus.

Updating instead of generation is chosen because this operation is performed many times.

Parameters

• allocation – All allocation solutions

• local_allocation – PADI-bus-local allocation solution

• requested_allocation – PADI-bus-local requested allocations

• padi_bus – PADI-bus for which solution is given

• requested_allocations – All requested allocations

• label_indices – Indices in label space for lookup of label values

• independent_allocation_requests – Independent allocation requests required for translation of a value in label_indices to requested allocations

• unique_dependent_label_groups – Unique dependent label groups required for translation of a value in label_indices to requested allocations

static bool valid_solution(std::vector<Allocation> const &allocations, std::vector<AllocationRequest> const &requested_allocations)

Check whether the solution is valid with regard to the request.

Parameters

• allocations – All allocation solutions

• requested_allocations – All requested allocations

Returns

Boolean value

struct grenade::vx::network::routing::greedy::detail::SynapseDriverOnPADIBusManager

#include <synapse_driver_on_padi_bus_manager.h>

Implementation details of the allocation manager for a single PADI-bus.

Public Types

typedef grenade::vx::network::routing::greedy::SynapseDriverOnPADIBusManager::Allocation Allocation

typedef grenade::vx::network::routing::greedy::SynapseDriverOnPADIBusManager::AllocationPolicy AllocationPolicy

typedef grenade::vx::network::routing::greedy::SynapseDriverOnPADIBusManager::AllocationRequest AllocationRequest

typedef std::map<SynapseDriver, std::vector<std::pair<size_t, Mask>>> IsolatedSynapseDrivers

Synapse drivers which allow isolation of requested allocation from all others given the mask value.

Isolation means no other requested allocation’s events are forwarded to the synapses of that driver.

Template Parameters

• Key – Synapse driver location

• Value – Pair of requested allocation index and mask value which isolated the request

typedef std::map<size_t, std::vector<Mask>> IsolatingMasks

Mask values which isolate a given requested allocation.

Isolation means the label of no other requested allocation has the same value after masking.

Template Parameters

• Key – Index in the requested allocations

• Value – Collection of masks

typedef grenade::vx::network::routing::greedy::SynapseDriverOnPADIBusManager::Label Label

typedef grenade::vx::network::routing::greedy::SynapseDriverOnPADIBusManager::Mask Mask

typedef grenade::vx::network::routing::greedy::SynapseDriverOnPADIBusManager::SynapseDriver SynapseDriver

Public Static Functions

static std::vector<Allocation> allocate_backtracking(std::vector<AllocationRequest> const &requested_allocations, IsolatedSynapseDrivers const &isolated_synapse_drivers, std::optional<std::chrono::milliseconds> const &max_duration = std::nullopt)

Place requested allocations using backtracking.

If a solution is possible, it is found (possibly at the cost of larger time consumption). If any requested allocation is sensitive to shape allocation order, the algorithm does not explore different order permutations. This means that for a requested allocation {Shape{2, not contiguous}, Shape{3, contiguous}} and a possible allocation {SynapseDriver(0), SynapseDriver(1), SynapseDriver(2), SynapseDriver(10), SynapseDriver(17)}, the algorithm does not flip the order of the requested shapes to allocate Shape{2, not contiguous} to {SynapseDriver(10), SynapseDriver(17)}, but tries {SynapseDriver(0), SynapseDriver(1)} and then fails to place the second contiguous shape. However, the occurrence of requests which are sensitive to shape allocation order is assumed to be rare, since contiguous shapes are only of use in the context of PPU algorithms and then additionally, the shapes in a request need to be inhomogeneous, which is only the case if different synapse driver configuration groups are requested. In these complex corner cases, if additionally the algorithm fails to find any solution, the user can permute the shapes himself outside of this manager.

Parameters

• requested_allocations – Requested allocations

• isolated_synapse_drivers – Isolated synapse drivers

• max_duration – Optional specification of maximal wall-clock time to perform backtracking

Returns

Allocations

static std::vector<Allocation> allocate_greedy(std::vector<AllocationRequest> const &requested_allocations, IsolatedSynapseDrivers const &isolated_synapse_drivers, bool exclusive_first)

Place requested allocations in a greedy manner.

First the first requested allocation is placed, then the second and so on. Additionally to iterating the synapse drivers linearly, synapse driver locations which only allow isolation of a single request can be used first.

Parameters

• requested_allocations – Requested allocations

• isolated_synapse_drivers – Isolated synapse drivers

• exclusive_first – First use exclusive synapse drivers

Returns

Allocations

static bool allocations_can_be_isolated(IsolatingMasks const &isolating_masks, std::vector<AllocationRequest> const &requested_allocations)

Get whether all requested allocations can in principle be isolated by at least one mask value.

Parameters

• isolating_masks – Isolating masks to given requested allocations

• requested_allocations – Requested allocations

Returns

Boolean value

static bool allocations_can_be_placed_individually(IsolatedSynapseDrivers const &isolated_synapse_drivers, std::vector<AllocationRequest> const &requested_allocations)

Get whether all requested allocations can in principle be placed individually when disregarding the placement of all other requested allocations.

Parameters

• isolated_synapse_drivers – Isolated synapse drivers

• requested_allocations – Requested allocations

Returns

Boolean value

static bool allocations_fit_available_size(std::set<SynapseDriver> const &unavailable_synapse_drivers, std::vector<AllocationRequest> const &requested_allocations)

Check whether the accumulated size of all requested allocations is less than or equal to the number of available synapse drivers.

Parameters

• unavailable_synapse_drivers – Unavailable synapse drivers

• requested_allocations – Requested allocations to check

Returns

Boolean value

static bool forwards(Label const &label, Mask const &mask, SynapseDriver const &synapse_driver)

Check whether given label is forwarded to synapses at specified synapse driver with mask.

Parameters

• label – Event label

• mask – Mask at synapse driver

• synapse_driver – Synapse driver location

Returns

Boolean value

static IsolatedSynapseDrivers generate_isolated_synapse_drivers(std::set<SynapseDriver> const &unavailable_synapse_drivers, IsolatingMasks const &isolating_masks, std::vector<AllocationRequest> const &requested_allocations)

Generate isolated synapse driver locations.

Parameters

• unavailable_synapse_drivers – Synapse drivers to exclude from selection

• isolating_masks – Isolating masks to given requested allocations

• requested_allocations – Requested allocations

Returns

Generated isolated synapse drivers

static IsolatingMasks generate_isolating_masks(std::vector<AllocationRequest> const &requested_allocations)

Generate isolating mask values.

Parameters

requested_allocations – Requested allocations to generate isolating masks for

Returns

Generated isolating masks

static bool has_unique_labels(std::vector<AllocationRequest> const &requested_allocations)

Check whether the requested allocations feature unique labels.

Parameters

requested_allocations – Requested allocations to check

Returns

Boolean value

static bool is_contiguous(std::set<SynapseDriver> const &synapse_drivers)

Get whether set of synapse drivers is contiguous.

An empty collection is defined to be contiguous.

Parameters

synapse_drivers – Synapse driver set to test

Returns

Boolean value

static bool valid(std::vector<Allocation> const &allocations, std::vector<AllocationRequest> const &requested_allocations)

Check whether allocations adhere to the requested allocations’ requirements.

Parameters

• allocations – Allocations to given requested allocations

• requested_allocations – Requested allocations

Returns

Boolean value

struct grenade::vx::network::routing::greedy::RoutingBuilder

#include <routing_builder.h>

Public Types

typedef RoutingResult::ExecutionInstance Result

Public Functions

RoutingBuilder()

Result route(Network::ExecutionInstance const &network, ConnectionRoutingResult const &connection_routing_result, std::optional<GreedyRouter::Options> const &options = std::nullopt) const

Private Functions

void apply_crossbar_nodes_from_background(Result &result) const

void apply_crossbar_nodes_from_internal_to_l2(Result &result) const

void apply_crossbar_nodes_from_l2(Result &result) const

void apply_crossbar_nodes_internal(Result &result) const

void apply_routed_connections(std::map<std::pair<ProjectionOnExecutionInstance, size_t>, std::vector<PlacedConnection>> const &placed_connections, std::map<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>, halco::hicann_dls::vx::v3::SpikeLabel> const &internal_labels, std::map<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>, std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, halco::hicann_dls::vx::v3::SpikeLabel>> const &background_labels, std::map<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>, std::map<halco::hicann_dls::vx::v3::PADIBusOnDLS, halco::hicann_dls::vx::v3::SpikeLabel>> const &external_labels, Network::ExecutionInstance const &network, Result &result) const

void apply_source_labels(RoutingConstraints const &constraints, std::map<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>, halco::hicann_dls::vx::v3::SpikeLabel> const &internal, std::map<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>, std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, halco::hicann_dls::vx::v3::SpikeLabel>> const &background, std::map<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>, std::map<halco::hicann_dls::vx::v3::PADIBusOnDLS, halco::hicann_dls::vx::v3::SpikeLabel>> const &external, Network::ExecutionInstance const &network, Result &result) const

std::map<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>, std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, halco::hicann_dls::vx::v3::SpikeLabel>> get_background_labels(std::vector<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>> const &descriptors, std::vector<SourceOnPADIBusManager::BackgroundSource> const &background_sources, SourceOnPADIBusManager::Partition const &partition, std::vector<SynapseDriverOnDLSManager::Allocation> const &allocations) const

std::pair<std::vector<SourceOnPADIBusManager::BackgroundSource>, std::vector<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>>> get_background_sources(RoutingConstraints const &constraints, halco::common::typed_array<RoutingConstraints::PADIBusConstraints, halco::hicann_dls::vx::v3::PADIBusOnDLS> const &padi_bus_constraints, Network::ExecutionInstance const &network) const

std::map<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>, std::map<halco::hicann_dls::vx::v3::PADIBusOnDLS, halco::hicann_dls::vx::v3::SpikeLabel>> get_external_labels(std::vector<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>> const &descriptors, SourceOnPADIBusManager::Partition const &partition, std::vector<SynapseDriverOnDLSManager::Allocation> const &allocations) const

std::pair<std::vector<SourceOnPADIBusManager::ExternalSource>, std::vector<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>>> get_external_sources(RoutingConstraints const &constraints, halco::common::typed_array<RoutingConstraints::PADIBusConstraints, halco::hicann_dls::vx::v3::PADIBusOnDLS> const &padi_bus_constraints, Network::ExecutionInstance const &network) const

std::map<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>, halco::hicann_dls::vx::v3::SpikeLabel> get_internal_labels(std::vector<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>> const &descriptors, SourceOnPADIBusManager::Partition const &partition, std::vector<SynapseDriverOnDLSManager::Allocation> const &allocations) const

std::pair<std::vector<SourceOnPADIBusManager::InternalSource>, std::vector<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>>> get_internal_sources(RoutingConstraints const &constraints, halco::common::typed_array<RoutingConstraints::PADIBusConstraints, halco::hicann_dls::vx::v3::PADIBusOnDLS> const &padi_bus_constraints, Network::ExecutionInstance const &network) const

std::map<std::pair<ProjectionOnExecutionInstance, size_t>, std::vector<PlacedConnection>> place_routed_connections(SourceOnPADIBusManager::Partition const &partition, std::vector<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>> const &internal_descriptors, std::vector<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>> const &background_descriptors, std::vector<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>> const &external_descriptors, std::vector<SourceOnPADIBusManager::InternalSource> const &internal_sources, std::vector<SourceOnPADIBusManager::BackgroundSource> const &background_sources, std::vector<SourceOnPADIBusManager::ExternalSource> const &external_sources, std::vector<SynapseDriverOnDLSManager::Allocation> const &padi_bus_allocations, RoutingConstraints const &constraints, Network::ExecutionInstance const &network, Result &result) const

template<typename Connection>
std::map<std::pair<ProjectionOnExecutionInstance, size_t>, std::vector<PlacedConnection>> place_routed_connections(std::vector<Connection> const &connections, std::map<Receptor::Type, std::vector<halco::hicann_dls::vx::v3::SynapseRowOnDLS>> const &synapse_rows) const

std::map<std::pair<ProjectionOnExecutionInstance, size_t>, std::vector<PlacedConnection>> place_routed_connections(std::vector<RoutedConnection> const &connections, std::vector<halco::hicann_dls::vx::v3::SynapseRowOnDLS> const &synapse_rows) const

template<typename Sources>
std::map<std::pair<ProjectionOnExecutionInstance, size_t>, std::vector<PlacedConnection>> place_routed_connections(std::vector<SourceOnPADIBusManager::Partition::Group> const &partition, std::vector<std::tuple<PopulationOnExecutionInstance, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>> const &descriptors, Sources const &sources, std::vector<SynapseDriverOnDLSManager::Allocation> const &padi_bus_allocations, size_t offset, RoutingConstraints const &constraints, Network::ExecutionInstance const &network, Result &result) const

void route_internal_crossbar(SourceOnPADIBusManager::DisabledInternalRoutes &disabled_internal_routes, RoutingConstraints const &constraints, halco::common::typed_array<RoutingConstraints::PADIBusConstraints, halco::hicann_dls::vx::v3::PADIBusOnDLS> &padi_bus_constraints, Result &result) const

Private Members

log4cxx::LoggerPtr m_logger

struct grenade::vx::network::routing::greedy::RoutingBuilder::PlacedConnection

Public Members

halco::hicann_dls::vx::v3::SynapseOnSynapseRow synapse_on_row

halco::hicann_dls::vx::v3::SynapseRowOnDLS synapse_row

struct grenade::vx::network::routing::greedy::RoutingBuilder::RoutedConnection

Public Members

std::pair<ProjectionOnExecutionInstance, size_t> descriptor

halco::hicann_dls::vx::v3::AtomicNeuronOnDLS target

struct grenade::vx::network::routing::greedy::RoutingConstraints

#include <routing_constraints.h>

Accessors for routing constraints for a given abstract network.

Public Functions

RoutingConstraints(Network::ExecutionInstance const &network, ConnectionRoutingResult const &connection_routing_result)

Construct constraints from and for an abstract network.

Parameters

• network – Abstract network

• connection_routing_result – Result of connection routing

void check() const

Check if routing in possible in principle given the hardware limitations.

The supported in-degree per neuron is checked as well as the required number of synapse rows per PADI-bus.

Throws

std::runtime_error – On unsatisfiable constraints

std::vector<BackgroundConnection> get_background_connections() const

Get background connections of network.

Returns

Background connections

std::vector<ExternalConnection> get_external_connections() const

Get external connections of network.

Returns

External connections

halco::common::typed_array<std::map<Receptor::Type, std::vector<std::pair<ProjectionOnExecutionInstance, size_t>>>, halco::hicann_dls::vx::v3::HemisphereOnDLS> get_external_connections_per_hemisphere() const

Get number of external connections placed onto each chip hemisphere per receptor type.

halco::common::typed_array<std::map<Receptor::Type, std::set<std::pair<PopulationOnExecutionInstance, size_t>>>, halco::hicann_dls::vx::v3::HemisphereOnDLS> get_external_sources_to_hemisphere() const

Get number of external sources projecting onto each chip hemisphere per receptor type.

std::vector<InternalConnection> get_internal_connections() const

Get internal connections of network.

Returns

Internal connections

std::set<halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> get_neither_recorded_nor_source_neurons() const

Get neurons which are neither recorded nor serve as source of (a) connection(s).

std::map<halco::hicann_dls::vx::v3::PADIBusOnDLS, std::set<halco::hicann_dls::vx::v3::NeuronEventOutputOnDLS>> get_neuron_event_outputs_on_padi_bus() const

Get neuron event outputs projecting onto each PADI-bus.

This function assumes the crossbar to forward all events at every node.

halco::common::typed_array<size_t, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> get_neuron_in_degree() const

Get in-degree per on-chip neuron.

halco::common::typed_array<halco::common::typed_array<size_t, halco::hicann_dls::vx::v3::PADIBusOnPADIBusBlock>, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> get_neuron_in_degree_per_padi_bus() const

Get in-degree per on-chip neuron for each incoming PADI-bus.

halco::common::typed_array<std::map<Receptor::Type, size_t>, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> get_neuron_in_degree_per_receptor_type() const

Get in-degree per on-chip neuron for each receptor type.

halco::common::typed_array<halco::common::typed_array<std::map<Receptor::Type, size_t>, halco::hicann_dls::vx::v3::PADIBusOnPADIBusBlock>, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> get_neuron_in_degree_per_receptor_type_per_padi_bus() const

Get in-degree per on-chip neuron for each incoming PADI-bus and receptor type.

std::map<halco::hicann_dls::vx::v3::NeuronEventOutputOnDLS, std::vector<halco::hicann_dls::vx::v3::AtomicNeuronOnDLS>> get_neurons_on_event_output() const

Get on-chip neurons forwarding their events per neuron event output.

std::map<halco::hicann_dls::vx::v3::PADIBusOnDLS, std::set<halco::hicann_dls::vx::v3::AtomicNeuronOnDLS>> get_neurons_on_padi_bus() const

Get on-chip neurons forwarding their events onto each PADI-bus.

This function assumes the crossbar to forward all events at every node.

halco::common::typed_array<size_t, halco::hicann_dls::vx::v3::PADIBusOnDLS> get_num_background_sources_on_padi_bus() const

Get number of background spike sources projecting onto each PADI-bus.

halco::common::typed_array<size_t, halco::hicann_dls::vx::v3::PADIBusOnDLS> get_num_synapse_rows_per_padi_bus() const

Get required number of synapse rows for each PADI-bus.

This is the accumulation of all numbers of synapse rows required for different receptor types on each PADI-bus.

halco::common::typed_array<std::map<Receptor::Type, size_t>, halco::hicann_dls::vx::v3::PADIBusOnDLS> get_num_synapse_rows_per_padi_bus_per_receptor_type() const

Get required number of synapse rows for each PADI-bus and receptor type combination.

halco::common::typed_array<PADIBusConstraints, halco::hicann_dls::vx::v3::PADIBusOnDLS> get_padi_bus_constraints() const

Get constraints for each PADI-bus.

Private Members

ConnectionRoutingResult const &m_connection_routing_result

Network::ExecutionInstance const &m_network

struct grenade::vx::network::routing::greedy::RoutingConstraints::BackgroundConnection

#include <routing_constraints.h>

Synaptic connection from a background spike source to an on-chip neuron.

Public Functions

bool operator!=(BackgroundConnection const &other) const

bool operator==(BackgroundConnection const &other) const

halco::hicann_dls::vx::v3::PADIBusOnDLS toPADIBusOnDLS() const

Get PADI-bus onto which the synapse is to be placed.

Public Members

std::pair<ProjectionOnExecutionInstance, size_t> descriptor

Descriptor of connection in abstract network.

Receptor::Type receptor_type

Receptor type of connection.

halco::hicann_dls::vx::v3::BackgroundSpikeSourceOnDLS source

Source circuit.

halco::hicann_dls::vx::v3::AtomicNeuronOnDLS target

Target neuron.

struct grenade::vx::network::routing::greedy::RoutingConstraints::ExternalConnection

#include <routing_constraints.h>

Synaptic connection from an external source to an on-chip neuron.

Public Functions

bool operator!=(ExternalConnection const &other) const

bool operator==(ExternalConnection const &other) const

halco::hicann_dls::vx::v3::PADIBusBlockOnDLS toPADIBusBlockOnDLS() const

Get PADI-bus block onto which the synapse is to be placed.

Public Members

std::pair<ProjectionOnExecutionInstance, size_t> descriptor

Descriptor of connection in abstract network.

Receptor::Type receptor_type

Receptor type of connection.

halco::hicann_dls::vx::v3::AtomicNeuronOnDLS target

Target neuron.

struct grenade::vx::network::routing::greedy::RoutingConstraints::InternalConnection

#include <routing_constraints.h>

Synaptic connection between a pair of on-chip neurons.

Public Functions

bool operator!=(InternalConnection const &other) const

bool operator==(InternalConnection const &other) const

halco::hicann_dls::vx::v3::PADIBusOnDLS toPADIBusOnDLS() const

Get PADI-bus onto which the synapse is to be placed.

Public Members

std::pair<ProjectionOnExecutionInstance, size_t> descriptor

Descriptor of connection in abstract network.

Receptor::Type receptor_type

Receptor type of connection.

halco::hicann_dls::vx::v3::AtomicNeuronOnDLS source

Source neuron.

halco::hicann_dls::vx::v3::AtomicNeuronOnDLS target

Target neuron.

struct grenade::vx::network::routing::greedy::RoutingConstraints::PADIBusConstraints

#include <routing_constraints.h>

Collection of constraints for a single PADI-bus.

Public Members

std::vector<BackgroundConnection> background_connections

Background connections.

std::vector<InternalConnection> internal_connections

Internal connections.

std::set<halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> neuron_sources

Neuron sources.

size_t num_background_spike_sources

Background spike source number.

std::set<halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> only_recorded_neurons

Neuron circuits, which don’t serve as source for any other target neuron but are still recorded and therefore elicit spike events.

struct grenade::vx::network::routing::greedy::SourceOnPADIBusManager

#include <source_on_padi_bus_manager.h>

Partitioning manager for sources projecting onto internal neurons via events propagated by PADI-busses.

Given all sources and their destination(s), distribute their event paths over PADI-busses. Depending on the type of source, the constraints for possible PADI-busses vary. Internal sources project at one fixed PADI-bus per hemisphere and background sources project at one fixed PADI-bus per chip while external sources are freely distributable over all PADI-busses of a chip.

Public Types

typedef std::map<halco::hicann_dls::vx::v3::NeuronEventOutputOnDLS, std::set<halco::hicann_dls::vx::v3::HemisphereOnDLS>> DisabledInternalRoutes

typedef SynapseDriverOnDLSManager::Label Label

Label to identify events at synapse driver(s).

typedef SynapseDriverOnDLSManager::SynapseDriver SynapseDriver

Synapse driver location.

Public Functions

SourceOnPADIBusManager(DisabledInternalRoutes const &disabled_internal_routes = {})

Construct manager.

Parameters

disabled_internal_routes – Disabled routes between internal sources and targets, which should never be used and required

std::optional<Partition> solve(std::vector<InternalSource> const &internal_sources, std::vector<BackgroundSource> const &background_sources, std::vector<ExternalSource> const &external_sources) const

Partition sources into allocation requests for projected-on synapse drivers.

Parameters

• internal_sources – Collection of internal sources

• background_sources – Collection of background sources

• external_sources – Collection of external sources

Returns

Partitioning of sources into synapse driver allocation requests. If unsuccessful, returns none.

Private Members

DisabledInternalRoutes m_disabled_internal_routes

log4cxx::LoggerPtr m_logger

struct grenade::vx::network::routing::greedy::SourceOnPADIBusManager::BackgroundSource

#include <source_on_padi_bus_manager.h>

Properties of a background source.

Public Members

std::map<Receptor::Type, halco::common::typed_array<size_t, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS>> out_degree

Number of required synapses per atomic neuron.

halco::hicann_dls::vx::v3::PADIBusOnDLS padi_bus

PADI-bus which carries outgoing events of source.

struct grenade::vx::network::routing::greedy::SourceOnPADIBusManager::ExternalSource

#include <source_on_padi_bus_manager.h>

Properties of an external source.

Public Members

std::map<Receptor::Type, halco::common::typed_array<size_t, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS>> out_degree

Number of required synapses per atomic neuron.

struct grenade::vx::network::routing::greedy::SourceOnPADIBusManager::InternalSource

#include <source_on_padi_bus_manager.h>

Properties of an internal source.

Public Functions

halco::hicann_dls::vx::v3::PADIBusOnPADIBusBlock toPADIBusOnPADIBusBlock() const

Get PADI-bus on block which carries outgoing events of source.

Returns

PADI-bus on block

Public Members

halco::hicann_dls::vx::v3::AtomicNeuronOnDLS neuron

Location of source.

std::map<Receptor::Type, halco::common::typed_array<size_t, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS>> out_degree

Number of required synapses per atomic neuron.

struct grenade::vx::network::routing::greedy::SourceOnPADIBusManager::Partition

#include <source_on_padi_bus_manager.h>

Partitioning of sources in label space and onto PADI-busses.

Public Functions

bool valid() const

Check validity of partition.

A partition is valid exactly if its groups are valid.

Public Members

std::vector<Group> background

Groups of background sources with their synapse driver allocation requests.

std::vector<Group> external

Groups of external sources with their synapse driver allocation requests.

std::vector<Group> internal

Groups of internal sources with their synapse driver allocation requests.

Friends

friend std::ostream &operator<<(std::ostream &os, Partition const &config)

struct grenade::vx::network::routing::greedy::SourceOnPADIBusManager::Partition::Group

#include <source_on_padi_bus_manager.h>

Group of sources projecting onto a single allocation request for synapse drivers.

Public Functions

bool valid() const

Check validity of group.

A group is valid exactly if the sources are unique and their number allows unique addressing in the synapse matrix.

Public Members

SynapseDriverOnDLSManager::AllocationRequest allocation_request

Synapse driver allocation request.

std::vector<size_t> sources

Collection of source indices into the respective vector of sources supplied to solve().

Friends

friend std::ostream &operator<<(std::ostream &os, Group const &config)

struct grenade::vx::network::routing::greedy::SynapseDriverOnDLSManager

#include <synapse_driver_on_dls_manager.h>

Allocation manager for synapse drivers on all PADI-busses of one chip.

Given requested allocations and a policy to use, places these requests onto the available synapse drivers.

Public Types

typedef SynapseDriverOnPADIBusManager::AllocationPolicy AllocationPolicy

Allocation policy to use per PADI-bus.

typedef SynapseDriverOnPADIBusManager::AllocationPolicyBacktracking AllocationPolicyBacktracking

typedef SynapseDriverOnPADIBusManager::AllocationPolicyGreedy AllocationPolicyGreedy

typedef SynapseDriverOnPADIBusManager::Label Label

Label to identify events at synapse driver(s).

typedef SynapseDriverOnPADIBusManager::SynapseDriver SynapseDriver

Synapse driver location.

Public Functions

SynapseDriverOnDLSManager(std::set<halco::hicann_dls::vx::v3::SynapseDriverOnDLS> const &unavailable_synapse_drivers = {})

Construct manager with unavailable synapse driver locations, which will be excluded for placing allocation(s).

Parameters

unavailable_synapse_drivers – Synapse drivers excluded from allocation(s).

std::optional<std::vector<Allocation>> solve(std::vector<AllocationRequest> const &requested_allocations, AllocationPolicy const &allocation_policy = AllocationPolicyBacktracking(), std::optional<std::chrono::milliseconds> const &timeout = std::nullopt)

Find placement of requested allocations.

Parameters

• requested_allocations – Collection of requested allocations

• allocation_policy – Policy to use for partitioning of available synapse drivers

• timeout – Optional timeout for brute-forcing label combinations per dependent PADI-busses

Returns

Actual allocations on success, std::nullopt on failure of placement

Private Members

log4cxx::LoggerPtr m_logger

halco::common::typed_array<SynapseDriverOnPADIBusManager, halco::hicann_dls::vx::v3::PADIBusOnDLS> m_synapse_driver_on_padi_bus_manager

struct grenade::vx::network::routing::greedy::SynapseDriverOnDLSManager::Allocation

#include <synapse_driver_on_dls_manager.h>

Allocation of synapse drivers.

Public Members

Label label

Labels of events.

std::map<halco::hicann_dls::vx::v3::PADIBusOnDLS, SynapseDriverOnPADIBusManager::Allocation> synapse_drivers

Collection of synapse drivers with their mask.

Friends

friend std::ostream &operator<<(std::ostream &os, Allocation const &config)

struct grenade::vx::network::routing::greedy::SynapseDriverOnDLSManager::AllocationRequest

#include <synapse_driver_on_dls_manager.h>

Properties of a potential allocation of synapse drivers.

Public Types

typedef SynapseDriverOnPADIBusManager::AllocationRequest::Shape Shape

Public Functions

bool operator!=(AllocationRequest const &other) const

bool operator==(AllocationRequest const &other) const

bool valid() const

Get whether request is valid by checking for non-empty labels and shapes.

Public Members

std::optional<DependentLabelGroup> dependent_label_group

std::vector<Label> labels

Potential labels of events which shall be forwarded exclusively to allocated synapse drivers.

std::map<halco::hicann_dls::vx::v3::PADIBusOnDLS, std::vector<Shape>> shapes

Shape(s) of allocation.

Friends

friend std::ostream &operator<<(std::ostream &os, AllocationRequest const &config)

struct grenade::vx::network::routing::greedy::SynapseDriverOnDLSManager::AllocationRequest::DependentLabelGroup : public halco::common::detail::BaseType<DependentLabelGroup, size_t>

#include <synapse_driver_on_dls_manager.h>

Descriptor to be used to identify a depdendency between the label space of multiple allocation requests.

Their labels are constrained such that their index in AllocationRequest::labels has to be equal.

Public Functions

inline explicit constexpr DependentLabelGroup(value_type const value = 0)

struct grenade::vx::network::routing::greedy::SynapseDriverOnPADIBusManager

#include <synapse_driver_on_padi_bus_manager.h>

Allocation manager for synapse drivers on a single PADI-bus.

Given requested allocations and a policy to use, places these requests onto the available synapse drivers.

Public Types

typedef std::variant<AllocationPolicyGreedy, AllocationPolicyBacktracking> AllocationPolicy

typedef haldls::vx::v3::PADIEvent::RowSelectAddress Label

Label to identify events at synapse driver(s).

typedef haldls::vx::v3::SynapseDriverConfig::RowAddressCompareMask Mask

Mask to filter events at synapse driver(s) depending on their label.

typedef halco::hicann_dls::vx::v3::SynapseDriverOnPADIBus SynapseDriver

Synapse driver location.

Public Functions

SynapseDriverOnPADIBusManager(std::set<SynapseDriver> const &unavailable_synapse_drivers = {})

Construct manager with unavailable synapse driver locations, which will be excluded for placing allocation(s).

Parameters

unavailable_synapse_drivers – Synapse drivers excluded from allocation(s).

std::optional<std::vector<Allocation>> solve(std::vector<AllocationRequest> const &requested_allocations, AllocationPolicy const &allocation_policy = AllocationPolicyBacktracking())

Find placement of requested allocations.

Parameters

• requested_allocations – Collection of requested allocations

• allocation_policy – Policy to use for partitioning of available synapse drivers

Returns

Actual allocations on success, std::nullopt on failure of placement

Private Members

std::set<SynapseDriver> m_unavailable_synapse_drivers

struct grenade::vx::network::routing::greedy::SynapseDriverOnPADIBusManager::Allocation

#include <synapse_driver_on_padi_bus_manager.h>

Allocation of synapse drivers.

Public Members

std::vector<std::vector<std::pair<SynapseDriver, Mask>>> synapse_drivers

Collection of synapse drivers with their mask.

Friends

friend std::ostream &operator<<(std::ostream &os, Allocation const &allocation)

struct grenade::vx::network::routing::greedy::SynapseDriverOnPADIBusManager::AllocationPolicyBacktracking

#include <synapse_driver_on_padi_bus_manager.h>

Public Functions

AllocationPolicyBacktracking(std::optional<std::chrono::milliseconds> const &max_duration = std::nullopt)

Public Members

std::optional<std::chrono::milliseconds> max_duration

struct grenade::vx::network::routing::greedy::SynapseDriverOnPADIBusManager::AllocationPolicyGreedy

#include <synapse_driver_on_padi_bus_manager.h>

Public Functions

AllocationPolicyGreedy(bool enable_exclusive_first = true)

Public Members

bool enable_exclusive_first

struct grenade::vx::network::routing::greedy::SynapseDriverOnPADIBusManager::AllocationRequest

#include <synapse_driver_on_padi_bus_manager.h>

Properties of a requested allocation of synapse drivers.

A request has a single label for incoming events and possibly multiple requested synapse driver collections with specified shape.

Public Functions

bool is_sensitive_for_shape_allocation_order() const

Get whether the request is sensitive to ordering of shapes on the available synapse drivers.

This is the case exactly if any shape shall be contiguous and the allocation does not contain only equal shapes.

bool operator!=(AllocationRequest const &other) const

bool operator==(AllocationRequest const &other) const

size_t size() const

Get accumulated size of all shapes of the request.

Public Members

Label label

Label of events which shall be forwarded exclusively to allocated synapse drivers.

std::vector<Shape> shapes

Collection of requested synapse drivers.

Friends

friend std::ostream &operator<<(std::ostream &os, AllocationRequest const &value)

struct grenade::vx::network::routing::greedy::SynapseDriverOnPADIBusManager::AllocationRequest::Shape

#include <synapse_driver_on_padi_bus_manager.h>

Single synapse driver collection.

Public Functions

bool operator!=(Shape const &other) const

bool operator==(Shape const &other) const

Public Members

bool contiguous

Whether the synapse drivers shall be contiguous, i.e.

without holes.

size_t size

Number of synapse drivers.

Friends

friend std::ostream &operator<<(std::ostream &os, Shape const &value)

struct grenade::vx::network::routing::GreedyRouter : public grenade::vx::network::routing::Router

#include <greedy_router.h>

Router using a (partially) greedy algorithm.

Public Functions

GreedyRouter(GreedyRouter const&) = delete

GreedyRouter(Options const &options = Options())

virtual ~GreedyRouter()

virtual RoutingResult operator()(std::shared_ptr<Network> const &network) override

Route given network.

Successive invokations with the same network are allowed to yield different results.

Parameters

network – Network to route for

Returns

Routing result

GreedyRouter &operator=(GreedyRouter const&) = delete

Public Members

std::vector<std::unique_ptr<Router>> routers

Private Members

std::unique_ptr<Impl> m_impl

struct grenade::vx::network::routing::GreedyRouter::Options

#include <greedy_router.h>

Options of the routing algorithm.

Public Types

typedef greedy::SynapseDriverOnDLSManager::AllocationPolicy AllocationPolicy

Policy to be used in synapse driver allocation.

typedef greedy::SynapseDriverOnDLSManager::AllocationPolicyBacktracking AllocationPolicyBacktracking

typedef greedy::SynapseDriverOnDLSManager::AllocationPolicyGreedy AllocationPolicyGreedy

Public Functions

Options()

Public Members

AllocationPolicy synapse_driver_allocation_policy

std::optional<std::chrono::milliseconds> synapse_driver_allocation_timeout

Optional timeout to be used in synapse driver allocation algorithm for iteration over label combinations.

Friends

friend std::ostream &operator<<(std::ostream &os, Options const &options)

struct grenade::vx::network::routing::PortfolioRouter : public grenade::vx::network::routing::Router

#include <portfolio_router.h>

Router using a portfolio of routing algorithms.

Can be used to find easy or special-case solutions fast with optimized algorithms and using more general algorithms afterwards.

Public Functions

PortfolioRouter()

PortfolioRouter(PortfolioRouter const&) = delete

PortfolioRouter(std::vector<std::unique_ptr<Router>> &&routers)

virtual ~PortfolioRouter()

virtual RoutingResult operator()(std::shared_ptr<Network> const &network) override

Route given network.

Successive invokations with the same network are allowed to yield different results.

Parameters

network – Network to route for

Returns

Routing result

PortfolioRouter &operator=(PortfolioRouter const&) = delete

Public Members

std::vector<std::unique_ptr<Router>> routers

struct grenade::vx::network::routing::Router

#include <router.h>

Subclassed by grenade::vx::network::routing::GreedyRouter, grenade::vx::network::routing::PortfolioRouter

Public Functions

virtual ~Router()

virtual RoutingResult operator()(std::shared_ptr<Network> const &network) = 0

Route given network.

Successive invokations with the same network are allowed to yield different results.

Parameters

network – Network to route for

Returns

Routing result

struct grenade::vx::network::RoutingResult

#include <routing_result.h>

Result of connection routing.

Public Functions

RoutingResult() = default

Public Members

std::map<common::ExecutionInstanceID, ExecutionInstance> execution_instances

struct grenade::vx::network::RoutingResult::TimingStatistics timing_statistics

Friends

friend std::ostream &operator<<(std::ostream&, RoutingResult const&)

struct grenade::vx::network::RoutingResult::ExecutionInstance

#include <routing_result.h>

Public Types

typedef std::map<PopulationOnExecutionInstance, std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, std::vector<halco::hicann_dls::vx::v3::SpikeLabel>>> BackgroundSpikeSourceLabels

Spike label corresponding to each neuron in a background source population.

typedef std::map<PopulationOnExecutionInstance, std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, haldls::vx::v3::BackgroundSpikeSource::Mask>> BackgroundSpikeSourceMasks

Background spike source mask for each population.

typedef std::map<ProjectionOnExecutionInstance, std::vector<std::vector<PlacedConnection>>> Connections

typedef std::map<halco::hicann_dls::vx::v3::CrossbarNodeOnDLS, haldls::vx::v3::CrossbarNode> CrossbarNodes

Crossbar node configuration resulting from routing to be applied.

This map is only required to feature used crossbar nodes, all other will be considered disabled.

typedef std::map<PopulationOnExecutionInstance, std::vector<std::vector<halco::hicann_dls::vx::v3::SpikeLabel>>> ExternalSpikeLabels

Spike label corresponding to each neuron in a external population.

typedef std::map<PopulationOnExecutionInstance, std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<std::optional<haldls::vx::v3::NeuronBackendConfig::AddressOut>>>>> InternalNeuronLabels

Neuron event output address corresponding to each neuron in a on-chip population.

typedef std::map<halco::hicann_dls::vx::v3::SynapseDriverOnDLS, haldls::vx::v3::SynapseDriverConfig::RowAddressCompareMask> SynapseDriverRowAddressCompareMasks

Synapse driver row address compare mask resulting from routing to be applied.

This map is only required to feature used synapse drivers, all other will be considered disabled.

typedef std::map<halco::hicann_dls::vx::v3::SynapseRowOnDLS, haldls::vx::v3::SynapseDriverConfig::RowMode> SynapseRowModes

Synapse row mode resulting from routing to be applied.

This map is only required to feature used synapse rows, all other will be considered disabled.

Public Functions

ExecutionInstance() = default

Public Members

BackgroundSpikeSourceLabels background_spike_source_labels

BackgroundSpikeSourceMasks background_spike_source_masks

ConnectionRoutingResult connection_routing_result

Connections connections

CrossbarNodes crossbar_nodes

ExternalSpikeLabels external_spike_labels

InternalNeuronLabels internal_neuron_labels

SynapseDriverRowAddressCompareMasks synapse_driver_compare_masks

SynapseRowModes synapse_row_modes

Friends

friend std::ostream &operator<<(std::ostream&, ExecutionInstance const&)

struct grenade::vx::network::RoutingResult::ExecutionInstance::PlacedConnection

#include <routing_result.h>

Placed single synapse connections with a N-to-one correspondence to an unplaced Projection::Connection with equal indexing.

Public Members

lola::vx::v3::SynapseMatrix::Label label

halco::hicann_dls::vx::v3::SynapseOnSynapseRow synapse_on_row

halco::hicann_dls::vx::v3::SynapseRowOnDLS synapse_row

lola::vx::v3::SynapseMatrix::Weight weight

Friends

friend std::ostream &operator<<(std::ostream&, PlacedConnection const&)

struct grenade::vx::network::RoutingResult::TimingStatistics

#include <routing_result.h>

Public Members

std::chrono::microseconds routing

class grenade::vx::network::UnsuccessfulRouting : public virtual std::exception

#include <exception.h>

Exception describing an unsuccessful routing.

Public Functions

explicit UnsuccessfulRouting(std::string const &message)

Construct from cause message.

Parameters

message – Exception cause

virtual const char *what() const noexcept override

Get exception cause.

Returns

String describing cause of exception

Private Members

std::string const m_message

struct grenade::vx::network::vertex::transformation::ExternalSourceMerger : public grenade::vx::signal_flow::vertex::Transformation::Function

#include <external_source_merger.h>

Transformation merging (translated) spike-trains from external user-input or other execution instance(s).

It introduces one additional copy of all forwarded data and sorting the forwarded data at once over time exactly if more than one input is to be merged.

Public Types

typedef std::variant<InterExecutionInstanceInput, ExternalInput> Input

typedef signal_flow::Data::Entry Value

Public Functions

ExternalSourceMerger() = default

ExternalSourceMerger(std::vector<Input> const &inputs)

Construct merger for spike-trains of external source.

Parameters

inputs – Input configuration.

~ExternalSourceMerger()

virtual Value apply(std::vector<Value> const &value) const

Apply function on input value.

Parameters

value – Input value

Returns

Transformed output value

virtual std::unique_ptr<signal_flow::vertex::Transformation::Function> clone() const

virtual bool equal(signal_flow::vertex::Transformation::Function const &other) const

virtual std::vector<signal_flow::Port> inputs() const

Provided input ports provided.

Returns

Port

virtual signal_flow::Port output() const

Single output port provided.

Returns

Port

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

std::vector<Input> m_inputs

Friends

friend struct cereal::access

struct grenade::vx::network::vertex::transformation::ExternalSourceMerger::ExternalInput

#include <external_source_merger.h>

User-supplied external input.

Public Functions

bool operator==(ExternalInput const &other) const

Public Static Attributes

static constexpr signal_flow::ConnectionType type = signal_flow::ConnectionType::TimedSpikeToChipSequence

struct grenade::vx::network::vertex::transformation::ExternalSourceMerger::InterExecutionInstanceInput

#include <external_source_merger.h>

Input from another execution instance with required label translation.

Public Functions

bool operator==(InterExecutionInstanceInput const &other) const

Public Members

std::map<halco::hicann_dls::vx::v3::SpikeLabel, std::vector<halco::hicann_dls::vx::v3::SpikeLabel>> translation

Post labels for pre label.

Public Static Attributes

static constexpr signal_flow::ConnectionType type = signal_flow::ConnectionType::TimedSpikeFromChipSequence

struct grenade::vx::ppu::NeuronViewHandle

#include <neuron_view_handle.h>

Public Members

hate::bitset<256, uint32_t> columns

Columns in neuron view.

TODO: replace numbers by halco constants

struct grenade::vx::ppu::SynapseArrayViewHandle

#include <synapse_array_view_handle.h>

Public Members

hate::bitset<256, uint32_t> columns

Columns in synapse array of view.

TODO: replace numbers by halco constants

hate::bitset<256, uint32_t> rows

Rows in synapse array of view.

struct grenade::vx::ppu::SynapseRowViewHandle

#include <synapse_row_view_handle.h>

Handle to synapse row.

Public Functions

inline SynapseRowViewHandle(SynapseArrayViewHandle const &synapses, size_t row)

Private Members

size_t m_row

SynapseArrayViewHandle const &m_synapses

struct grenade::vx::ppu::SynapseRowViewHandleRange

#include <synapse_row_view_handle_range.h>

Iterable range of synapse row handles of a synapse array.

Public Functions

SynapseRowViewHandleRange(SynapseArrayViewHandle const &synapses)

Iterator begin() const

Iterator end() const

Private Members

Iterator m_begin

Iterator m_end

class grenade::vx::ppu::SynapseRowViewHandleRange::Iterator : public boost::iterator_facade<Iterator, SynapseRowViewHandle, boost::forward_traversal_tag, SynapseRowViewHandle>

#include <synapse_row_view_handle_range.h>

Private Types

typedef SynapseRowViewHandle reference

Private Functions

Iterator(SynapseArrayViewHandle const &synapses)

Iterator(SynapseArrayViewHandle const &synapses, size_t row)

reference dereference() const

bool equal(Iterator const &other) const

void increment()

Private Members

size_t m_row

SynapseArrayViewHandle const &m_synapses

Friends

friend class boost::iterator_core_access

friend class SynapseRowViewHandleRange

struct grenade::vx::ppu::SynapseRowViewHandleSigned

#include <synapse_row_view_handle.h>

Handle to signed synapse row (consisting of an excitatory and an inhibitory row).

Public Functions

inline SynapseRowViewHandleSigned(SynapseRowViewHandle const &exc, SynapseRowViewHandle const &inh)

Private Members

SynapseRowViewHandle m_exc

SynapseRowViewHandle m_inh

struct grenade::vx::ppu::SynapseRowViewHandleSignedRange

#include <synapse_row_view_handle_range.h>

Iterable range of signed synapse row handles of a synapse array.

Public Functions

SynapseRowViewHandleSignedRange(SynapseArrayViewHandle const &synapses_exc, SynapseArrayViewHandle const &synapses_inh)

Iterator begin() const

Iterator end() const

Private Members

Iterator m_begin

Iterator m_end

class grenade::vx::ppu::SynapseRowViewHandleSignedRange::Iterator : public boost::iterator_facade<Iterator, SynapseRowViewHandleSigned, boost::forward_traversal_tag, SynapseRowViewHandleSigned>

#include <synapse_row_view_handle_range.h>

Private Types

typedef SynapseRowViewHandleSigned reference

Private Functions

Iterator(SynapseArrayViewHandle const &synapses_exc, SynapseArrayViewHandle const &synapses_inh)

Iterator(SynapseArrayViewHandle const &synapses_exc, SynapseArrayViewHandle const &synapses_inh, size_t exc_row, size_t inh_row)

void check() const

reference dereference() const

bool equal(Iterator const &other) const

void increment()

Private Members

size_t m_exc_row = {0}

size_t m_inh_row = {0}

SynapseArrayViewHandle const &m_synapses_exc

SynapseArrayViewHandle const &m_synapses_inh

Friends

friend class boost::iterator_core_access

friend class SynapseRowViewHandleSignedRange

struct grenade::vx::signal_flow::Data

#include <data.h>

Data map used for external data exchange in graph execution.

For each type of data a separate member allows access.

Subclassed by grenade::vx::signal_flow::InputData, grenade::vx::signal_flow::OutputData

Public Types

typedef std::variant<std::vector<common::TimedDataSequence<std::vector<UInt32>>>, std::vector<common::TimedDataSequence<std::vector<UInt5>>>, std::vector<common::TimedDataSequence<std::vector<Int8>>>, std::vector<TimedSpikeToChipSequence>, std::vector<TimedSpikeFromChipSequence>, std::vector<TimedMADCSampleFromChipSequence>> Entry

Data entry for a vertex.

Public Functions

Data()

Data(Data &&other)

Data(Data const&) = delete

size_t batch_size() const

Get number of elements in each batch of data.

Returns

Number of elements in batch

void clear()

Clear content of map.

bool empty() const

Get whether the map does not contain any elements.

Returns

Boolean value

void merge(Data &&other)

Merge other map content into this one’s.

Parameters

other – Other map to merge into this instance

void merge(Data &other)

Merge other map content into this one’s.

Parameters

other – Other map to merge into this instance

Data &operator=(Data &&other)

Data &operator=(Data const &other) = delete

bool valid() const

Check that all map entries feature the same batch_size value.

Returns

Boolean value

Public Members

std::map<signal_flow::detail::vertex_descriptor, Entry> data

Data is connected to specified vertex descriptors.

Batch-support is enabled by storing batch-size many data elements aside each-other. Data is stored as shared_ptr to allow for inexpensive shallow copy of data for multiple vertices in the map.

Public Static Functions

static bool is_match(Entry const &entry, signal_flow::Port const &port)

Get whether the data held in the entry match the port shape and type information.

Parameters

• entry – Entry to check

• port – Port to check

Returns

Boolean value

template<typename VertexVariant>
struct CheckVertexConcept

template<typename ...Vertex>
struct grenade::vx::signal_flow::detail::CheckVertexConcept<std::variant<Vertex...>> : public grenade::vx::signal_flow::detail::VertexConcept<Vertex>

#include <vertex_concept.h>

Public Static Attributes

template<typename V>
static constexpr bool has_can_connect_different_execution_instances_v = has_can_connect_different_execution_instances<V>::value

template<typename V>
static constexpr bool has_inputs_v = has_inputs<V>::value

template<typename V>
static constexpr bool has_output_v = has_output<V>::value

template<typename V>
static constexpr bool has_variadic_input_v = has_variadic_input<V>::value

template<typename Inputs>
struct IsInputsReturn : public std::false_type

#include <vertex_concept.h>

template<size_t N>
struct IsInputsReturn<std::array<Port, N>> : public std::true_type

#include <vertex_concept.h>

template<>
struct IsInputsReturn<std::vector<Port>> : public std::true_type

#include <vertex_concept.h>

template<typename Vertex>
struct grenade::vx::signal_flow::detail::VertexConcept

#include <vertex_concept.h>

A vertex is an entity which has a defined number of input ports and one output port with defined type and size.

Subclassed by grenade::vx::signal_flow::detail::CheckVertexConcept< std::variant< Vertex… > >

Public Static Attributes

template<typename V>
static constexpr bool has_can_connect_different_execution_instances_v = has_can_connect_different_execution_instances<V>::value

template<typename V>
static constexpr bool has_inputs_v = has_inputs<V>::value

template<typename V>
static constexpr bool has_output_v = has_output<V>::value

template<typename V>
static constexpr bool has_variadic_input_v = has_variadic_input<V>::value

template<typename V, typename = void>
struct has_can_connect_different_execution_instances : public std::false_type

#include <vertex_concept.h>

template<typename V>
struct grenade::vx::signal_flow::detail::VertexConcept::has_can_connect_different_execution_instances<V, std::void_t<decltype(&V::can_connect_different_execution_instances)>>

#include <vertex_concept.h>

Public Static Attributes

static constexpr bool value = std::is_same_v<decltype(V::can_connect_different_execution_instances), bool const>

template<typename V, typename = void>
struct has_inputs : public std::false_type

#include <vertex_concept.h>

template<typename V>
struct grenade::vx::signal_flow::detail::VertexConcept::has_inputs<V, std::void_t<decltype(&V::inputs)>>

#include <vertex_concept.h>

Public Static Attributes

static constexpr bool value = IsInputsReturn<decltype(std::declval<V const>().inputs())>::value

template<typename V, typename = void>
struct has_output : public std::false_type

#include <vertex_concept.h>

template<typename V>
struct grenade::vx::signal_flow::detail::VertexConcept::has_output<V, std::void_t<decltype(&V::output)>>

#include <vertex_concept.h>

Public Static Attributes

static constexpr bool value = std::is_same_v<decltype(&V::output), Port (V::*)() const>

template<typename V, typename = void>
struct has_variadic_input : public std::false_type

#include <vertex_concept.h>

template<typename V>
struct grenade::vx::signal_flow::detail::VertexConcept::has_variadic_input<V, std::void_t<decltype(&V::variadic_input)>>

#include <vertex_concept.h>

Public Static Attributes

static constexpr bool value = std::is_same_v<decltype(V::variadic_input), bool const>

struct grenade::vx::signal_flow::ExecutionInstanceHooks

#include <execution_instance_hooks.h>

Hooks for an execution instance for complementing the graph-based experiment notation.

Public Types

typedef std::set<std::string> ReadPPUSymbols

typedef std::map<std::string, std::variant<std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, haldls::vx::v3::PPUMemoryBlock>, lola::vx::v3::ExternalPPUMemoryBlock>> WritePPUSymbols

Public Functions

ExecutionInstanceHooks() = default

ExecutionInstanceHooks(ExecutionInstanceHooks&&) = default

ExecutionInstanceHooks(ExecutionInstanceHooks const&) = delete

ExecutionInstanceHooks(stadls::vx::v3::PlaybackProgramBuilder &pre_static_config, stadls::vx::v3::PlaybackProgramBuilder &pre_realtime, stadls::vx::v3::PlaybackProgramBuilder &inside_realtime_begin, stadls::vx::v3::AbsoluteTimePlaybackProgramBuilder &inside_realtime, stadls::vx::v3::PlaybackProgramBuilder &inside_realtime_end, stadls::vx::v3::PlaybackProgramBuilder &post_realtime, WritePPUSymbols const &write_ppu_symbols = WritePPUSymbols(), ReadPPUSymbols const &read_ppu_symbols = ReadPPUSymbols())

ExecutionInstanceHooks &operator=(ExecutionInstanceHooks&&) = default

ExecutionInstanceHooks &operator=(ExecutionInstanceHooks const&) = delete

Public Members

stadls::vx::v3::AbsoluteTimePlaybackProgramBuilder inside_realtime

stadls::vx::v3::PlaybackProgramBuilder inside_realtime_begin

stadls::vx::v3::PlaybackProgramBuilder inside_realtime_end

stadls::vx::v3::PlaybackProgramBuilder post_realtime

stadls::vx::v3::PlaybackProgramBuilder pre_realtime

stadls::vx::v3::PlaybackProgramBuilder pre_static_config

ReadPPUSymbols read_ppu_symbols

PPU symbols to read after every batch entry.

WritePPUSymbols write_ppu_symbols

PPU symbols written once as part of the initialization process.

struct grenade::vx::signal_flow::ExecutionTimeInfo

#include <execution_time_info.h>

Public Functions

void merge(ExecutionTimeInfo &&other)

Merge other execution time info.

This merges all map-like structures and accumulates the others as well as already present map entries.

Parameters

other – Other execution time info to merge

void merge(ExecutionTimeInfo &other)

Merge other execution time info.

This merges all map-like structures and accumulates the others as well as already present map entries.

Parameters

other – Other execution time info to merge

Public Members

std::chrono::nanoseconds execution_duration = {0}

Total duration of execution.

This includes graph traversal, compilation of playback programs and post-processing of result. data.

std::map<halco::hicann_dls::vx::v3::DLSGlobal, std::chrono::nanoseconds> execution_duration_per_hardware = {}

Time spent in execution on hardware.

This is the accumulated time each connection spends in execution state of executing playback program instruction streams, that is from encoding and sending instructions to receiving all responses and decoding them up to the halt response.

std::map<common::ExecutionInstanceID, std::chrono::nanoseconds> realtime_duration_per_execution_instance = {}

Time spent in realtime section on hardware.

This is the accumulated time for each execution instance of the interval [0, runtime) for each batch entry. It is equivalent to the accumulated duration of the intervals during which event recording is enabled for each batch entry.

Friends

friend std::ostream &operator<<(std::ostream &os, ExecutionTimeInfo const &data)

class grenade::vx::signal_flow::Graph

#include <graph.h>

Placed computation graph.

A vertex represents a unit which processes data. An edge represents the data flow.

Vertices are physically and temporally placed on a specific ExecutionInstance. Data flow between different execution instances is restricted to off-chip data. Access to execution instance subgraphs and mapping between execution instance dependency graph and the complete data-flow graph is provided.

The dependence graph of execution instances has to be acyclic in order to be executable, while a subgraph tied to a execution instance can partly be cyclic, e.g. via recurrent routing of on-chip events. This is enforced by checks on addition of vertices/edges.

Public Types

typedef detail::edge_descriptor edge_descriptor

typedef std::map<edge_descriptor, std::optional<PortRestriction>> edge_property_map_type

Edge properties indexed by edge descriptor.

typedef boost::bimap<vertex_descriptor, boost::bimaps::set_of<common::ExecutionInstanceID>> execution_instance_map_type

Map between execution instance graph vertex descriptor and execution instance.

typedef detail::Graph graph_type

typedef detail::vertex_descriptor vertex_descriptor

typedef boost::bimap<boost::bimaps::set_of<vertex_descriptor>, boost::bimaps::multiset_of<vertex_descriptor>> vertex_descriptor_map_type

Map between descriptors of vertices and descriptor of execution instance graph vertex.

An execution instance graph vertex might relate to multiple vertices.

typedef std::vector<std::shared_ptr<Vertex>> vertex_property_map_type

Vertex properties indexed by vertex descriptor.

Public Functions

Graph(bool enable_acyclicity_check = true)

Construct graph.

Parameters

enable_acyclicity_check – Enable check for acyclicity in execution instance graph on every add call where a connection between previously unconnected execution instances is made.

Graph(Graph&&)

Graph(Graph const&)

vertex_descriptor add(vertex_descriptor vertex_reference, common::ExecutionInstanceID execution_instance, std::vector<Input> inputs)

Add vertex by reference on specified execution instance with specified inputs.

This is to be used to update input relations. TODO: We might want to have a more fancy vertex descriptor return type Perform checks for:

• connection between vertex types is allowed

• vertex inputs match provided input descriptors output

• connection does not lead to acyclicity

• connection goes forward in time

Parameters

• vertex_reference – Vertex reference configuration

• execution_instance – Execution instance to place on

• inputs – Positional list input vertex descriptors (with optional port restriction)

Returns

Vertex descriptor of added vertex

template<typename VertexT>
vertex_descriptor add(VertexT &&vertex, common::ExecutionInstanceID execution_instance, std::vector<Input> inputs)

Add vertex on specified execution instance with specified inputs.

No checks are performed against whether the section of specified chip instance is already used. TODO: We might want to have a more fancy vertex descriptor return type Perform checks for:

• connection between vertex types is allowed

• vertex inputs match provided input descriptors output

• connection does not lead to acyclicity

• connection goes forward in time

Parameters

• vertex – Vertex configuration

• execution_instance – Execution instance to place on

• inputs – Positional list input vertex descriptors (with optional port restriction)

Returns

Vertex descriptor of added vertex

edge_property_map_type const &get_edge_property_map() const

Get constant reference to edge property map.

Returns

Constant reference to edge property map

graph_type const &get_execution_instance_graph() const

Get constant reference to underlying graph of execution instances.

Returns

Constant reference to underlying graph of execution instances

execution_instance_map_type const &get_execution_instance_map() const

Get constant reference to vertex property map.

Returns

Constant reference to vertex property map

graph_type const &get_graph() const

Get constant reference to underlying graph.

Returns

Constant reference to underlying graph

vertex_descriptor_map_type const &get_vertex_descriptor_map() const

Get constant reference to vertex descriptor map.

Returns

Constant reference to vertex descriptor map

Vertex const &get_vertex_property(vertex_descriptor descriptor) const

Get constant reference to a vertex property.

Parameters

descriptor – Vertex descriptor to get property for

Returns

Constant reference to a vertex property

bool is_acyclic_execution_instance_graph() const

Get whether the underlying execution instance graph is acyclic.

This is a necessary requirement for executability.

Returns

Boolean value

bool operator!=(Graph const &other) const

Graph &operator=(Graph&&)

Graph &operator=(Graph const&)

bool operator==(Graph const &other) const

template<typename VertexT>
void update(vertex_descriptor vertex_reference, VertexT &&vertex)

Update value of vertex.

Ensures, that no value is updated, which would make graph illegal, i.e. the new vertex property has to be compatible with its inputs and all outgoing vertices have to be compatible with the new property.

Parameters

• vertex_reference – Reference to vertex to update value for

• vertex – Value to set

template<typename VertexT>
void update_and_relocate(vertex_descriptor vertex_reference, VertexT &&vertex, std::vector<Input> inputs)

Update value of vertex and relocate vertex with new inputs.

Ensures, that no value is updated, which would make graph illegal, i.e. the new vertex property has to be compatible with its new inputs and all outgoing vertices have to be compatible with the new property.

Parameters

• vertex_reference – Vertex to relocate

• inputs – New inputs to use

Private Functions

void add_edges(vertex_descriptor descriptor, common::ExecutionInstanceID const &execution_instance, std::vector<Input> const &inputs)

void add_log(vertex_descriptor descriptor, common::ExecutionInstanceID const &execution_instance, hate::Timer const &timer)

template<typename Vertex, typename InputVertex>
void check_execution_instances(Vertex const &vertex, InputVertex const &input_vertex, common::ExecutionInstanceID const &vertex_execution_instance, common::ExecutionInstanceID const &input_vertex_execution_instance)

void check_inputs(Vertex const &vertex, common::ExecutionInstanceID const &execution_instance, std::vector<Input> const &inputs)

template<typename Archive>
void load(Archive &ar, std::uint32_t)

template<typename Archive>
void save(Archive &ar, std::uint32_t) const

void update(vertex_descriptor vertex_reference, Vertex &&vertex)

void update_and_relocate(vertex_descriptor vertex_reference, Vertex &&vertex, std::vector<Input> inputs)

Private Members

edge_property_map_type m_edge_property_map

bool m_enable_acyclicity_check

std::unique_ptr<graph_type> m_execution_instance_graph

execution_instance_map_type m_execution_instance_map

std::unique_ptr<graph_type> m_graph

log4cxx::LoggerPtr m_logger

vertex_descriptor_map_type m_vertex_descriptor_map

vertex_property_map_type m_vertex_property_map

Private Static Functions

template<typename VertexPort, typename InputVertexPort>
static void check_input_port(VertexPort const &vertex_port, InputVertexPort const &input_vertex_port, std::optional<PortRestriction> const &input_vertex_port_restriction)

template<bool VariadicInput>
static void check_inputs_size(size_t vertex_inputs_size, size_t inputs_size)

template<typename Vertex, typename InputVertex>
static void check_supports_input_from(Vertex const &vertex, InputVertex const &input_vertex, std::optional<PortRestriction> const &input_port_restriction)

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, Graph const &graph)

Ostream operator of graph.

Prints graph topology in graphviz’ dot format. Vertices are in the format Type(descriptor), which allows identification of referenced vertices.

struct grenade::vx::signal_flow::Input

#include <input.h>

Input to a vertex in the data-flow graph comprised of a descriptor and an optional port restriction.

Public Types

typedef Graph::vertex_descriptor descriptor_type

Public Functions

inline Input(descriptor_type const &descriptor)

inline Input(descriptor_type const &descriptor, PortRestriction const &port_restriction)

bool operator!=(Input const &other) const

bool operator==(Input const &other) const

Public Members

descriptor_type descriptor

std::optional<PortRestriction> port_restriction

Friends

friend std::ostream &operator<<(std::ostream &os, Input const &data)

struct grenade::vx::signal_flow::InputData : public grenade::vx::signal_flow::Data

#include <input_data.h>

Data map used for input data in graph execution.

Public Types

typedef std::variant<std::vector<common::TimedDataSequence<std::vector<UInt32>>>, std::vector<common::TimedDataSequence<std::vector<UInt5>>>, std::vector<common::TimedDataSequence<std::vector<Int8>>>, std::vector<TimedSpikeToChipSequence>, std::vector<TimedSpikeFromChipSequence>, std::vector<TimedMADCSampleFromChipSequence>> Entry

Data entry for a vertex.

Public Functions

InputData()

InputData(InputData &&other)

InputData(InputData const&) = delete

size_t batch_size() const

Get number of elements in each batch of data.

Returns

Number of elements in batch

void clear()

Clear content of map.

bool empty() const

Get whether the map does not contain any elements.

Returns

Boolean value

void merge(Data &&other)

Merge other map content into this one’s.

Parameters

other – Other map to merge into this instance

void merge(Data &other)

Merge other map content into this one’s.

Parameters

other – Other map to merge into this instance

void merge(InputData &&other)

Merge other map content into this one’s.

Parameters

other – Other map to merge into this instance

void merge(InputData &other)

Merge other map content into this one’s.

Parameters

other – Other map to merge into this instance

InputData &operator=(InputData &&other)

InputData &operator=(InputData const &other) = delete

bool valid() const

Check that all map entries feature the same batch_size value.

Returns

Boolean value

Public Members

std::map<signal_flow::detail::vertex_descriptor, Entry> data

Data is connected to specified vertex descriptors.

Batch-support is enabled by storing batch-size many data elements aside each-other. Data is stored as shared_ptr to allow for inexpensive shallow copy of data for multiple vertices in the map.

std::map<common::ExecutionInstanceID, common::Time> inter_batch_entry_wait

Minimal waiting time between batch entries.

For the case of multiple realtime columns (multiple snippets per batch entry), only the inter_batch_entry_wait of the last realtime column will be processed.

std::vector<std::map<common::ExecutionInstanceID, common::Time>> runtime

Runtime time-interval data.

The runtime start time coincides with the spike events’ and MADC recording start time. Event data is only recorded during the runtime. If the runtime data is empty it is ignored.

Public Static Functions

static bool is_match(Entry const &entry, signal_flow::Port const &port)

Get whether the data held in the entry match the port shape and type information.

Parameters

• entry – Entry to check

• port – Port to check

Returns

Boolean value

struct grenade::vx::signal_flow::Int8 : public halco::common::detail::BaseType<Int8, int8_t>

#include <types.h>

8 bit wide signed integer value of e.g.

CADC membrane readouts.

In haldls we use unsigned values for the CADC readouts, this shall be a typesafe wrapper around int8_t, which we don’t currently have, since it relies on the interpretation of having the CADC baseline in the middle of the value range.

Public Functions

inline explicit constexpr Int8(value_type const value = 0)

struct grenade::vx::signal_flow::MADCSampleFromChip

#include <event.h>

From-chip MADC sample.

Public Types

typedef haldls::vx::v3::MADCSampleFromChip::Channel Channel

typedef haldls::vx::v3::MADCSampleFromChip::Value Value

Public Functions

MADCSampleFromChip() = default

inline MADCSampleFromChip(Value const value, Channel const channel)

bool operator!=(MADCSampleFromChip const &other) const

bool operator==(MADCSampleFromChip const &other) const

Public Members

Channel channel = {}

Value value = {}

Friends

friend std::ostream &operator<<(std::ostream &os, MADCSampleFromChip const &sample)

struct grenade::vx::signal_flow::OutputData : public grenade::vx::signal_flow::Data

#include <output_data.h>

Data map used for output data in graph execution.

Public Types

typedef std::map<common::ExecutionInstanceID, lola::vx::v3::Chip> Chips

typedef std::variant<std::vector<common::TimedDataSequence<std::vector<UInt32>>>, std::vector<common::TimedDataSequence<std::vector<UInt5>>>, std::vector<common::TimedDataSequence<std::vector<Int8>>>, std::vector<TimedSpikeToChipSequence>, std::vector<TimedSpikeFromChipSequence>, std::vector<TimedMADCSampleFromChipSequence>> Entry

Data entry for a vertex.

typedef std::vector<std::map<common::ExecutionInstanceID, std::map<std::string, std::variant<std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, haldls::vx::v3::PPUMemoryBlock>, lola::vx::v3::ExternalPPUMemoryBlock>>>> ReadPPUSymbols

Public Functions

OutputData()

OutputData(OutputData &&other)

OutputData(OutputData const&) = delete

size_t batch_size() const

Get number of elements in each batch of data.

Returns

Number of elements in batch

void clear()

Clear content of map.

bool empty() const

Get whether the map does not contain any elements.

Returns

Boolean value

void merge(Data &&other)

Merge other map content into this one’s.

Parameters

other – Other map to merge into this instance

void merge(Data &other)

Merge other map content into this one’s.

Parameters

other – Other map to merge into this instance

void merge(OutputData &&other)

Merge other map content into this one’s.

Parameters

other – Other map to merge into this instance

void merge(OutputData &other)

Merge other map content into this one’s.

Parameters

other – Other map to merge into this instance

OutputData &operator=(OutputData &&other)

OutputData &operator=(OutputData const &other) = delete

bool valid() const

Check that all map entries feature the same batch_size value.

Returns

Boolean value

Public Members

std::map<signal_flow::detail::vertex_descriptor, Entry> data

Data is connected to specified vertex descriptors.

Batch-support is enabled by storing batch-size many data elements aside each-other. Data is stored as shared_ptr to allow for inexpensive shallow copy of data for multiple vertices in the map.

std::optional<ExecutionTimeInfo> execution_time_info

Optional time information of performed execution to be filled by executor.

Chips pre_execution_chips

Pre-execution chip configuration including execution instance’s static configuration.

ReadPPUSymbols read_ppu_symbols

Read PPU symbols corresponding to requested symbols in ExecutionInstanceHooks.

Public Static Functions

static bool is_match(Entry const &entry, signal_flow::Port const &port)

Get whether the data held in the entry match the port shape and type information.

Parameters

• entry – Entry to check

• port – Port to check

Returns

Boolean value

Private Members

std::unique_ptr<std::mutex> mutex

Mutex guarding mutable operation merge() and clear().

Mutable access to map content shall be guarded with this mutex.

struct grenade::vx::signal_flow::Port

#include <port.h>

Description of a single data port of a vertex.

A port is described by the type of data to be transfered and a size of parallel transfered elements.

Public Functions

inline explicit constexpr Port(size_t const size, ConnectionType const type)

inline constexpr bool operator!=(Port const &other) const

inline constexpr bool operator==(Port const &other) const

Public Members

size_t size

Number of entries.

ConnectionType type

Connection type.

Friends

friend std::ostream &operator<<(std::ostream &os, Port const &port)

struct grenade::vx::signal_flow::PortRestriction

#include <port_restriction.h>

Interval restriction of a port.

This allows connecting a subset of a vertex’s output to another vertex’s input.

Public Functions

PortRestriction() = default

PortRestriction(size_t min, size_t max)

bool is_restriction_of(Port const &port) const

Get whether this port restriction is a valid restriction of the given port.

This is the case exactly if the range [min, max] is within the port’s range [0, size).

Parameters

port – Port to check

Returns

Boolean validity value

size_t max() const

Get maximal inclusive index.

Returns

Maximum of range

size_t min() const

Get minimal inclusive index.

Returns

Minimum of range

bool operator!=(PortRestriction const &other) const

bool operator==(PortRestriction const &other) const

size_t size() const

Get size of port restriction range [min, max].

Returns

Size value

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

size_t m_max = {0}

size_t m_min = {0}

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, PortRestriction const &data)

struct grenade::vx::signal_flow::UInt32 : public halco::common::detail::BaseType<UInt32, uint32_t>

#include <types.h>

32 bit wide unsigned integer value of e.g.

indices.

Public Functions

inline explicit constexpr UInt32(value_type const value = 0)

struct grenade::vx::signal_flow::vertex::BackgroundSpikeSource : public grenade::vx::signal_flow::vertex::EntityOnChip

#include <background_spike_source.h>

Background event source to the Crossbar.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

typedef haldls::vx::BackgroundSpikeSource Config

typedef halco::hicann_dls::vx::BackgroundSpikeSourceOnDLS Coordinate

Public Functions

BackgroundSpikeSource() = default

BackgroundSpikeSource(Config const &config, Coordinate const &coordinate, ChipCoordinate const &chip_coordinate = ChipCoordinate())

Construct BackgroundSpikeSource.

Parameters

• config – Config to use

• coordinate – Coordinate to use

• chip_coordinate – Coordinate of chip to use

Config const &get_config() const

Coordinate const &get_coordinate() const

inline constexpr std::array<Port, 0> inputs() const

bool operator!=(BackgroundSpikeSource const &other) const

bool operator!=(EntityOnChip const &other) const

bool operator==(BackgroundSpikeSource const &other) const

bool operator==(EntityOnChip const &other) const

inline constexpr Port output() const

template<typename InputVertex>
bool supports_input_from(InputVertex const &input, std::optional<PortRestriction> const &port_restriction) const

Whether entity on chip supports input from given vertex.

This is true exactly if the input vertex resides on the same chip or is not derived from EntityOnChip. When the derived-from vertex employs further restrictions this base-class method is to be checked within the derived-from method.

Public Members

ChipCoordinate chip_coordinate

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Config m_config

Coordinate m_coordinate

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, BackgroundSpikeSource const &config)

struct grenade::vx::signal_flow::vertex::CADCMembraneReadoutView : public grenade::vx::signal_flow::vertex::EntityOnChip

#include <cadc_membrane_readout_view.h>

Readout of membrane voltages via the CADC.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

typedef std::vector<std::vector<halco::hicann_dls::vx::v3::SynapseOnSynapseRow>> Columns

Columns to record as collection of collections of columns.

Each inner collection corresponds to one input port of the vertex and thus allows recording neurons from different non-contiguous input vertices.

enum class Mode

Values:

enumerator hagen

enumerator periodic

typedef std::vector<std::vector<lola::vx::v3::AtomicNeuron::Readout::Source>> Sources

typedef halco::hicann_dls::vx::v3::SynramOnDLS Synram

Public Functions

CADCMembraneReadoutView() = default

template<typename ColumnsT, typename SynramT, typename SourcesT>
explicit CADCMembraneReadoutView(ColumnsT &&columns, SynramT &&synram, Mode const &mode, SourcesT &&sources, ChipCoordinate const &chip_coordinate = ChipCoordinate())

Construct CADCMembraneReadoutView with specified size.

Parameters

columns – Columns to read out

Columns const &get_columns() const

Mode const &get_mode() const

Sources const &get_sources() const

Synram const &get_synram() const

std::vector<Port> inputs() const

bool operator!=(CADCMembraneReadoutView const &other) const

bool operator!=(EntityOnChip const &other) const

bool operator==(CADCMembraneReadoutView const &other) const

bool operator==(EntityOnChip const &other) const

Port output() const

template<typename InputVertex>
bool supports_input_from(InputVertex const &input, std::optional<PortRestriction> const &port_restriction) const

Whether entity on chip supports input from given vertex.

This is true exactly if the input vertex resides on the same chip or is not derived from EntityOnChip. When the derived-from vertex employs further restrictions this base-class method is to be checked within the derived-from method.

bool supports_input_from(NeuronView const &input, std::optional<PortRestriction> const &restriction) const

Public Members

ChipCoordinate chip_coordinate

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

void check(Columns const &columns, Sources const &sources)

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Columns m_columns = {}

Mode m_mode = {}

Sources m_sources = {}

Synram m_synram = {}

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, CADCMembraneReadoutView const &config)

struct grenade::vx::signal_flow::vertex::CrossbarL2Input : public grenade::vx::signal_flow::vertex::EntityOnChip

#include <crossbar_l2_input.h>

Input from the FPGA to the Crossbar.

Since the data to the individual channels is split afterwards, they are presented merged here.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

Public Functions

CrossbarL2Input(ChipCoordinate const &chip_coordinate = ChipCoordinate())

Construct CrossbarL2Input.

Parameters

chip_coordinate – Coordinate of chip to use

inline constexpr std::array<Port, 1> inputs() const

bool operator!=(CrossbarL2Input const &other) const

bool operator!=(EntityOnChip const &other) const

bool operator==(CrossbarL2Input const &other) const

bool operator==(EntityOnChip const &other) const

inline constexpr Port output() const

template<typename InputVertex>
bool supports_input_from(InputVertex const &input, std::optional<PortRestriction> const &port_restriction) const

Whether entity on chip supports input from given vertex.

This is true exactly if the input vertex resides on the same chip or is not derived from EntityOnChip. When the derived-from vertex employs further restrictions this base-class method is to be checked within the derived-from method.

Public Members

ChipCoordinate chip_coordinate

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, CrossbarL2Input const &config)

struct grenade::vx::signal_flow::vertex::CrossbarL2Output : public grenade::vx::signal_flow::vertex::EntityOnChip

#include <crossbar_l2_output.h>

Output from the Crossbar to the FPGA.

Since the data from the individual channels are merged, they are also presented merged here.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

Public Functions

CrossbarL2Output(ChipCoordinate const &chip_coordinate = ChipCoordinate())

Construct CrossbarL2Output.

Parameters

chip_coordinate – Coordinate of chip to use

inline constexpr std::array<Port, 1> inputs() const

bool operator!=(CrossbarL2Output const &other) const

bool operator!=(EntityOnChip const &other) const

bool operator==(CrossbarL2Output const &other) const

bool operator==(EntityOnChip const &other) const

inline constexpr Port output() const

bool supports_input_from(CrossbarNode const &input, std::optional<PortRestriction> const &restriction) const

template<typename InputVertex>
bool supports_input_from(InputVertex const &input, std::optional<PortRestriction> const &port_restriction) const

Whether entity on chip supports input from given vertex.

This is true exactly if the input vertex resides on the same chip or is not derived from EntityOnChip. When the derived-from vertex employs further restrictions this base-class method is to be checked within the derived-from method.

Public Members

ChipCoordinate chip_coordinate

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = true

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, CrossbarL2Output const &config)

struct grenade::vx::signal_flow::vertex::CrossbarNode : public grenade::vx::signal_flow::vertex::EntityOnChip

#include <crossbar_node.h>

Crossbar node.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

typedef haldls::vx::v3::CrossbarNode Config

typedef haldls::vx::v3::CrossbarNode::coordinate_type Coordinate

Public Functions

CrossbarNode() = default

CrossbarNode(Coordinate const &coordinate, Config const &config, ChipCoordinate const &chip_coordinate = ChipCoordinate())

Construct node at specified location with specified configuration.

Parameters

• coordinate – Location

• config – Configuration

• chip_coordinate – Coordinate of chip to use

Config const &get_config() const

Coordinate const &get_coordinate() const

inline constexpr std::array<Port, 1> inputs() const

bool operator!=(CrossbarNode const &other) const

bool operator!=(EntityOnChip const &other) const

bool operator==(CrossbarNode const &other) const

bool operator==(EntityOnChip const &other) const

inline constexpr Port output() const

bool supports_input_from(BackgroundSpikeSource const &input, std::optional<PortRestriction> const &restriction) const

template<typename InputVertex>
bool supports_input_from(InputVertex const &input, std::optional<PortRestriction> const &port_restriction) const

Whether entity on chip supports input from given vertex.

This is true exactly if the input vertex resides on the same chip or is not derived from EntityOnChip. When the derived-from vertex employs further restrictions this base-class method is to be checked within the derived-from method.

Public Members

ChipCoordinate chip_coordinate

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Config m_config = {}

Coordinate m_coordinate = {}

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, CrossbarNode const &config)

struct grenade::vx::signal_flow::vertex::DataInput

#include <data_input.h>

Formatted data input from memory.

Public Functions

DataInput() = default

explicit DataInput(ConnectionType output_type, size_t size)

Construct DataInput with specified size and data output type.

Parameters

• output_type – Output data type

• size – Number of data values

Throws

std::runtime_error – On output data type not supported

std::array<Port, 1> inputs() const

bool operator!=(DataInput const &other) const

bool operator==(DataInput const &other) const

Port output() const

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = true

static constexpr bool variadic_input = false

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

ConnectionType m_output_type = {}

size_t m_size = {}

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, DataInput const &config)

struct grenade::vx::signal_flow::vertex::DataOutput

#include <data_output.h>

Formatted data output to memory.

Public Functions

DataOutput() = default

explicit DataOutput(ConnectionType input_type, size_t size)

Construct DataOutput with specified size and data input type.

Parameters

• input_type – Input data type

• size – Number of data values

Throws

std::runtime_error – On input data type not supported

std::array<Port, 1> inputs() const

bool operator!=(DataOutput const &other) const

bool operator==(DataOutput const &other) const

Port output() const

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = true

static constexpr bool variadic_input = false

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

ConnectionType m_input_type = {}

size_t m_size = {}

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, DataOutput const &config)

struct grenade::vx::signal_flow::vertex::EntityOnChip : public grenade::vx::common::EntityOnChip

#include <entity_on_chip.h>

Entity on chip mixin carrying chip id information.

Subclassed by grenade::vx::signal_flow::vertex::BackgroundSpikeSource, grenade::vx::signal_flow::vertex::CADCMembraneReadoutView, grenade::vx::signal_flow::vertex::CrossbarL2Input, grenade::vx::signal_flow::vertex::CrossbarL2Output, grenade::vx::signal_flow::vertex::CrossbarNode, grenade::vx::signal_flow::vertex::MADCReadoutView, grenade::vx::signal_flow::vertex::NeuronEventOutputView, grenade::vx::signal_flow::vertex::NeuronView, grenade::vx::signal_flow::vertex::PADIBus, grenade::vx::signal_flow::vertex::PadReadoutView, grenade::vx::signal_flow::vertex::PlasticityRule, grenade::vx::signal_flow::vertex::SynapseArrayView, grenade::vx::signal_flow::vertex::SynapseArrayViewSparse, grenade::vx::signal_flow::vertex::SynapseDriver

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

Public Functions

explicit EntityOnChip(ChipCoordinate const &coordinate_chip = ChipCoordinate())

bool operator!=(EntityOnChip const &other) const

bool operator==(EntityOnChip const &other) const

template<typename InputVertex>
bool supports_input_from(InputVertex const &input, std::optional<PortRestriction> const &port_restriction) const

Whether entity on chip supports input from given vertex.

This is true exactly if the input vertex resides on the same chip or is not derived from EntityOnChip. When the derived-from vertex employs further restrictions this base-class method is to be checked within the derived-from method.

Public Members

ChipCoordinate chip_coordinate

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::vertex::ExternalInput

#include <external_input.h>

External input data source.

Public Functions

ExternalInput() = default

explicit ExternalInput(ConnectionType output_type, size_t size)

Construct external input data source with specified coordinate list.

Parameters

• output_type – Number of external input entries

• size – Number of external input entries

inline constexpr std::array<Port, 0> inputs() const

bool operator!=(ExternalInput const &other) const

bool operator==(ExternalInput const &other) const

Port output() const

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

ConnectionType m_output_type = {}

size_t m_size = {}

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, ExternalInput const &config)

struct grenade::vx::signal_flow::vertex::MADCReadoutView : public grenade::vx::signal_flow::vertex::EntityOnChip

#include <madc_readout.h>

Readout of neuron voltages via the MADC.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

Public Functions

MADCReadoutView() = default

explicit MADCReadoutView(Source const &first_source, std::optional<Source> const &second_source, SourceSelection const &source_selection, ChipCoordinate const &chip_coordinate = ChipCoordinate())

Construct MADCReadoutView.

Parameters

• first_source – Neuron source and location to read out

• second_source – Optional second neuron source and location to read out

• source_selection – Source selection config

• chip_coordinate – Coordinate of chip to use

Source const &get_first_source() const

std::optional<Source> const &get_second_source() const

SourceSelection const &get_source_selection() const

std::vector<Port> inputs() const

bool operator!=(EntityOnChip const &other) const

bool operator!=(MADCReadoutView const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(MADCReadoutView const &other) const

Port output() const

template<typename InputVertex>
bool supports_input_from(InputVertex const &input, std::optional<PortRestriction> const &port_restriction) const

Whether entity on chip supports input from given vertex.

This is true exactly if the input vertex resides on the same chip or is not derived from EntityOnChip. When the derived-from vertex employs further restrictions this base-class method is to be checked within the derived-from method.

bool supports_input_from(NeuronView const &input, std::optional<PortRestriction> const &restriction) const

Public Members

ChipCoordinate chip_coordinate

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Source m_first_source = {}

std::optional<Source> m_second_source = {}

SourceSelection m_source_selection = {}

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, MADCReadoutView const &config)

struct grenade::vx::signal_flow::vertex::MADCReadoutView::Source

#include <madc_readout.h>

Public Types

typedef halco::hicann_dls::vx::v3::AtomicNeuronOnDLS Coord

typedef lola::vx::v3::AtomicNeuron::Readout::Source Type

Public Functions

bool operator!=(Source const &other) const

bool operator==(Source const &other) const

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Public Members

Coord coord = {}

Type type = {}

struct grenade::vx::signal_flow::vertex::MADCReadoutView::SourceSelection

#include <madc_readout.h>

Configuration of (timed) selection between the two MADC channels.

Public Types

typedef halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection Initial

Initially selected channel.

typedef haldls::vx::v3::MADCConfig::ActiveMuxInputSelectLength Period

Period with which to switch between channels.

Public Functions

bool operator!=(SourceSelection const &other) const

bool operator==(SourceSelection const &other) const

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Public Members

Initial initial = {}

Period period = {}

struct grenade::vx::signal_flow::vertex::NeuronEventOutputView : public grenade::vx::signal_flow::vertex::EntityOnChip

#include <neuron_event_output_view.h>

A view of neuron event outputs into the routing crossbar.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

typedef std::vector<halco::hicann_dls::vx::v3::NeuronColumnOnDLS> Columns

typedef std::map<Row, std::vector<Columns>> Neurons

typedef halco::hicann_dls::vx::v3::NeuronRowOnDLS Row

Public Functions

NeuronEventOutputView() = default

NeuronEventOutputView(Neurons const &neurons, ChipCoordinate const &chip_coordinate = ChipCoordinate())

Construct NeuronEventOutputView with specified neurons.

Parameters

• neurons – Incoming neurons

• chip_coordinate – Coordinate of chip to use

Neurons const &get_neurons() const

std::vector<Port> inputs() const

Input ports are organized in the same order as the specified neuron views.

bool operator!=(EntityOnChip const &other) const

bool operator!=(NeuronEventOutputView const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(NeuronEventOutputView const &other) const

Port output() const

Output ports are sorted neuron event output channels.

template<typename InputVertex>
bool supports_input_from(InputVertex const &input, std::optional<PortRestriction> const &port_restriction) const

Whether entity on chip supports input from given vertex.

This is true exactly if the input vertex resides on the same chip or is not derived from EntityOnChip. When the derived-from vertex employs further restrictions this base-class method is to be checked within the derived-from method.

bool supports_input_from(NeuronView const &input, std::optional<PortRestriction> const &restriction) const

Public Members

ChipCoordinate chip_coordinate

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Neurons m_neurons = {}

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, NeuronEventOutputView const &config)

struct grenade::vx::signal_flow::vertex::NeuronView : public grenade::vx::signal_flow::vertex::EntityOnChip

#include <neuron_view.h>

A view of neuron circuits.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

typedef std::vector<halco::hicann_dls::vx::v3::NeuronColumnOnDLS> Columns

typedef std::vector<Config> Configs

typedef std::vector<bool> EnableResets

typedef halco::hicann_dls::vx::v3::NeuronRowOnDLS Row

Public Functions

NeuronView() = default

template<typename ColumnsT, typename ConfigsT, typename RowT>
explicit NeuronView(ColumnsT &&columns, ConfigsT &&enable_resets, RowT &&row, ChipCoordinate const &chip_coordinate = ChipCoordinate())

Construct NeuronView with specified neurons.

Parameters

• columns – Neuron columns

• enable_resets – Enable values for initial reset of the neurons

• row – Neuron row

• chip_coordinate – Coordinate of chip to use

Columns const &get_columns() const

Configs const &get_configs() const

Row const &get_row() const

std::array<Port, 1> inputs() const

bool operator!=(EntityOnChip const &other) const

bool operator!=(NeuronView const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(NeuronView const &other) const

Port output() const

template<typename InputVertex>
bool supports_input_from(InputVertex const &input, std::optional<PortRestriction> const &port_restriction) const

Whether entity on chip supports input from given vertex.

This is true exactly if the input vertex resides on the same chip or is not derived from EntityOnChip. When the derived-from vertex employs further restrictions this base-class method is to be checked within the derived-from method.

bool supports_input_from(SynapseArrayView const &input, std::optional<PortRestriction> const &restriction) const

ppu::NeuronViewHandle toNeuronViewHandle() const

Convert to neuron view handle for PPU programs.

Public Members

ChipCoordinate chip_coordinate

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = true

Private Functions

void check(Columns const &columns, Configs const &configs)

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Columns m_columns = {}

Configs m_configs = {}

Row m_row = {}

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, NeuronView const &config)

struct grenade::vx::signal_flow::vertex::NeuronView::Config

#include <neuron_view.h>

Public Types

typedef lola::vx::v3::AtomicNeuron::EventRouting::Address Label

Public Functions

bool operator!=(Config const &other) const

bool operator==(Config const &other) const

Public Members

bool enable_reset

std::optional<Label> label

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t version)

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::vertex::PADIBus : public grenade::vx::signal_flow::vertex::EntityOnChip

#include <padi_bus.h>

PADI bus connecting a set of crossbar nodes to a set of synapse drivers.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

typedef halco::hicann_dls::vx::v3::PADIBusOnDLS Coordinate

Public Functions

PADIBus() = default

PADIBus(Coordinate const &coordinate, ChipCoordinate const &chip_coordinate = ChipCoordinate())

Construct PADI bus at specified location.

Parameters

• coordinate – Location

• chip_coordinate – Coordinate of chip to use

Coordinate const &get_coordinate() const

inline constexpr std::array<Port, 1> inputs() const

bool operator!=(EntityOnChip const &other) const

bool operator!=(PADIBus const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(PADIBus const &other) const

inline constexpr Port output() const

bool supports_input_from(CrossbarNode const &input, std::optional<PortRestriction> const &restriction) const

template<typename InputVertex>
bool supports_input_from(InputVertex const &input, std::optional<PortRestriction> const &port_restriction) const

Whether entity on chip supports input from given vertex.

This is true exactly if the input vertex resides on the same chip or is not derived from EntityOnChip. When the derived-from vertex employs further restrictions this base-class method is to be checked within the derived-from method.

Public Members

ChipCoordinate chip_coordinate

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = true

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Coordinate m_coordinate = {}

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, PADIBus const &config)

struct grenade::vx::signal_flow::vertex::PadReadoutView : public grenade::vx::signal_flow::vertex::EntityOnChip

#include <pad_readout.h>

Readout of neuron voltages via a pad.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

typedef halco::hicann_dls::vx::v3::PadOnDLS Coordinate

Public Functions

PadReadoutView() = default

explicit PadReadoutView(Source const &source, Coordinate const &coordinate, ChipCoordinate const &chip_coordinate = ChipCoordinate())

Construct PadReadoutView.

Parameters

• source – Neuron source and location to read out

• coordinate – Pad to use

• chip_coordinate – Coordinate of chip to use

Coordinate const &get_coordinate() const

Source const &get_source() const

std::array<Port, 1> inputs() const

bool operator!=(EntityOnChip const &other) const

bool operator!=(PadReadoutView const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(PadReadoutView const &other) const

Port output() const

template<typename InputVertex>
bool supports_input_from(InputVertex const &input, std::optional<PortRestriction> const &port_restriction) const

Whether entity on chip supports input from given vertex.

This is true exactly if the input vertex resides on the same chip or is not derived from EntityOnChip. When the derived-from vertex employs further restrictions this base-class method is to be checked within the derived-from method.

bool supports_input_from(NeuronView const &input, std::optional<PortRestriction> const &restriction) const

Public Members

ChipCoordinate chip_coordinate

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Coordinate m_coordinate = {}

Source m_source = {}

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, PadReadoutView const &config)

struct grenade::vx::signal_flow::vertex::PadReadoutView::Source

#include <pad_readout.h>

Public Types

typedef halco::hicann_dls::vx::v3::AtomicNeuronOnDLS Coord

typedef lola::vx::v3::AtomicNeuron::Readout::Source Type

Public Functions

bool operator!=(Source const &other) const

bool operator==(Source const &other) const

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Public Members

Coord coord = {}

bool enable_buffered = {false}

Type type = {}

template<typename ElementT, typename Derived>
struct grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType

#include <observable_data_type.h>

Public Types

typedef ElementT ElementType

Private Functions

template<typename Archive>
inline void serialize(Archive&)

Friends

friend struct cereal::access

inline friend constexpr bool operator!=(Derived const&, Derived const&)

inline friend std::ostream &operator<<(std::ostream &os, Derived const&)

inline friend constexpr bool operator==(Derived const&, Derived const&)

struct grenade::vx::signal_flow::vertex::PlasticityRule : public grenade::vx::signal_flow::vertex::EntityOnChip

#include <plasticity_rule.h>

A plasticity rule to operate on synapse array views.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

typedef std::variant<RawRecording, TimedRecording> Recording

Recording information for execution of the rule.

typedef std::variant<RawRecordingData, TimedRecordingData> RecordingData

Public Functions

PlasticityRule() = default

PlasticityRule(std::string kernel, Timer const &timer, std::vector<SynapseViewShape> const &synapse_view_shapes, std::vector<NeuronViewShape> const &neuron_view_shapes, std::optional<Recording> const &recording, ChipCoordinate const &chip_coordinate = ChipCoordinate())

Construct PlasticityRule with specified kernel, timer and synapse information.

Parameters

• kernel – Kernel to apply

• timer – Timer to use

• synapse_view_shapes – Shapes of synapse views to alter

• neuron_view_shapes – Shapes of neuron views to alter

• recording – Optional recording providing memory for the plasticity rule to store information during execution.

• chip_coordinate – Coordinate of chip to use

RecordingData extract_recording_data(std::vector<common::TimedDataSequence<std::vector<signal_flow::Int8>>> const &data) const

Extract data corresponding to performed recording.

For RawRecording return the raw data, for TimedRecording extract observables of timed recording from raw data. This method is to be used after successful execution of aa graph incorporating this vertex instance.

Throws

std::runtime_error – On data not matching expectation

Parameters

data – Raw data to extract recording from

std::string const &get_kernel() const

std::vector<NeuronViewShape> const &get_neuron_view_shapes() const

std::pair<size_t, size_t> get_recorded_memory_data_interval() const

Get interval in memory layout of data within recording.

std::string get_recorded_memory_definition() const

Get C++ definition of recorded memory structure.

This structure is instantiated and made available to the plasticity rule kernel.

std::map<std::string, std::pair<size_t, size_t>> get_recorded_memory_timed_data_intervals() const

Get interval in memory layout of data within recorded events.

Data intervals are given per observable.

Throws

std::runtime_error – On no or raw recording type

size_t get_recorded_scratchpad_memory_alignment() const

Alignment (in bytes) of recorded scratchpad memory.

size_t get_recorded_scratchpad_memory_size() const

Size (in bytes) of recorded scratchpad memory, which is stored after execution and provided as output of this vertex.

When the recording is TimedRecording, the shapes of the synapse views are used to calculate the space requirement for the observables per synapse.

std::optional<Recording> get_recording() const

std::vector<SynapseViewShape> const &get_synapse_view_shapes() const

Timer const &get_timer() const

std::vector<Port> inputs() const

bool operator!=(EntityOnChip const &other) const

bool operator!=(PlasticityRule const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(PlasticityRule const &other) const

Port output() const

template<typename InputVertex>
bool supports_input_from(InputVertex const &input, std::optional<PortRestriction> const &port_restriction) const

Whether entity on chip supports input from given vertex.

This is true exactly if the input vertex resides on the same chip or is not derived from EntityOnChip. When the derived-from vertex employs further restrictions this base-class method is to be checked within the derived-from method.

bool supports_input_from(NeuronView const &input, std::optional<PortRestriction> const &restriction) const

bool supports_input_from(SynapseArrayView const &input, std::optional<PortRestriction> const &restriction) const

Public Members

ChipCoordinate chip_coordinate

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

std::string m_kernel

std::vector<NeuronViewShape> m_neuron_view_shapes

std::optional<Recording> m_recording

std::vector<SynapseViewShape> m_synapse_view_shapes

Timer m_timer

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, PlasticityRule const &config)

struct grenade::vx::signal_flow::vertex::PlasticityRule::NeuronViewShape

#include <plasticity_rule.h>

Shape of a single neuron view to be altered.

Public Types

typedef lola::vx::v3::AtomicNeuron::Readout::Source NeuronReadoutSource

Public Functions

bool operator!=(NeuronViewShape const &other) const

bool operator==(NeuronViewShape const &other) const

Public Members

NeuronView::Columns columns

Location of columns.

This information is needed for extraction of timed recording observables and measurement settings.

std::vector<std::optional<NeuronReadoutSource>> neuron_readout_sources

Readout source specification per neuron used for static configuration such that the plasticity rule can read the specified signal.

NeuronView::Row row

Row of neurons.

This information is required for extraction of timed recording observables and measurement settings.

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t version)

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, NeuronViewShape const &recording)

struct grenade::vx::signal_flow::vertex::PlasticityRule::RawRecording

#include <plasticity_rule.h>

Recording information for execution of the rule.

Raw recording of one scratchpad memory region for all timed invocations of the rule. No automated recording of time is performed.

Public Functions

bool operator!=(RawRecording const &other) const

bool operator==(RawRecording const &other) const

Public Members

size_t scratchpad_memory_size

Size (in bytes) of recorded scratchpad memory, which is stored after execution and provided as output of this vertex.

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t version)

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, RawRecording const &recording)

struct grenade::vx::signal_flow::vertex::PlasticityRule::RawRecordingData

#include <plasticity_rule.h>

Recording data corresponding to a raw recording.

Public Members

std::vector<std::vector<signal_flow::Int8>> data

Data with outer dimension being batch entries and inner dimension being the data per batch entry.

Friends

friend std::ostream &operator<<(std::ostream &os, RawRecordingData const &data)

struct grenade::vx::signal_flow::vertex::PlasticityRule::SynapseViewShape

#include <plasticity_rule.h>

Shape of a single synapse view to be altered.

Public Functions

bool operator!=(SynapseViewShape const &other) const

bool operator==(SynapseViewShape const &other) const

Public Members

std::vector<halco::hicann_dls::vx::v3::SynapseOnSynapseRow> columns

Location of columns.

This information is needed for extraction of timed recording observables.

halco::hicann_dls::vx::v3::HemisphereOnDLS hemisphere

Hemisphere of synapses.

This information is required for extraction of timed recording observables.

size_t num_rows

Number of rows.

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t version)

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, SynapseViewShape const &recording)

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording

#include <plasticity_rule.h>

Recording information for execution of the rule.

Recording of exclusive scratchpad memory per rule invocation with time recording and returned data as time-annotated events.

Public Types

typedef std::variant<ObservablePerSynapse, ObservablePerNeuron, ObservableArray> Observable

Observable type specification.

Public Functions

bool operator!=(TimedRecording const &other) const

bool operator==(TimedRecording const &other) const

Public Members

std::map<std::string, Observable> observables

Map of named observables with type information.

The plasticity rule kernel is given memory to record the observables generated with the same names as used in this map.

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t version)

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, TimedRecording const &recording)

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservableArray

#include <plasticity_rule.h>

Observable with array of values of configurable size.

Used for e.g. neuron firing rates.

Public Types

typedef std::variant<Type::Int8, Type::UInt8, Type::Int16, Type::UInt16> TypeVariant

Public Functions

ObservableArray() = default

ObservableArray(TypeVariant const &type, size_t size)

bool operator!=(ObservableArray const &other) const

bool operator==(ObservableArray const &other) const

Public Members

size_t size = 0

TypeVariant type = Type::int8

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t version)

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, ObservableArray const &observable)

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservableArray::Type

#include <plasticity_rule.h>

Public Static Attributes

static constexpr Int16 int16 = {}

static constexpr Int8 int8 = {}

static constexpr UInt16 uint16 = {}

static constexpr UInt8 uint8 = {}

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservableArray::Type::Int16 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<int16_t, Int16>

#include <plasticity_rule.h>

Public Types

typedef int16_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "int16_t"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservableArray::Type::Int8 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<int8_t, Int8>

#include <plasticity_rule.h>

Public Types

typedef int8_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "int8_t"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservableArray::Type::UInt16 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<uint16_t, UInt16>

#include <plasticity_rule.h>

Public Types

typedef uint16_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "uint16_t"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservableArray::Type::UInt8 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<uint8_t, UInt8>

#include <plasticity_rule.h>

Public Types

typedef uint8_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "uint8_t"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerNeuron

#include <plasticity_rule.h>

Observable with a single data entry per neuron.

Used for e.g. membrane potential measurements

Public Types

enum class Layout

Values:

enumerator complete_row

enumerator packed_active_columns

Record complete row of values.

This is fast, but inefficient memory-wise, since independent of the number of active columns in the neuron view the complete row is stored. The memory provided per row is of type libnux::vx::VectorRow{Mod,FracSat}{8,16} for type {u,}{int_}{8,16}. Record only active columns of neuron view. This is efficient memory-wise, but slow, since the values are stored sequentially per neuron. The memory provided per row is of type std::array<{u,}{int_}{8,16}_t, num_columns> for type {u,}{int_}{8,16}.

typedef std::variant<Type::Int8, Type::UInt8, Type::Int16, Type::UInt16> TypeVariant

Public Functions

ObservablePerNeuron() = default

ObservablePerNeuron(TypeVariant const &type, Layout const &layout_per_row)

bool operator!=(ObservablePerNeuron const &other) const

bool operator==(ObservablePerNeuron const &other) const

Public Members

enum grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerNeuron::Layout layout = Layout::complete_row

TypeVariant type = Type::int8

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t version)

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, ObservablePerNeuron const &observable)

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerNeuron::Type

#include <plasticity_rule.h>

Public Static Attributes

static constexpr Int16 int16 = {}

static constexpr Int8 int8 = {}

static constexpr UInt16 uint16 = {}

static constexpr UInt8 uint8 = {}

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerNeuron::Type::Int16 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<int16_t, Int16>

#include <plasticity_rule.h>

Public Types

typedef int16_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowFracSat16"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerNeuron::Type::Int8 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<int8_t, Int8>

#include <plasticity_rule.h>

Public Types

typedef int8_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowFracSat8"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerNeuron::Type::UInt16 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<uint16_t, UInt16>

#include <plasticity_rule.h>

Public Types

typedef uint16_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowMod16"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerNeuron::Type::UInt8 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<uint8_t, UInt8>

#include <plasticity_rule.h>

Public Types

typedef uint8_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowMod8"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerSynapse

#include <plasticity_rule.h>

Observable with a single data entry per synapse.

Used for e.g. weights and correlation measurements

Public Types

enum class LayoutPerRow

Values:

enumerator complete_rows

enumerator packed_active_columns

Record complete rows of values.

This is fast, but inefficient memory-wise, since independent of the number of active columns in the synapse view the complete row is stored. The memory provided per row is of type libnux::vx::VectorRow{Mod,FracSat}{8,16} for type {u,}{int_}{8,16}. Record only active columns of synapse view. This is efficient memory-wise, but slow, since the values are stored sequentially per synapse. The memory provided per row is of type std::array<{u,}{int_}{8,16}_t, num_columns> for type {u,}{int_}{8,16}.

typedef std::variant<Type::Int8, Type::UInt8, Type::Int16, Type::UInt16> TypeVariant

Public Functions

ObservablePerSynapse() = default

ObservablePerSynapse(TypeVariant const &type, LayoutPerRow const &layout_per_row)

bool operator!=(ObservablePerSynapse const &other) const

bool operator==(ObservablePerSynapse const &other) const

Public Members

enum grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerSynapse::LayoutPerRow layout_per_row = LayoutPerRow::complete_rows

TypeVariant type = Type::int8

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t version)

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, ObservablePerSynapse const &observable)

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerSynapse::Type

#include <plasticity_rule.h>

Public Static Attributes

static constexpr Int16 int16 = {}

static constexpr Int8 int8 = {}

static constexpr UInt16 uint16 = {}

static constexpr UInt8 uint8 = {}

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerSynapse::Type::Int16 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<int16_t, Int16>

#include <plasticity_rule.h>

Public Types

typedef int16_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowFracSat16"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerSynapse::Type::Int8 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<int8_t, Int8>

#include <plasticity_rule.h>

Public Types

typedef int8_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowFracSat8"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerSynapse::Type::UInt16 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<uint16_t, UInt16>

#include <plasticity_rule.h>

Public Types

typedef uint16_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowMod16"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerSynapse::Type::UInt8 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<uint8_t, UInt8>

#include <plasticity_rule.h>

Public Types

typedef uint8_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowMod8"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecordingData

#include <plasticity_rule.h>

Extracted recorded data of observables corresponding to timed recording.

Public Types

typedef std::variant<std::vector<common::TimedDataSequence<std::vector<int8_t>>>, std::vector<common::TimedDataSequence<std::vector<uint8_t>>>, std::vector<common::TimedDataSequence<std::vector<int16_t>>>, std::vector<common::TimedDataSequence<std::vector<uint16_t>>>> Entry

Public Members

std::map<std::string, Entry> data_array

std::map<std::string, std::vector<Entry>> data_per_neuron

std::map<std::string, std::vector<Entry>> data_per_synapse

Friends

friend std::ostream &operator<<(std::ostream &os, TimedRecordingData const &data)

struct grenade::vx::signal_flow::vertex::PlasticityRule::Timer

#include <plasticity_rule.h>

Timing information for execution of the rule.

Public Functions

bool operator!=(Timer const &other) const

bool operator==(Timer const &other) const

Public Members

size_t num_periods

Value period

Value start

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t version)

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, Timer const &timer)

struct grenade::vx::signal_flow::vertex::PlasticityRule::Timer::Value : public halco::common::detail::RantWrapper<Value, uintmax_t, 0xffffffff, 0>

#include <plasticity_rule.h>

PPU clock cycles.

Public Functions

inline explicit constexpr Value(uintmax_t const value = 0)

struct grenade::vx::signal_flow::vertex::SynapseArrayView : public grenade::vx::signal_flow::vertex::EntityOnChip

#include <synapse_array_view.h>

A rectangular view of synapses connected to a set of synapse drivers.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

typedef std::vector<halco::hicann_dls::vx::v3::SynapseOnSynapseRow> Columns

typedef std::vector<std::vector<lola::vx::v3::SynapseMatrix::Label>> Labels

typedef std::vector<halco::hicann_dls::vx::v3::SynapseRowOnSynram> Rows

typedef halco::hicann_dls::vx::v3::SynramOnDLS Synram

typedef std::vector<std::vector<lola::vx::v3::SynapseMatrix::Weight>> Weights

Public Functions

SynapseArrayView() = default

template<typename SynramT, typename RowsT, typename ColumnsT, typename WeightsT, typename LabelsT>
explicit SynapseArrayView(SynramT &&synram, RowsT &&rows, ColumnsT &&columns, WeightsT &&weights, LabelsT &&labels, ChipCoordinate const &chip_coordinate = ChipCoordinate())

Construct synapse array view.

Parameters

• synram – Synram location of synapses

• rows – Coordinates of rows

• columns – Coordinates of columns

• weights – Weight values

• labels – Label values

• chip_coordinate – Coordinate of chip to use

boost::iterator_range<Columns::const_iterator> get_columns() const

Accessor to synapse column coordinates via a range.

Returns

Range of synapse column coordinates

boost::iterator_range<Labels::const_iterator> get_labels() const

Accessor to label configuration via a range.

Returns

Range of label configuration

boost::iterator_range<Rows::const_iterator> get_rows() const

Accessor to synapse row coordinates via a range.

Returns

Range of synapse row coordinates

Synram const &get_synram() const

boost::iterator_range<Weights::const_iterator> get_weights() const

Accessor to weight configuration via a range.

Returns

Range of weight configuration

std::vector<Port> inputs() const

bool operator!=(EntityOnChip const &other) const

bool operator!=(SynapseArrayView const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(SynapseArrayView const &other) const

Port output() const

template<typename InputVertex>
bool supports_input_from(InputVertex const &input, std::optional<PortRestriction> const &port_restriction) const

Whether entity on chip supports input from given vertex.

This is true exactly if the input vertex resides on the same chip or is not derived from EntityOnChip. When the derived-from vertex employs further restrictions this base-class method is to be checked within the derived-from method.

Public Members

ChipCoordinate chip_coordinate

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

void check(Rows const &rows, Columns const &columns, Weights const &weights, Labels const &labels)

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Columns m_columns = {}

Labels m_labels = {}

Rows m_rows = {}

Synram m_synram = {}

Weights m_weights = {}

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, SynapseArrayView const &config)

struct grenade::vx::signal_flow::vertex::SynapseArrayViewSparse : public grenade::vx::signal_flow::vertex::EntityOnChip

#include <synapse_array_view_sparse.h>

A sparse view of synapses connected to a set of synapse drivers.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

typedef std::vector<halco::hicann_dls::vx::v3::SynapseOnSynapseRow> Columns

typedef std::vector<halco::hicann_dls::vx::v3::SynapseRowOnSynram> Rows

typedef std::vector<Synapse> Synapses

typedef halco::hicann_dls::vx::v3::SynramOnDLS Synram

Public Functions

SynapseArrayViewSparse() = default

template<typename SynramT, typename RowsT, typename ColumnsT, typename SynapsesT>
explicit SynapseArrayViewSparse(SynramT &&synram, RowsT &&rows, ColumnsT &&columns, SynapsesT &&synapses, ChipCoordinate const &chip_coordinate = ChipCoordinate())

Construct synapse array view.

Parameters

• synram – Synram location of synapses

• rows – Coordinates of rows

• columns – Coordinates of columns

• synapses – Synapse values

• chip_coordinate – Coordinate of chip to use

boost::iterator_range<Columns::const_iterator> get_columns() const

Accessor to synapse column coordinates via a range.

Returns

Range of synapse column coordinates

boost::iterator_range<Rows::const_iterator> get_rows() const

Accessor to synapse row coordinates via a range.

Returns

Range of synapse row coordinates

boost::iterator_range<Synapses::const_iterator> get_synapses() const

Accessor to synapse configuration via a range.

Returns

Range of synapse configuration

Synram const &get_synram() const

std::vector<Port> inputs() const

bool operator!=(EntityOnChip const &other) const

bool operator!=(SynapseArrayViewSparse const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(SynapseArrayViewSparse const &other) const

Port output() const

template<typename InputVertex>
bool supports_input_from(InputVertex const &input, std::optional<PortRestriction> const &port_restriction) const

Whether entity on chip supports input from given vertex.

This is true exactly if the input vertex resides on the same chip or is not derived from EntityOnChip. When the derived-from vertex employs further restrictions this base-class method is to be checked within the derived-from method.

ppu::SynapseArrayViewHandle toSynapseArrayViewHandle() const

Convert to synapse array view handle for PPU programs.

Public Members

ChipCoordinate chip_coordinate

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

void check(Rows const &rows, Columns const &columns, Synapses const &synapses)

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Columns m_columns = {}

Rows m_rows = {}

Synapses m_synapses = {}

Synram m_synram = {}

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, SynapseArrayViewSparse const &config)

struct grenade::vx::signal_flow::vertex::SynapseArrayViewSparse::Synapse

#include <synapse_array_view_sparse.h>

Public Functions

bool operator!=(Synapse const &other) const

bool operator==(Synapse const &other) const

Public Members

size_t index_column

size_t index_row

lola::vx::v3::SynapseMatrix::Label label

lola::vx::v3::SynapseMatrix::Weight weight

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::vertex::SynapseDriver : public grenade::vx::signal_flow::vertex::EntityOnChip

#include <synapse_driver.h>

Synapse driver.

Public Types

typedef halco::hicann_dls::vx::v3::DLSGlobal ChipCoordinate

typedef halco::hicann_dls::vx::v3::SynapseDriverOnDLS Coordinate

Public Functions

SynapseDriver() = default

SynapseDriver(Coordinate const &coordinate, Config const &config, ChipCoordinate const &chip_coordinate = ChipCoordinate())

Construct synapse driver at specified location with specified configuration.

Parameters

• coordinate – Location

• config – Configuration

• chip_coordinate – Coordinate of chip to use

Config get_config() const

Coordinate get_coordinate() const

inline constexpr std::array<Port, 1> inputs() const

bool operator!=(EntityOnChip const &other) const

bool operator!=(SynapseDriver const &other) const

bool operator==(EntityOnChip const &other) const

bool operator==(SynapseDriver const &other) const

inline constexpr Port output() const

template<typename InputVertex>
bool supports_input_from(InputVertex const &input, std::optional<PortRestriction> const &port_restriction) const

Whether entity on chip supports input from given vertex.

This is true exactly if the input vertex resides on the same chip or is not derived from EntityOnChip. When the derived-from vertex employs further restrictions this base-class method is to be checked within the derived-from method.

bool supports_input_from(PADIBus const &input, std::optional<PortRestriction> const &restriction) const

Public Members

ChipCoordinate chip_coordinate

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Config m_config = {}

Coordinate m_coordinate = {}

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, SynapseDriver const &config)

struct grenade::vx::signal_flow::vertex::SynapseDriver::Config

#include <synapse_driver.h>

Public Types

typedef haldls::vx::v3::SynapseDriverConfig::RowAddressCompareMask RowAddressCompareMask

typedef halco::common::typed_array<haldls::vx::v3::SynapseDriverConfig::RowMode, halco::hicann_dls::vx::v3::SynapseRowOnSynapseDriver> RowModes

Public Functions

bool operator!=(Config const &other) const

bool operator==(Config const &other) const

Public Members

bool enable_address_out = {false}

RowAddressCompareMask row_address_compare_mask = {}

RowModes row_modes = {}

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::vertex::Transformation

#include <transformation.h>

Formatted data input from memory.

Public Functions

Transformation() = default

explicit Transformation(std::unique_ptr<Function> function)

Construct Transformation with specified function.

Parameters

function – Function to apply on transformation

Transformation(Transformation &&other)

Transformation(Transformation const &other)

Function::Value apply(std::vector<Function::Value> const &value) const

Apply transformation.

Parameters

value – Input value

Returns

Output value

std::vector<Port> inputs() const

bool operator!=(Transformation const &other) const

Transformation &operator=(Transformation &&other)

Transformation &operator=(Transformation const &other)

bool operator==(Transformation const &other) const

Port output() const

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = true

static constexpr bool variadic_input = false

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

std::unique_ptr<Function> m_function = {}

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream &os, Transformation const &config)

struct grenade::vx::signal_flow::vertex::transformation::Addition : public grenade::vx::signal_flow::vertex::Transformation::Function

#include <addition.h>

Addition of multiple inputs of signal_flow::Int8 data type.

Public Types

typedef signal_flow::Data::Entry Value

Public Functions

Addition() = default

Addition(size_t num_inputs, size_t size)

Construct addition transformation with specified number of inputs and their size.

Parameters

• num_inputs – Number of inputs

• size – Number of data values per input

~Addition()

virtual Value apply(std::vector<Value> const &value) const

Apply function on input value.

Parameters

value – Input value

Returns

Transformed output value

virtual std::unique_ptr<Transformation::Function> clone() const

virtual bool equal(Transformation::Function const &other) const

virtual std::vector<Port> inputs() const

Provided input ports provided.

Returns

Port

virtual Port output() const

Single output port provided.

Returns

Port

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

size_t m_num_inputs = {}

size_t m_size = {}

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::vertex::transformation::ArgMax : public grenade::vx::signal_flow::vertex::Transformation::Function

#include <argmax.h>

ArgMax of multiple inputs.

Public Types

typedef signal_flow::Data::Entry Value

Public Functions

ArgMax() = default

ArgMax(size_t size, ConnectionType type)

Construct argmax transformation with data type and size.

Parameters

• size – Number of data values

• type – Type of data to compute argmax over

~ArgMax()

virtual Value apply(std::vector<Value> const &value) const

Apply function on input value.

Parameters

value – Input value

Returns

Transformed output value

virtual std::unique_ptr<Transformation::Function> clone() const

virtual bool equal(Transformation::Function const &other) const

virtual std::vector<Port> inputs() const

Provided input ports provided.

Returns

Port

virtual Port output() const

Single output port provided.

Returns

Port

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

size_t m_size = {}

ConnectionType m_type = {}

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::vertex::transformation::Concatenation : public grenade::vx::signal_flow::vertex::Transformation::Function

#include <concatenation.h>

Public Types

typedef signal_flow::Data::Entry Value

Public Functions

Concatenation() = default

Concatenation(ConnectionType type, std::vector<size_t> const &sizes)

Construct concatenation transformation with data type and sizes to concatenate.

Parameters

• type – Data type

• sizes – Sizes

~Concatenation()

virtual Value apply(std::vector<Value> const &value) const

Apply function on input value.

Parameters

value – Input value

Returns

Transformed output value

virtual std::unique_ptr<Transformation::Function> clone() const

virtual bool equal(Transformation::Function const &other) const

virtual std::vector<Port> inputs() const

Provided input ports provided.

Returns

Port

virtual Port output() const

Single output port provided.

Returns

Port

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

std::vector<size_t> m_sizes = {}

ConnectionType m_type = {}

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::vertex::transformation::ConvertingReLU : public grenade::vx::signal_flow::vertex::Transformation::Function

#include <converting_relu.h>

ConvertingReLU of multiple inputs from signal_flow::Int8 to signal_flow::UInt5.

Public Types

typedef signal_flow::Data::Entry Value

Public Functions

ConvertingReLU() = default

ConvertingReLU(size_t size, uint32_t shift)

Construct converting relu transformation with data size and configuration.

Parameters

• size – Number of data values per input

• shift – Number of bits to shift after relu before clamping

~ConvertingReLU()

virtual Value apply(std::vector<Value> const &value) const

Apply function on input value.

Parameters

value – Input value

Returns

Transformed output value

virtual std::unique_ptr<Transformation::Function> clone() const

virtual bool equal(Transformation::Function const &other) const

virtual std::vector<Port> inputs() const

Provided input ports provided.

Returns

Port

virtual Port output() const

Single output port provided.

Returns

Port

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

uint32_t m_shift

size_t m_size

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::vertex::Transformation::Function

#include <transformation.h>

Function base for transforming a single input value to a single output value.

Subclassed by grenade::vx::network::vertex::transformation::ExternalSourceMerger, grenade::vx::signal_flow::vertex::transformation::Addition, grenade::vx::signal_flow::vertex::transformation::ArgMax, grenade::vx::signal_flow::vertex::transformation::Concatenation, grenade::vx::signal_flow::vertex::transformation::ConvertingReLU, grenade::vx::signal_flow::vertex::transformation::MACSpikeTrainGenerator, grenade::vx::signal_flow::vertex::transformation::ReLU, grenade::vx::signal_flow::vertex::transformation::SpikePacking, grenade::vx::signal_flow::vertex::transformation::Subtraction

Public Types

typedef signal_flow::Data::Entry Value

Public Functions

virtual ~Function() = 0

virtual Value apply(std::vector<Value> const &value) const = 0

Apply function on input value.

Parameters

value – Input value

Returns

Transformed output value

virtual std::unique_ptr<Function> clone() const = 0

virtual bool equal(Function const &other) const = 0

virtual std::vector<Port> inputs() const = 0

Provided input ports provided.

Returns

Port

virtual Port output() const = 0

Single output port provided.

Returns

Port

struct grenade::vx::signal_flow::vertex::transformation::MACSpikeTrainGenerator : public grenade::vx::signal_flow::vertex::Transformation::Function

#include <mac_spiketrain_generator.h>

Public Types

typedef signal_flow::Data::Entry Value

Public Functions

MACSpikeTrainGenerator() = default

MACSpikeTrainGenerator(halco::common::typed_array<size_t, halco::hicann_dls::vx::v3::HemisphereOnDLS> const &hemisphere_sizes, size_t num_sends, common::Time wait_between_events)

Construct spiketrain generator transformation.

Parameters

• hemisphere_sizes – Hemisphere sizes for which to generate spikeTrain for. This setting corresponds to the number of inputs expected from the transformation, where for each hemisphere size > 0 an input is expected.

• num_sends – Number of times a input activation is sent to the specific row

• wait_between_events – Wait time between input events in FPGA cycles

~MACSpikeTrainGenerator()

virtual Value apply(std::vector<Value> const &value) const

Apply function on input value.

Parameters

value – Input value

Returns

Transformed output value

virtual std::unique_ptr<Transformation::Function> clone() const

virtual bool equal(Transformation::Function const &other) const

virtual std::vector<Port> inputs() const

Provided input ports provided.

Returns

Port

virtual Port output() const

Single output port provided.

Returns

Port

Private Functions

FRIEND_TEST(::MACSpikeTrainGenerator, get_spike_label)

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

halco::common::typed_array<size_t, halco::hicann_dls::vx::v3::HemisphereOnDLS> m_hemisphere_sizes

size_t m_num_sends = {}

common::Time m_wait_between_events = {}

Private Static Functions

static std::optional<halco::hicann_dls::vx::v3::SpikeLabel> get_spike_label(halco::hicann_dls::vx::v3::SynapseDriverOnDLS const &driver, signal_flow::UInt5 const value)

Get spike label value from location and activation value.

Parameters

• row – Synapse driver to send to

• value – Activation value to send

Returns

SpikeLabel value if activation value is larger than zero

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::vertex::transformation::ReLU : public grenade::vx::signal_flow::vertex::Transformation::Function

#include <relu.h>

ReLU of multiple inputs of signal_flow::Int8 data type.

Public Types

typedef signal_flow::Data::Entry Value

Public Functions

ReLU() = default

ReLU(size_t size)

Construct reul transformation with data size.

Parameters

size – Number of data values per input

~ReLU()

virtual Value apply(std::vector<Value> const &value) const

Apply function on input value.

Parameters

value – Input value

Returns

Transformed output value

virtual std::unique_ptr<Transformation::Function> clone() const

virtual bool equal(Transformation::Function const &other) const

virtual std::vector<Port> inputs() const

Provided input ports provided.

Returns

Port

virtual Port output() const

Single output port provided.

Returns

Port

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

size_t m_size = {}

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::vertex::transformation::SpikePacking : public grenade::vx::signal_flow::vertex::Transformation::Function

#include <spike_packing.h>

Transformation packing single spikes into double spikes when times match.

Public Types

typedef signal_flow::Data::Entry Value

Public Functions

SpikePacking() = default

~SpikePacking()

virtual Value apply(std::vector<Value> const &value) const

Apply function on input value.

Parameters

value – Input value

Returns

Transformed output value

virtual std::unique_ptr<Transformation::Function> clone() const

virtual bool equal(signal_flow::vertex::Transformation::Function const &other) const

virtual std::vector<signal_flow::Port> inputs() const

Provided input ports provided.

Returns

Port

virtual signal_flow::Port output() const

Single output port provided.

Returns

Port

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::vertex::transformation::Subtraction : public grenade::vx::signal_flow::vertex::Transformation::Function

#include <subtraction.h>

Subtraction of multiple inputs of signal_flow::Int8 data type.

Public Types

typedef signal_flow::Data::Entry Value

Public Functions

Subtraction() = default

Subtraction(size_t num_inputs, size_t size)

Construct subtraction transformation with specified number of inputs and their size.

Parameters

• num_inputs – Number of inputs

• size – Number of data values per input

~Subtraction()

virtual Value apply(std::vector<Value> const &value) const

Apply function on input value.

Parameters

value – Input value

Returns

Transformed output value

virtual std::unique_ptr<Transformation::Function> clone() const

virtual bool equal(Transformation::Function const &other) const

virtual std::vector<Port> inputs() const

Provided input ports provided.

Returns

Port

virtual Port output() const

Single output port provided.

Returns

Port

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

size_t m_num_inputs = {}

size_t m_size = {}

Friends

friend struct cereal::access

struct grenade::vx::TemporaryDirectory

#include <ppu.h>

Create (and automatically delete) temporary directory.

Public Functions

TemporaryDirectory(std::string directory_template)

~TemporaryDirectory()

std::filesystem::path get_path() const

Private Members

std::filesystem::path m_path

template<>
struct std::hash<grenade::vx::network::Receptor>

#include <receptor.h>

Public Functions

inline size_t operator()(grenade::vx::network::Receptor const &t) const

template<>
struct std::hash<grenade::vx::signal_flow::detail::Graph::edge_descriptor>

#include <graph.h>

Public Functions

inline size_t operator()(grenade::vx::signal_flow::detail::Graph::edge_descriptor const &e) const

namespace boost

namespace cereal

namespace common

namespace grenade

namespace grenade::vx

Functions

halco::common::typed_array<int8_t, halco::hicann_dls::vx::v3::NeuronColumnOnDLS> from_vector_unit_row(haldls::vx::v3::PPUMemoryBlock const &values)

Convert PPUMemoryBlock to column byte values.

std::string get_include_paths()

Get include paths.

std::string get_libnux_runtime(std::string const &name)

Get full path to libnux runtime.

Parameters

name – Name to search for

std::string get_library_paths()

Get library paths.

std::string get_linker_file(std::string const &name)

Get full path to linker file.

Parameters

name – Name to search for

std::string get_program_base_source()

Get full path to PPU program source.

haldls::vx::v3::PPUMemoryBlock to_vector_unit_row(halco::common::typed_array<int8_t, halco::hicann_dls::vx::v3::NeuronColumnOnDLS> const &values)

Convert column byte values to PPUMemoryBlock.

Variables

static constexpr size_t num_cadc_samples_in_extmem = 100

static constexpr size_t ppu_vector_alignment = 128

namespace grenade::vx::common

Typedefs

template<typename T>
using TimedDataSequence = std::vector<TimedData<T>>

namespace detail

namespace compute

namespace detail

namespace grenade::vx::execution

Functions

signal_flow::OutputData run(JITGraphExecutor &executor, signal_flow::Graph const &graph, JITGraphExecutor::ChipConfigs const &initial_config, signal_flow::InputData const &input, JITGraphExecutor::Hooks &&hooks = {})

Run the specified graph with specified inputs on the supplied executor.

Parameters

• executor – Executor to use

• graph – Graph to execute

• initial_config – Map of initial configuration

• input – List of input values to use

• hooks – Map of playback sequence collections to be inserted at specified execution instances

std::vector<signal_flow::OutputData> run(JITGraphExecutor &executor, std::vector<std::reference_wrapper<signal_flow::Graph const>> const &graphs, std::vector<std::reference_wrapper<JITGraphExecutor::ChipConfigs const>> const &configs, std::vector<std::reference_wrapper<signal_flow::InputData const>> const &inputs, JITGraphExecutor::Hooks &&hooks = {})

Run the specified graphs with specified inputs on the supplied executor.

Parameters

• executor – Executor to use

• graphs – Graphs to execute (one per realtime_column)

• configs – Maps of configurations (one per realtime_column)

• input – Lists of input values to use (one per realtime_column)

• hooks – Map of playback sequence collections to be inserted at specified execution instances

namespace grenade::vx::execution::backend

Functions

stadls::vx::RunTimeInfo run(Connection &connection, stadls::vx::v3::PlaybackProgram &&program)

Execute given playback program using the given connection.

Parameters

• connection – Connection to run on

• program – Program to execute

Returns

Run time information of execution

stadls::vx::RunTimeInfo run(Connection &connection, stadls::vx::v3::PlaybackProgram &program)

Execute given playback program using the given connection.

Parameters

• connection – Connection to run on

• program – Program to execute

Returns

Run time information of execution

namespace detail

namespace generator

namespace grenade::vx::network

Typedefs

typedef common::TimedData<std::vector<int16_t>> _ArrayEntryInt16

typedef common::TimedData<std::vector<int8_t>> _ArrayEntryInt8

typedef common::TimedData<std::vector<uint16_t>> _ArrayEntryUInt16

typedef common::TimedData<std::vector<uint8_t>> _ArrayEntryUInt8

typedef common::TimedData<std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<int16_t>>>> _SingleEntryPerNeuronInt16

typedef common::TimedData<std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<int8_t>>>> _SingleEntryPerNeuronInt8

typedef common::TimedData<std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<uint16_t>>>> _SingleEntryPerNeuronUInt16

typedef common::TimedData<std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<uint8_t>>>> _SingleEntryPerNeuronUInt8

typedef common::TimedData<std::vector<std::vector<int16_t>>> _SingleEntryPerSynapseInt16

typedef common::TimedData<std::vector<std::vector<int8_t>>> _SingleEntryPerSynapseInt8

typedef common::TimedData<std::vector<std::vector<uint16_t>>> _SingleEntryPerSynapseUInt16

typedef common::TimedData<std::vector<std::vector<uint8_t>>> _SingleEntryPerSynapseUInt8

typedef std::map<ProjectionOnExecutionInstance, std::vector<ConnectionToHardwareRoutes>> ConnectionRoutingResult

Translation between synapses between logical neuron compartments and synapses between atomic neurons within compartments.

Contains a translation for each connection of each projection. The order of the translations matches the order of the connections in the projection.

Functions

ConnectionRoutingResult build_connection_routing(Network::ExecutionInstance const &network)

Build a connection routing for a given network.

This is the first step in two-stage routing towards a hardware data-flow graph representation.

Parameters

network – Network execution instance for which to build connection routing

std::vector<lola::vx::v3::SynapseMatrix::Weight> build_connection_weight_split(Projection::Connection::Weight const &weight, size_t num)

Split weight of connection into single hardware synapse circuit weight values.

This function splits like 123 -> 63 + 60 + 0.

Parameters

• weight – Weight to split

• num – Number of synapses to split weight onto

NetworkGraph build_network_graph(std::shared_ptr<Network> const &network, RoutingResult const &routing_result)

Build a hardware network representation for a given network.

Parameters

• network – Network for which to build hardware network representation

• routing_result – Routing result to use to build hardware network representation

std::vector<std::vector<std::tuple<common::Time, AtomicNeuronOnNetwork, signal_flow::Int8>>> extract_cadc_samples(signal_flow::OutputData const &data, NetworkGraph const &network_graph)

Extract CADC samples to be recorded for a network.

Parameters

• data – Data containing CADC samples

• network_graph – Network graph to use for matching of logical to hardware neurons

Returns

Time-series CADC sample data per batch entry. Samples are sorted by their ChipTime per batch-entry and contain their corresponding location alongside the ADC value.

std::vector<std::vector<std::tuple<common::Time, AtomicNeuronOnNetwork, haldls::vx::v3::MADCSampleFromChip::Value>>> extract_madc_samples(signal_flow::OutputData const &data, NetworkGraph const &network_graph)

Extract MADC samples to be recorded for a network.

Parameters

• data – Data containing MADC samples

• network_graph – Network graph to use for matching of logical to hardware neurons

Returns

Time-series MADC sample data per batch entry. Samples are sorted by their ChipTime per batch-entry and contain their corresponding location alongside the ADC value.

std::vector<std::map<std::tuple<PopulationOnNetwork, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>, std::vector<common::Time>>> extract_neuron_spikes(signal_flow::OutputData const &data, NetworkGraph const &network_graph)

Extract spikes corresponding to neurons in the network.

Spikes which don’t correspond to a neuron in the network are ignored.

Parameters

• data – Data containing spike labels

• network_graph – Network graph to use for matching of logical to hardware neurons

Returns

Time-series neuron spike data per batch entry

PlasticityRule::RecordingData extract_plasticity_rule_recording_data(signal_flow::OutputData const &data, NetworkGraph const &network_graph, PlasticityRuleOnNetwork descriptor)

Extract to be recorded observable data of a plasticity rule.

Parameters

• data – Data containing observables

• network_graph – Network graph to use for hardware to logical network translation

• descriptor – Descriptor to plasticity rule to extract observable data for

Returns

Observable data per batch entry

NetworkGraphStatistics extract_statistics(NetworkGraph const &network_graph)

Extract statistics from network graph.

Connectum generate_connectum_from_abstract_network(NetworkGraph const &network_graph)

Connectum generate_connectum_from_hardware_network(NetworkGraph const &network_graph)

size_t hash_value(Receptor const &receptor)

std::ostream &operator<<(std::ostream &os, Projection::Connection::Index const &index)

std::ostream &operator<<(std::ostream &os, Receptor::Type const &receptor_type)

bool requires_routing(std::shared_ptr<Network> const &current, NetworkGraph const &old_graph)

Get whether the current network requires routing compared to the old network.

Parameters

• current – Current network

• old_graph – Old routed network

Returns

Boolean value

signal_flow::OutputData run(execution::JITGraphExecutor &executor, NetworkGraph const &network_graph, execution::JITGraphExecutor::ChipConfigs const &config, signal_flow::InputData const &input, execution::JITGraphExecutor::Hooks &&hooks = {})

Execute the given network hardware graph and fetch results.

Parameters

• executor – Executor instance to be used for running the graph

• network_graph – Network hardware graph to run

• config – Static chip configuration to use

• input – Inputs to use

• hooks – Optional playback sequences to inject

Returns

Run time information

std::vector<signal_flow::OutputData> run(execution::JITGraphExecutor &executor, std::vector<std::reference_wrapper<NetworkGraph const>> const &network_graphs, std::vector<std::reference_wrapper<execution::JITGraphExecutor::ChipConfigs const>> const &configs, std::vector<std::reference_wrapper<signal_flow::InputData const>> const &inputs, execution::JITGraphExecutor::Hooks &&hooks = {})

Execute the given network hardware graphs and fetch results.

Parameters

• executor – Executor instance to be used for running the graph

• network_graphs – Network hardware graphs to run

• configs – Static chip configurations to use

• inputs – Inputs to use

• hooks – Optional playback sequences to inject

Returns

Run time information

void update_network_graph(NetworkGraph &network_graph, std::shared_ptr<Network> const &network)

Update an exisiting hardware graph representation.

For this to work, no new routing has to have been required.

Parameters

• network_graph – Existing hardware graph representation to update or fill with newly built instance

• network – New network for which to update or build

namespace routing

namespace grenade::vx::network::routing::greedy

Functions

std::ostream &operator<<(std::ostream &os, SynapseDriverOnPADIBusManager::AllocationPolicy const &value)

namespace detail

namespace vertex

namespace transformation

namespace grenade::vx::ppu

Functions

SynapseRowViewHandleRange make_synapse_row_view_handle_range(std::array<SynapseArrayViewHandle, 1> const &synapses)

Construct synapse row view handle range for one unsigned synapse array view handle.

To be used when abstract code is written and function overloading is used to select signed or unsigned view ranges.

Parameters

synapses – Synapses to use for construction of range

Returns

Constructed range

SynapseRowViewHandleSignedRange make_synapse_row_view_handle_range(std::array<SynapseArrayViewHandle, 2> const &synapses)

Construct synapse row view handle range for one unsigned synapse array view handle.

To be used when abstract code is written and function overloading is used to select signed or unsigned view ranges.

Parameters

synapses – Synapses to use for construction of range, the first is used as excitatory range, the second as inhibitory range

Returns

Constructed range

template<typename T, typename HandleI, typename HandleO>
libnux::vx::VectorRow<T> translate_columns(libnux::vx::VectorRow<T> const &input, HandleI const &input_handle, HandleO const &output_handle)

Translate vector row values from columns of input handle to columns of output handle.

Translates sequentially, if there are less active columns in input than in output broadcasts last value, if there are more active columns in input than in output drops the additional values.

Parameters

• input – Input values

• input_handle – Input handle for active column lookup

• output_handle – Output handle for active column lookup

namespace grenade::vx::ppu::detail

Enums

enum class Status : uint32_t

Values:

enumerator initial

enumerator idle

enumerator reset_neurons

enumerator baseline_read

enumerator read

enumerator periodic_read

enumerator inside_periodic_read

enumerator stop_periodic_read

enumerator stop

enumerator scheduler

enum class Stopped : uint32_t

Values:

enumerator no

enumerator yes

Variables

constexpr size_t cadc_recording_storage_base_bottom = 65536

constexpr size_t cadc_recording_storage_base_top = 0

constexpr size_t cadc_recording_storage_size = 65536

namespace grenade::vx::signal_flow

Typedefs

typedef halco::hicann_dls::vx::v3::SpikeLabel SpikeFromChip

From-chip spike.

typedef std::variant<haldls::vx::v3::SpikePack1ToChip, haldls::vx::v3::SpikePack2ToChip, haldls::vx::v3::SpikePack3ToChip> SpikeToChip

To-chip spike.

typedef common::TimedData<MADCSampleFromChip> TimedMADCSampleFromChip

Time-annotated from-chip MADC sample.

typedef std::vector<TimedMADCSampleFromChip> TimedMADCSampleFromChipSequence

Sequence of time-annotated from-chip MADC events.

typedef common::TimedData<SpikeFromChip> TimedSpikeFromChip

Time-annotated from-chip spike.

typedef std::vector<TimedSpikeFromChip> TimedSpikeFromChipSequence

Sequence of time-annotated from-chip spike events.

typedef common::TimedData<SpikeToChip> TimedSpikeToChip

Time-annotated to-chip spike.

typedef std::vector<TimedSpikeToChip> TimedSpikeToChipSequence

Sequence of timed to-chip spike events.

typedef haldls::vx::v3::PADIEvent::HagenActivation UInt5

5 bit wide unsigned activation value type.

typedef std::variant<vertex::PlasticityRule, vertex::BackgroundSpikeSource, vertex::CrossbarL2Input, vertex::CrossbarL2Output, vertex::CrossbarNode, vertex::PADIBus, vertex::SynapseDriver, vertex::SynapseArrayViewSparse, vertex::SynapseArrayView, vertex::ExternalInput, vertex::DataInput, vertex::DataOutput, vertex::Transformation, vertex::NeuronView, vertex::NeuronEventOutputView, vertex::MADCReadoutView, vertex::PadReadoutView, vertex::CADCMembraneReadoutView> Vertex

Vertex configuration as variant over possible types.

Enums

enum class ConnectionType

Type of data transfered by a connection.

Connections between vertices are only allowed if the input vertex output connection type is equal to the output vertex input connection type.

Values:

enumerator SynapseInputLabel

enumerator UInt32

enumerator UInt5

enumerator Int8

enumerator SynapticInput

enumerator MembraneVoltage

enumerator TimedSpikeToChipSequence

enumerator TimedSpikeFromChipSequence

enumerator TimedMADCSampleFromChipSequence

enumerator DataTimedSpikeToChipSequence

enumerator DataTimedSpikeFromChipSequence

enumerator DataTimedMADCSampleFromChipSequence

enumerator DataInt8

enumerator DataUInt5

enumerator DataUInt32

enumerator CrossbarInputLabel

enumerator CrossbarOutputLabel

enumerator SynapseDriverInputLabel

enumerator ExternalAnalogSignal

Functions

std::ostream &operator<<(std::ostream &os, ConnectionType const &type)

void pack_spikes(Data &data)

Pack single spikes to same time into double spikes in-place.

template<typename Vertex, typename InputVertex>
bool supports_input_from(Vertex const &vertex, InputVertex const &input, std::optional<PortRestriction> const &port_restriction)

Get whether given vertex supports input from given input vertex with optional port restriction.

Default assumption is that the connection is supported. Restrictions can be defined by a member function of signature: supports_input_from(OtherVertex const&, std::optional<PortRestriction> const&).

Template Parameters

• Vertex – Type of vertex

• InputVertex – Type of input vertex

Parameters

• vertex – Vertex to check

• input_vertex – Input vertex to check

• port_restriction – Optional port restriction to apply to check

Variables

constexpr auto can_connect_different_execution_instances = std::array{ConnectionType::DataUInt5, ConnectionType::DataInt8, ConnectionType::DataTimedSpikeToChipSequence, ConnectionType::DataTimedSpikeFromChipSequence, ConnectionType::DataUInt32, ConnectionType::DataTimedMADCSampleFromChipSequence}

Only memory operations are allowed to connect between different execution instances.

namespace grenade::vx::signal_flow::detail

Typedefs

typedef Graph::edge_descriptor edge_descriptor

typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::bidirectionalS, boost::no_property, boost::no_property> Graph

Bidirectional graph.

template<typename Vertex, typename InputVertex>
using has_supports_input_from = decltype(std::declval<Vertex>().supports_input_from(std::declval<InputVertex>(), std::declval<std::optional<PortRestriction>>()))

typedef Graph::vertex_descriptor vertex_descriptor

namespace grenade::vx::signal_flow::vertex

Functions

std::ostream &operator<<(std::ostream &os, PlasticityRule::TimedRecording::ObservablePerNeuron::Layout const &layout)

std::ostream &operator<<(std::ostream &os, PlasticityRule::TimedRecording::ObservablePerSynapse::LayoutPerRow const &layout)

namespace plasticity_rule

namespace transformation

namespace halco

namespace common

namespace detail

namespace hate

namespace log4cxx

Typedefs

typedef std::shared_ptr<Logger> LoggerPtr

namespace lola

namespace vx

namespace v3

namespace stadls

namespace vx

namespace stadls::vx::v3

Typedefs

using PlaybackProgram = stadls::vx::PlaybackProgram

namespace std

STL namespace.

file cerealization.h

#include “”

Defines

EXPLICIT_INSTANTIATE_CEREAL_LOAD_SAVE(CLASS_NAME)

file null_output_iterator.h

#include <>

file entity_on_chip.h

#include “grenade/vx/genpybind.h”

#include “”

#include “”

#include <>

file entity_on_chip.h

#include “grenade/vx/common/entity_on_chip.h”

#include “”

#include “”

#include <>

#include “”

file execution_instance_id.h

#include “grenade/vx/genpybind.h”

#include “”

#include “”

#include <>

file time.h

#include “grenade/vx/genpybind.h”

#include “”

#include “”

#include “”

#include “”

file timed_data.h

#include “grenade/vx/common/time.h”

#include “grenade/vx/genpybind.h”

#include <>

#include “”

file addition.h

#include <>

#include “grenade/vx/signal_flow/graph.h”

#include “grenade/vx/signal_flow/types.h”

file addition.h

#include “grenade/vx/signal_flow/vertex/transformation.h”

#include <>

file argmax.h

#include <>

#include “grenade/vx/signal_flow/graph.h”

#include “grenade/vx/signal_flow/types.h”

file argmax.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/vertex/transformation.h”

#include <>

file conv1d.h

#include <>

#include <>

#include “grenade/vx/common/time.h”

#include “grenade/vx/compute/mac.h”

#include “grenade/vx/signal_flow/types.h”

#include “”

file converting_relu.h

#include <>

#include “grenade/vx/signal_flow/graph.h”

#include “grenade/vx/signal_flow/types.h”

file converting_relu.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/vertex/transformation.h”

#include <>

file range_split.h

#include “”

#include <>

#include <>

file single_chip_execution_instance_manager.h

#include “grenade/vx/common/execution_instance_id.h”

#include “”

#include “”

file mac.h

#include <>

#include <>

#include “grenade/vx/common/time.h”

#include “grenade/vx/execution/jit_graph_executor.h”

#include “grenade/vx/signal_flow/graph.h”

#include “grenade/vx/signal_flow/types.h”

#include “grenade/vx/signal_flow/vertex/synapse_array_view.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include “”

file relu.h

#include <>

#include “grenade/vx/signal_flow/graph.h”

#include “grenade/vx/signal_flow/types.h”

file relu.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/vertex/transformation.h”

#include <>

file sequence.h

#include “grenade/cerealization.h”

#include “grenade/vx/compute/addition.h”

#include “grenade/vx/compute/argmax.h”

#include “grenade/vx/compute/conv1d.h”

#include “grenade/vx/compute/converting_relu.h”

#include “grenade/vx/compute/mac.h”

#include “grenade/vx/compute/relu.h”

#include “”

#include <>

#include <>

file connection.h

#include “grenade/vx/genpybind.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

file run.h

#include “”

#include “”

file run.h

#include “grenade/vx/execution/jit_graph_executor.h”

#include “grenade/vx/signal_flow/output_data.h”

#include “”

#include <>

file run.h

#include “grenade/vx/execution/jit_graph_executor.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/network_graph.h”

#include “grenade/vx/signal_flow/input_data.h”

#include “grenade/vx/signal_flow/output_data.h”

#include “”

#include “”

#include <>

file connection_state_storage.h

#include “”

#include “”

#include “”

#include <>

#include <>

file execution_instance_builder.h

#include <>

#include <>

#include <>

#include <>

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/execution/detail/generator/neuron_reset_mask.h”

#include “grenade/vx/signal_flow/data.h”

#include “grenade/vx/signal_flow/execution_instance_hooks.h”

#include “grenade/vx/signal_flow/graph.h”

#include “grenade/vx/signal_flow/input_data.h”

#include “grenade/vx/signal_flow/output_data.h”

#include “grenade/vx/signal_flow/types.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

file execution_instance_config_visitor.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/ppu/neuron_view_handle.h”

#include “grenade/vx/ppu/synapse_array_view_handle.h”

#include “grenade/vx/signal_flow/graph.h”

#include “grenade/vx/signal_flow/vertex/plasticity_rule.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

file execution_instance_node.h

#include <>

#include <>

#include <>

#include “grenade/vx/execution/detail/connection_state_storage.h”

#include “grenade/vx/execution/detail/execution_instance_builder.h”

#include “grenade/vx/signal_flow/execution_instance_hooks.h”

#include “grenade/vx/signal_flow/graph.h”

#include “grenade/vx/signal_flow/input_data.h”

#include “grenade/vx/signal_flow/output_data.h”

#include “”

#include “”

file madc.h

#include “”

#include “”

#include “”

#include “”

file neuron_reset_mask.h

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

file ppu.h

#include “grenade/vx/ppu/detail/status.h”

#include “”

#include “”

#include “”

#include “”

#include “”

file ppu.h

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

file timed_spike_to_chip_sequence.h

#include “grenade/vx/signal_flow/event.h”

#include “”

#include “”

#include “”

#include “”

file ppu_program_generator.h

#include “grenade/vx/ppu/neuron_view_handle.h”

#include “grenade/vx/ppu/synapse_array_view_handle.h”

#include “grenade/vx/signal_flow/graph.h”

#include “grenade/vx/signal_flow/vertex/plasticity_rule.h”

#include “”

#include “”

#include “”

#include <>

#include <>

file jit_graph_executor.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/execution/backend/connection.h”

#include “grenade/vx/execution/detail/connection_state_storage.h”

#include “grenade/vx/signal_flow/execution_instance_hooks.h”

#include “”

#include “”

#include “”

#include <>

file python_bindings.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/common/entity_on_chip.h”

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/common/time.h”

file python_bindings.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/execution/jit_graph_executor.h”

file python_bindings.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/background_source_population.h”

#include “grenade/vx/network/connection_routing_result.h”

#include “grenade/vx/network/external_source_population.h”

#include “grenade/vx/network/extract_output.h”

#include “grenade/vx/network/generate_input.h”

#include “grenade/vx/network/network.h”

#include “grenade/vx/network/network_builder.h”

#include “grenade/vx/network/network_graph.h”

#include “grenade/vx/network/network_graph_builder.h”

#include “grenade/vx/network/network_graph_statistics.h”

#include “grenade/vx/network/pad_recording.h”

#include “grenade/vx/network/plasticity_rule.h”

#include “grenade/vx/network/plasticity_rule_generator.h”

#include “grenade/vx/network/plasticity_rule_on_network.h”

#include “grenade/vx/network/population.h”

#include “grenade/vx/network/population_on_network.h”

#include “grenade/vx/network/projection.h”

#include “grenade/vx/network/projection_on_network.h”

#include “grenade/vx/network/requires_routing.h”

#include “grenade/vx/network/routing/portfolio_router.h”

#include “grenade/vx/network/run.h”

file python_bindings.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/routing/greedy_router.h”

#include “grenade/vx/network/routing/portfolio_router.h”

#include “grenade/vx/network/routing/router.h”

file python_bindings.h

#include “grenade/vx/genpybind.h”

file python_bindings.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/signal_flow/data.h”

#include “grenade/vx/signal_flow/event.h”

#include “grenade/vx/signal_flow/execution_instance_hooks.h”

#include “grenade/vx/signal_flow/execution_time_info.h”

#include “grenade/vx/signal_flow/graph.h”

#include “grenade/vx/signal_flow/input_data.h”

#include “grenade/vx/signal_flow/output_data.h”

#include “grenade/vx/signal_flow/pack_spikes.h”

#include “grenade/vx/signal_flow/types.h”

file genpybind.h

#include <genpybind.h>

Defines

GENPYBIND_MODULE

GENPYBIND_TAG_GRENADE_VX

GENPYBIND_TAG_GRENADE_VX_COMMON

GENPYBIND_TAG_GRENADE_VX_EXECUTION

GENPYBIND_TAG_GRENADE_VX_NETWORK

GENPYBIND_TAG_GRENADE_VX_NETWORK_ROUTING

GENPYBIND_TAG_GRENADE_VX_SIGNAL_FLOW

file atomic_neuron_on_execution_instance.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/population_on_execution_instance.h”

#include “”

#include “”

#include <>

#include <>

file atomic_neuron_on_network.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/population_on_network.h”

#include “”

#include “”

#include <>

#include <>

file background_source_population.h

#include “grenade/vx/common/entity_on_chip.h”

#include “grenade/vx/genpybind.h”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

file build_connection_routing.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/connection_routing_result.h”

#include “grenade/vx/network/network.h”

#include “”

#include <>

file build_connection_weight_split.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/projection.h”

#include “”

#include <>

file cadc_recording.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/neuron_recording.h”

#include “”

file connection_routing_result.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/projection_on_network.h”

#include “”

#include <>

#include <>

#include <>

#include <>

file connectum.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/network/population_on_execution_instance.h”

#include “grenade/vx/network/projection.h”

#include “grenade/vx/network/projection_on_network.h”

#include “grenade/vx/signal_flow/graph.h”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

file exception.h

#include “”

#include <>

#include <>

file external_source_population.h

#include “grenade/vx/common/entity_on_chip.h”

#include “grenade/vx/genpybind.h”

#include “”

#include <>

#include <>

file extract_output.h

#include “grenade/vx/common/time.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/atomic_neuron_on_network.h”

#include “grenade/vx/network/network_graph.h”

#include “grenade/vx/network/plasticity_rule_on_network.h”

#include “grenade/vx/network/population_on_network.h”

#include “grenade/vx/network/projection_on_network.h”

#include “grenade/vx/signal_flow/output_data.h”

#include “”

#include <>

#include <>

#include <>

file generate_input.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/network_graph.h”

#include “grenade/vx/signal_flow/event.h”

#include “grenade/vx/signal_flow/input_data.h”

file inter_execution_instance_projection.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/population_on_network.h”

#include “”

#include “”

#include “”

#include <>

file inter_execution_instance_projection_on_network.h

#include “grenade/vx/genpybind.h”

#include “”

file madc_recording.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/neuron_recording.h”

#include “”

file network.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/background_source_population.h”

#include “grenade/vx/network/cadc_recording.h”

#include “grenade/vx/network/external_source_population.h”

#include “grenade/vx/network/inter_execution_instance_projection.h”

#include “grenade/vx/network/inter_execution_instance_projection_on_network.h”

#include “grenade/vx/network/madc_recording.h”

#include “grenade/vx/network/pad_recording.h”

#include “grenade/vx/network/plasticity_rule.h”

#include “grenade/vx/network/plasticity_rule_on_execution_instance.h”

#include “grenade/vx/network/population.h”

#include “grenade/vx/network/population_on_execution_instance.h”

#include “grenade/vx/network/projection.h”

#include “grenade/vx/network/projection_on_execution_instance.h”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

file network_builder.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/cadc_recording.h”

#include “grenade/vx/network/inter_execution_instance_projection.h”

#include “grenade/vx/network/inter_execution_instance_projection_on_network.h”

#include “grenade/vx/network/madc_recording.h”

#include “grenade/vx/network/network.h”

#include “grenade/vx/network/pad_recording.h”

#include “grenade/vx/network/plasticity_rule.h”

#include “grenade/vx/network/plasticity_rule_on_network.h”

#include “grenade/vx/network/population.h”

#include “grenade/vx/network/population_on_network.h”

#include “grenade/vx/network/projection.h”

#include “grenade/vx/network/projection_on_network.h”

#include “”

#include <>

#include <>

file network_graph.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/network.h”

#include “grenade/vx/network/network_graph_statistics.h”

#include “grenade/vx/network/population_on_network.h”

#include “grenade/vx/network/projection_on_network.h”

#include “grenade/vx/signal_flow/graph.h”

#include “”

#include <>

#include <>

file network_graph_builder.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/cadc_recording.h”

#include “grenade/vx/network/madc_recording.h”

#include “grenade/vx/network/network.h”

#include “grenade/vx/network/network_graph.h”

#include “grenade/vx/network/plasticity_rule.h”

#include “grenade/vx/network/population_on_network.h”

#include “grenade/vx/network/projection.h”

#include “grenade/vx/network/routing_result.h”

#include “grenade/vx/signal_flow/graph.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

file network_graph_statistics.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/genpybind.h”

#include “”

#include <>

#include <>

#include <>

#include <>

file neuron_recording.h

#include “grenade/vx/common/entity_on_chip.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/atomic_neuron_on_execution_instance.h”

#include “”

#include “”

file pad_recording.h

#include “grenade/vx/common/entity_on_chip.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/neuron_recording.h”

#include “”

#include “”

#include <>

file plasticity_rule.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/population_on_execution_instance.h”

#include “grenade/vx/network/projection_on_execution_instance.h”

#include “grenade/vx/signal_flow/vertex/plasticity_rule.h”

#include “”

#include <>

#include <>

#include <>

#include <>

file plasticity_rule.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/event.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/entity_on_chip.h”

#include “grenade/vx/signal_flow/vertex/neuron_view.h”

#include “grenade/vx/signal_flow/vertex/plasticity_rule/observable_data_type.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

file plasticity_rule_generator.h

#include “grenade/vx/network/plasticity_rule.h”

#include “”

#include <>

file plasticity_rule_on_execution_instance.h

#include “grenade/vx/genpybind.h”

#include “”

file plasticity_rule_on_network.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/plasticity_rule_on_execution_instance.h”

file population.h

#include “grenade/vx/common/entity_on_chip.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/receptor.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

file population_on_execution_instance.h

#include “grenade/vx/genpybind.h”

#include “”

file population_on_network.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/population_on_execution_instance.h”

file projection.h

#include “grenade/vx/common/entity_on_chip.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/population_on_execution_instance.h”

#include “grenade/vx/network/receptor.h”

#include “”

#include “”

#include “”

#include <>

file projection_on_execution_instance.h

#include “grenade/vx/genpybind.h”

#include “”

file projection_on_network.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/projection_on_execution_instance.h”

file README.md

file receptor.h

#include “grenade/vx/genpybind.h”

#include “”

#include “”

#include <>

file requires_routing.h

#include “grenade/vx/genpybind.h”

#include “”

#include <>

file synapse_driver_on_dls_manager.h

#include “grenade/vx/network/routing/greedy/synapse_driver_on_dls_manager.h”

#include “grenade/vx/network/routing/greedy/synapse_driver_on_padi_bus_manager.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

file synapse_driver_on_dls_manager.h

#include “grenade/vx/network/routing/greedy/synapse_driver_on_padi_bus_manager.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

file synapse_driver_on_padi_bus_manager.h

#include “grenade/vx/network/routing/greedy/synapse_driver_on_padi_bus_manager.h”

#include “”

#include <>

#include <>

#include <>

file synapse_driver_on_padi_bus_manager.h

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

file routing_builder.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/connection_routing_result.h”

#include “grenade/vx/network/network.h”

#include “grenade/vx/network/population_on_execution_instance.h”

#include “grenade/vx/network/projection.h”

#include “grenade/vx/network/routing/greedy/routing_constraints.h”

#include “grenade/vx/network/routing/greedy/source_on_padi_bus_manager.h”

#include “grenade/vx/network/routing/greedy/synapse_driver_on_dls_manager.h”

#include “grenade/vx/network/routing/greedy_router.h”

#include “grenade/vx/network/routing_result.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

file routing_constraints.h

#include “grenade/vx/network/connection_routing_result.h”

#include “grenade/vx/network/network.h”

#include “grenade/vx/network/population_on_execution_instance.h”

#include “grenade/vx/network/projection.h”

#include “grenade/vx/network/receptor.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

file source_on_padi_bus_manager.h

#include “grenade/vx/network/routing/greedy/source_on_padi_bus_manager.h”

#include “grenade/vx/network/routing/greedy/synapse_driver_on_dls_manager.h”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

file source_on_padi_bus_manager.h

#include “grenade/vx/network/receptor.h”

#include “grenade/vx/network/routing/greedy/synapse_driver_on_dls_manager.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

file greedy_router.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/routing/greedy/synapse_driver_on_dls_manager.h”

#include “grenade/vx/network/routing/router.h”

#include “grenade/vx/network/routing_result.h”

#include “”

#include <>

#include <>

#include <>

#include <>

file portfolio_router.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/routing/router.h”

#include “grenade/vx/network/routing_result.h”

#include “”

#include <>

file router.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/routing_result.h”

#include “”

#include <>

file routing_result.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/network/connection_routing_result.h”

#include “grenade/vx/network/population_on_execution_instance.h”

#include “grenade/vx/network/projection_on_execution_instance.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

file external_source_merger.h

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/transformation.h”

#include “”

#include “”

#include <>

file extmem.h

#include <>

file status.h

#include <>

file stopped.h

#include <>

file neuron_view_handle.h

#include “”

#include “”

file synapse_array_view_handle.h

#include “”

#include “”

file synapse_row_view_handle.h

#include “grenade/vx/ppu/synapse_array_view_handle.h”

#include “”

file synapse_row_view_handle_range.h

#include “grenade/vx/ppu/synapse_row_view_handle.h”

#include <>

#include “”

file translate_columns.h

#include “”

file connection_type.h

#include “”

#include <>

#include <>

file data.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/common/time.h”

#include “grenade/vx/common/timed_data.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/signal_flow/detail/graph.h”

#include “grenade/vx/signal_flow/event.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/types.h”

#include “”

#include <>

#include <>

#include <>

#include <>

file graph.h

#include <>

file graph.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/signal_flow/detail/graph.h”

#include “grenade/vx/signal_flow/port_restriction.h”

#include “grenade/vx/signal_flow/vertex.h”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

#include “”

file vertex_concept.h

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

file event.h

#include “grenade/vx/common/timed_data.h”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

file execution_instance_hooks.h

#include “grenade/vx/genpybind.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

file execution_time_info.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/genpybind.h”

#include “”

#include “”

#include <>

#include <>

#include <>

file input.h

#include “grenade/vx/signal_flow/graph.h”

#include “grenade/vx/signal_flow/port_restriction.h”

#include “”

#include <>

#include <>

file input_data.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/common/time.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/signal_flow/data.h”

#include “grenade/vx/signal_flow/port.h”

#include “”

#include <>

#include <>

file output_data.h

#include “grenade/vx/common/execution_instance_id.h”

#include “grenade/vx/genpybind.h”

#include “grenade/vx/signal_flow/data.h”

#include “grenade/vx/signal_flow/detail/graph.h”

#include “grenade/vx/signal_flow/event.h”

#include “grenade/vx/signal_flow/execution_time_info.h”

#include “grenade/vx/signal_flow/types.h”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

file pack_spikes.h

#include “grenade/vx/genpybind.h”

#include “grenade/vx/signal_flow/data.h”

#include “”

file port.h

#include <>

#include <>

#include “grenade/vx/signal_flow/connection_type.h”

#include “”

file port_restriction.h

#include “”

#include <>

#include <>

#include <>

#include <>

file supports_input_from.h

#include “”

#include <>

file types.h

#include “grenade/vx/genpybind.h”

#include “”

#include “”

file vertex.h

#include “grenade/vx/signal_flow/detail/vertex_concept.h”

#include “grenade/vx/signal_flow/vertex/background_spike_source.h”

#include “grenade/vx/signal_flow/vertex/cadc_membrane_readout_view.h”

#include “grenade/vx/signal_flow/vertex/crossbar_l2_input.h”

#include “grenade/vx/signal_flow/vertex/crossbar_l2_output.h”

#include “grenade/vx/signal_flow/vertex/crossbar_node.h”

#include “grenade/vx/signal_flow/vertex/data_input.h”

#include “grenade/vx/signal_flow/vertex/data_output.h”

#include “grenade/vx/signal_flow/vertex/external_input.h”

#include “grenade/vx/signal_flow/vertex/madc_readout.h”

#include “grenade/vx/signal_flow/vertex/neuron_event_output_view.h”

#include “grenade/vx/signal_flow/vertex/neuron_view.h”

#include “grenade/vx/signal_flow/vertex/pad_readout.h”

#include “grenade/vx/signal_flow/vertex/padi_bus.h”

#include “grenade/vx/signal_flow/vertex/plasticity_rule.h”

#include “grenade/vx/signal_flow/vertex/synapse_array_view.h”

#include “grenade/vx/signal_flow/vertex/synapse_array_view_sparse.h”

#include “grenade/vx/signal_flow/vertex/synapse_driver.h”

#include “grenade/vx/signal_flow/vertex/transformation.h”

#include <>

file background_spike_source.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/entity_on_chip.h”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

file cadc_membrane_readout_view.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/entity_on_chip.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

#include “”

file crossbar_l2_input.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/entity_on_chip.h”

#include “”

#include <>

#include <>

#include <>

#include <>

file crossbar_l2_output.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/entity_on_chip.h”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

file crossbar_node.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/port_restriction.h”

#include “grenade/vx/signal_flow/vertex/entity_on_chip.h”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

file data_input.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “”

#include <>

#include <>

#include <>

#include <>

file data_output.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

file external_input.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

file madc_readout.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/entity_on_chip.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

file neuron_event_output_view.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/entity_on_chip.h”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

file neuron_view.h

#include “grenade/vx/ppu/neuron_view_handle.h”

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/entity_on_chip.h”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

#include “”

file pad_readout.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/entity_on_chip.h”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

file padi_bus.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/entity_on_chip.h”

#include “”

#include “”

#include <>

#include <>

#include <>

file observable_data_type.h

#include “grenade/vx/genpybind.h”

#include “”

#include <>

#include <>

file synapse_array_view.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/entity_on_chip.h”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

#include “”

file synapse_array_view_sparse.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/entity_on_chip.h”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

#include “”

file synapse_driver.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/entity_on_chip.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

file transformation.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/data.h”

#include “grenade/vx/signal_flow/port.h”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

file concatenation.h

#include “grenade/vx/signal_flow/connection_type.h”

#include “grenade/vx/signal_flow/vertex/transformation.h”

#include <>

file mac_spiketrain_generator.h

#include “grenade/vx/common/time.h”

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/transformation.h”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

file spike_packing.h

#include “grenade/vx/signal_flow/port.h”

#include “grenade/vx/signal_flow/vertex/transformation.h”

file subtraction.h

#include “grenade/vx/signal_flow/vertex/transformation.h”

#include <>

page md__jenkins_jenlib_workspaces_f9_doc_gerrit_documentation_brainscales2_dependencies_ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA_x_grenade_include_grenade_vx_network_README

The logical_network namespace contains facilities to describe a Network of placed Populations of logical neurons, unplaced and unrouted Projections of connections corresponding to possibly multiple hardware synapse circuits in-between compartments of neurons in these populations, MADCRecording on a single atomic neuron, CADCRecording on a collection of atomic neurons as well as PlasticityRules on projections. In addition, ExternalSourcePopulations allow feeding-in external spike trains and BackgroundSourcePopulations describe the on-chip background generators.

The only difference to the network namespace therefore is the description of logical neurons and projections in-between their neurons’ compartments with possibly multiple hardware synapses per connection.

Given such a Network, an automated routing algorithm called via NetworkGraph build_network_graph(Network) solves the correspondence between logical neurons and atomic neurons as well as abstract synapses and network::Network hardware synapses. It therrefore selects which atomic neurons of the compartments to connect and the distribution of hardware synapses.

The NetworkGraph then contains the original Network as well as the routed network::Network. This can then be used further as described in the network namespace.

Spike-trains to the ExternalSourcePopulations in the network are supplied to an InputGenerator builder-pattern, which transforms the supplied spike-trains to the raw signal_flow::InputData format required by run().

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/execution/backend

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/common

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/compute

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/common/detail

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/compute/detail

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/execution/detail

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/network/routing/greedy/detail

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/ppu/detail

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/signal_flow/detail

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/execution

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/execution/detail/generator

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/network/routing/greedy

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/network

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/signal_flow/vertex/plasticity_rule

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/ppu

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/network/routing

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/signal_flow

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/network/vertex/transformation

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/signal_flow/vertex/transformation

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/network/vertex

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx/signal_flow/vertex

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/grenade/include/grenade/vx