API Reference: grenade

struct GENPYBIND_TAG_GRENADE_VX_NETWORK::MechanismOnCompartment : public halco::common::detail::BaseType<MechanismOnCompartment, size_t>
#include <multicompartment_mechanism_on_compartment.h>

Public Functions

inline MechanismOnCompartment(value_type const value = 0)
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> link_options_before_source = {"-T" + get_linker_file("elf32nux.x"), "-Wl,--gc-sections"}
std::vector<std::string> options_after_source = {"-Bstatic", get_library_paths(), "-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", "-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", "-nostartfiles", "-Wl,--defsym=mailbox_size=4096",}

Public Static Attributes

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

Protected Functions

Objectfile compile_objectfile(std::vector<std::string> sources)

Compile sources into target objectfile.

Program link_from_objectfiles(std::vector<Objectfile> objectfiles)

Private Functions

Objectfile compile_objectfile_cached(std::vector<std::string> source)

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

Private Static Functions

static ObjectfileCache &get_objectfile_cache()
static ProgramCache &get_program_cache()
struct grenade::vx::CachingCompiler::ObjectfileCache
#include <ppu.h>

Cache for compiled PPU objectfiles.

The objectfile information is indexed by hashed compilation options and the source code. It assumes, that the included headers are not modified concurrently.

Public Members

std::map<std::string, Objectfile> data
std::mutex data_mutex
struct grenade::vx::CachingCompiler::ObjectfileCache::Source
#include <ppu.h>

Sources used for compilation of objectfile 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 codes.

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> link_options_before_source

Compiler options before the source location specification.

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> link_options_before_source = {"-T" + get_linker_file("elf32nux.x"), "-Wl,--gc-sections"}
std::vector<std::string> options_after_source = {"-Bstatic", get_library_paths(), "-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", "-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", "-nostartfiles", "-Wl,--defsym=mailbox_size=4096",}

Public Static Attributes

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

Protected Functions

Objectfile compile_objectfile(std::vector<std::string> sources)

Compile sources into target objectfile.

Program link_from_objectfiles(std::vector<Objectfile> objectfiles)
struct grenade::vx::Compiler::Objectfile
#include <ppu.h>

PPU objectfile result of compilation.

Public Members

std::string content

Content of objectfile.

std::optional<std::string> objdump

Optional objdump -d output of objectfile.

Generation is performed for loglevel trace.

std::optional<std::string> readelf

Optional readelf -a output of objectfile.

Generation is performed for loglevel debug.

std::optional<std::string> stack_sizes

Optional stack size output of functions of objectfile.

Generation is performed for loglevel debug.

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::ConnectionConfig
#include <connection_config.h>

Connection config tracking changes to the configuration of hardware accessible via one connection.

Containers are eagerly encoded to only encode them once for both base and differential config parts.

Public Types

typedef std::vector<halco::hicann_dls::vx::OmnibusAddress> Addresses
typedef std::vector<fisch::vx::word_access_type::Omnibus> Words

Public Functions

ConnectionConfig() = default
haldls::vx::Encodable::BackendCocoListVariant get_base()
haldls::vx::Encodable::BackendCocoListVariant get_differential()
bool get_differential_changes_capmem() const

Get whether applying current state differential changes CapMem.

bool get_enable_differential_config() const
bool get_has_differential() const
bool get_is_fresh() const

Get whether connection config is fresh, i.e.

never applied.

bool operator!=(ConnectionConfig const &other) const = default
bool operator==(ConnectionConfig const &other) const = default
void set_chip(lola::vx::v3::Chip const &value, bool split_base_differential)

Set chip which is to be applied next.

void set_enable_differential_config(bool value)
void set_external_ppu_dram_memory(std::optional<lola::vx::v3::ExternalPPUDRAMMemoryBlock> const &value)

Set external PPU DRAM memory which is to be applied next.

Private Members

Addresses m_chip_base_addresses
Words m_chip_base_words
Addresses m_chip_differential_addresses
Words m_chip_differential_words
Words m_chip_words
bool m_enable_differential_config
std::optional<lola::vx::v3::ExternalPPUDRAMMemoryBlock> m_external_ppu_dram_memory
Addresses m_external_ppu_dram_memory_addresses
Addresses m_external_ppu_dram_memory_base_addresses
Words m_external_ppu_dram_memory_base_words
Addresses m_external_ppu_dram_memory_differential_addresses
Words m_external_ppu_dram_memory_differential_words
Words m_external_ppu_dram_memory_words
lola::vx::v3::Chip m_last_chip
Words m_last_chip_words
std::optional<lola::vx::v3::ExternalPPUDRAMMemoryBlock> m_last_external_ppu_dram_memory
std::map<Addresses::value_type, Words::value_type> m_last_external_ppu_dram_memory_words
struct grenade::vx::execution::detail::ConnectionConfigBase : public haldls::vx::Container
#include <connection_config.h>

Public Functions

ConnectionConfigBase(ConnectionConfig &config)
virtual std::unique_ptr<Container> clone_container() const
virtual std::unique_ptr<Encodable> clone_encodable() const
virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)
virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<haldls::vx::Backend> const &backend) const
virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<haldls::vx::Backend> const &backend) const
virtual bool get_is_valid_backend(haldls::vx::Backend backend) const
virtual bool get_supports_differential_write() const
virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const
virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const
virtual bool operator!=(Encodable const &other) const
virtual bool operator==(Encodable const &other) const
virtual std::ostream &print(std::ostream &os) const

Private Members

ConnectionConfig &m_config
struct ConnectionConfigBaseCoordinate : public halco::common::detail::RantWrapper<ConnectionConfigBaseCoordinate, size_t, 0, 0>, public halco::common::CoordinateBase<ConnectionConfigBaseCoordinate>
#include <connection_config.h>
struct grenade::vx::execution::detail::ConnectionConfigDifferential : public haldls::vx::Container
#include <connection_config.h>

Public Functions

ConnectionConfigDifferential(ConnectionConfig &config)
virtual std::unique_ptr<Container> clone_container() const
virtual std::unique_ptr<Encodable> clone_encodable() const
virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)
virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<haldls::vx::Backend> const &backend) const
virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<haldls::vx::Backend> const &backend) const
virtual bool get_is_valid_backend(haldls::vx::Backend backend) const
virtual bool get_supports_differential_write() const
virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const
virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const
virtual bool operator!=(Encodable const &other) const
virtual bool operator==(Encodable const &other) const
virtual std::ostream &print(std::ostream &os) const

Private Members

ConnectionConfig &m_config
struct ConnectionConfigDifferentialCoordinate : public halco::common::detail::RantWrapper<ConnectionConfigDifferentialCoordinate, size_t, 0, 0>, public halco::common::CoordinateBase<ConnectionConfigDifferentialCoordinate>
#include <connection_config.h>
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

ConnectionConfig config
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, size_t realtime_column_index)

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

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, std::vector<halco::common::typed_array<std::optional<stadls::vx::v3::ContainerTicket>, halco::hicann_dls::vx::PPUOnDLS>> const &cadc_readout_tickets, std::optional<ExecutionInstanceNode::PeriodicCADCReadoutTimes> const &periodic_cadc_readout_times)

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::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
ExecutionInstanceNode::PeriodicCADCReadoutTimes m_periodic_cadc_readout_times
std::vector<signal_flow::Graph::vertex_descriptor> m_post_vertices
bool m_postprocessing
std::optional<lola::vx::v3::PPUElfFile::symbols_type> m_ppu_symbols
size_t m_realtime_column_index
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 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
std::vector<generator::PPUCommand::Result> ppu_command_results
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

std::vector<RealtimeSnippet> realtimes
struct grenade::vx::execution::detail::ExecutionInstanceBuilder::Usages
#include <execution_instance_builder.h>

Public Members

halco::common::typed_array<std::set<signal_flow::vertex::CADCMembraneReadoutView::Mode>, halco::hicann_dls::vx::v3::HemisphereOnDLS> cadc_recording
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, size_t realtime_column_index)

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<PpuUsage, halco::common::typed_array<bool, halco::hicann_dls::vx::v3::NeuronResetOnDLS>> operator()()

Perform visit operation and generate initial configuration.

Returns

PpuUsage

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_cadc_readout
bool m_has_periodic_cadc_readout
bool m_has_periodic_cadc_readout_on_dram
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>>, size_t>> m_plasticity_rules
size_t m_realtime_column_index
bool m_used_madc
struct grenade::vx::execution::detail::ExecutionInstanceConfigVisitor::PpuUsage
#include <execution_instance_config_visitor.h>

Public Functions

PpuUsage() = default
PpuUsage(PpuUsage &&other)
PpuUsage(PpuUsage const &other) = default
PpuUsage &operator+=(PpuUsage &&other)

Order has_periodic_cadc_readout and concatenate plasticity_rules.

PpuUsage &operator=(PpuUsage &&other)
PpuUsage &operator=(PpuUsage &other) = default

Public Members

bool has_cadc_readout = false
bool has_periodic_cadc_readout = false
bool has_periodic_cadc_readout_on_dram = false
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>>, size_t>> plasticity_rules
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::PeriodicCADCReadoutTimes
#include <execution_instance_node.h>

Public Members

std::vector<haldls::vx::v3::Timer::Value> interval_begin
std::vector<haldls::vx::v3::Timer::Value> interval_end
std::vector<haldls::vx::v3::Timer::Value> time_zero
struct grenade::vx::execution::detail::generator::CapMemSettlingWait
#include <capmem.h>

Generator for a playback program snippet for waiting for CapMem to settle.

Public Types

typedef stadls::vx::v3::PlaybackProgramBuilder Builder
typedef hate::Nil Result

Protected Functions

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

Friends

friend auto generate(CapMemSettlingWait const&)
struct grenade::vx::execution::detail::generator::GetState
#include <get_state.h>

Generator for a playback program snippet for getting current hardware state.

Public Types

typedef stadls::vx::v3::PlaybackProgramBuilder Builder

Public Members

bool has_plasticity = {false}

Protected Functions

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

Friends

friend auto generate(GetState const&)
struct grenade::vx::execution::detail::generator::GetState::Result
#include <get_state.h>

Public Functions

void apply(lola::vx::v3::Chip &chip) const

Public Members

halco::common::typed_array<std::optional<stadls::vx::v3::ContainerTicket>, halco::hicann_dls::vx::v3::PPUMemoryOnDLS> ticket_ppu_memory
halco::common::typed_array<std::optional<stadls::vx::v3::ContainerTicket>, halco::hicann_dls::vx::v3::SynapseWeightMatrixOnDLS> ticket_synaptic_weights
struct grenade::vx::execution::detail::generator::HealthInfo
#include <health_info.h>

Generator for a playback program snippet for reading out health information.

Public Types

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

Protected Functions

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

Friends

friend auto generate(HealthInfo const&)
struct grenade::vx::execution::detail::generator::HealthInfo::Result
#include <health_info.h>

Public Functions

signal_flow::ExecutionHealthInfo::ExecutionInstance get_execution_health_info() const

Public Members

haldls::vx::v3::Timer::Value execution_duration

Private Members

halco::common::typed_array<stadls::vx::v3::AbsoluteTimePlaybackProgramContainerTicket, halco::hicann_dls::vx::v3::CrossbarInputOnDLS> m_crossbar_input_drop_counter
halco::common::typed_array<stadls::vx::v3::AbsoluteTimePlaybackProgramContainerTicket, halco::hicann_dls::vx::v3::CrossbarOutputOnDLS> m_crossbar_output_event_counter
stadls::vx::v3::AbsoluteTimePlaybackProgramContainerTicket m_hicann_arq_status
halco::common::typed_array<stadls::vx::v3::AbsoluteTimePlaybackProgramContainerTicket, halco::hicann_dls::vx::v3::PhyStatusOnFPGA> m_phy_status

Friends

friend struct HealthInfo
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::PlaybackProgramBuilder Builder
typedef hate::Nil 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

Public Functions

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

Construct blocking PPU command.

Parameters

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

  • status – Command to place

  • expected_previous_status – Expectation of status before issuing the new command.

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_expected_previous_status
grenade::vx::ppu::detail::Status m_status

Friends

friend auto generate(PPUCommand const&)
struct grenade::vx::execution::detail::generator::PPUCommand::Result
#include <ppu.h>

Result containing tickets to check for expected status before sending the new status command.

Public Functions

void evaluate() const

Evaluate whether read-out status matches expectation.

Issues a warning if they don’t match.

Public Members

haldls::vx::v3::Timer::Value duration
grenade::vx::ppu::detail::Status expected_previous_status
halco::common::typed_array<stadls::vx::v3::AbsoluteTimePlaybackProgramContainerTicket, halco::hicann_dls::vx::v3::PPUOnDLS> previous_status
struct grenade::vx::execution::detail::generator::PPUReadHooks
#include <ppu.h>

Generator for a playback program snippet for reads of PPU symbols requested in hooks.

Public Types

typedef stadls::vx::v3::PlaybackProgramBuilder Builder

Public Functions

inline PPUReadHooks(std::set<std::string> const &symbol_names, lola::vx::v3::PPUElfFile::symbols_type const &symbols)

Construct generator for read hooks.

Parameters

  • symbol_names – PPU symbol names to read out

  • symbols – PPU symbols to use for location lookup

Protected Functions

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

Private Members

std::set<std::string> const &m_symbol_names
lola::vx::v3::PPUElfFile::symbols_type const &m_symbols

Friends

friend auto generate(PPUReadHooks const&)
struct grenade::vx::execution::detail::generator::PPUReadHooks::Result
#include <ppu.h>

Public Functions

signal_flow::OutputData::ReadPPUSymbols::value_type::mapped_type evaluate() const

Public Members

std::map<std::string, std::variant<std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, stadls::vx::v3::ContainerTicket>, stadls::vx::v3::ContainerTicket>> tickets
struct grenade::vx::execution::detail::generator::PPUStart
#include <ppu.h>

Generator for a playback program snippet for starting the PPUs.

Public Types

typedef stadls::vx::v3::PlaybackProgramBuilder Builder
typedef hate::Nil Result

Public Functions

inline PPUStart(halco::hicann_dls::vx::v3::PPUMemoryWordOnPPU const &coord)

Construct blocking PPU command.

Parameters

coord – PPU memory location at which to place the command

Protected Functions

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

Private Members

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

Friends

friend auto generate(PPUStart const&)
struct grenade::vx::execution::detail::generator::PPUStop
#include <ppu.h>

Generator for a playback program snippet for stopping the PPUs.

Public Types

typedef stadls::vx::v3::PlaybackProgramBuilder Builder
typedef hate::Nil Result

Public Functions

inline PPUStop(halco::hicann_dls::vx::v3::PPUMemoryWordOnPPU const &coord)

Construct blocking PPU command.

Parameters

coord – PPU memory location at which to place the command

Protected Functions

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

Private Members

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

Friends

friend auto generate(PPUStop 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, size_t realtime_column_index)
std::vector<std::string> done()

Public Members

bool has_periodic_cadc_readout = false
bool has_periodic_cadc_readout_on_dram = false
size_t num_periodic_cadc_samples = 0

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>>, size_t>> 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(std::vector<Neuron> neurons, 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
std::vector<Neuron> neurons = {}

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::BackgroundSourcePopulation::Neuron
#include <background_source_population.h>

Public Functions

Neuron(bool enable_record_spikes = false)
bool operator!=(Neuron const &other) const = default
bool operator==(Neuron const &other) const = default

Public Members

bool enable_record_spikes

Friends

friend std::ostream &operator<<(std::ostream &os, Neuron const &value)
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, bool placement_on_dram = false, 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 = {}
bool placement_on_dram = {false}
struct grenade::vx::network::Compartment : public grenade::vx::network::Property<Compartment>
#include <multicompartment_compartment.h>

Public Functions

virtual MechanismOnCompartment add(Mechanism const &mechanism)
virtual std::unique_ptr<Compartment> copy() const

Copy object.

virtual Mechanism const &get(MechanismOnCompartment const &descriptor) const
std::map<MechanismOnCompartment, HardwareResourcesWithConstraints> get_hardware(CompartmentOnNeuron const &compartment, Environment const &environment) const
virtual std::unique_ptr<Compartment> move()

Move object.

bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

virtual void remove(MechanismOnCompartment const &descriptor)
virtual void set(MechanismOnCompartment const &descriptor, Mechanism const &mechanism)
bool valid() const

Returns if all mechanisms on the compartment are valid.

Protected Functions

bool is_equal_to(Compartment const &other) const
virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

virtual std::ostream &print(std::ostream &os) const

Print object.

This method is to be implemented by derived classes.

Private Members

size_t m_mechanism_key_counter = 0
std::map<MechanismOnCompartment, detail::PropertyHolder<Mechanism>> m_mechanisms
struct grenade::vx::network::CompartmentConnection : public grenade::vx::network::Property<CompartmentConnection>
#include <multicompartment_compartment_connection.h>

Subclassed by grenade::vx::network::CompartmentConnectionConductance

Public Functions

CompartmentConnection() = default
virtual std::unique_ptr<T> copy() const = 0

Copy object.

virtual std::unique_ptr<T> move() = 0

Move object.

bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

Protected Functions

virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

virtual std::ostream &print(std::ostream &os) const = 0

Print object.

This method is to be implemented by derived classes.

struct grenade::vx::network::CompartmentConnection::ParameterSpace
#include <multicompartment_compartment_connection.h>

Public Functions

virtual bool valid(Parameterization const &parameterization) = 0
struct Parameterization
#include <multicompartment_compartment_connection.h>
struct grenade::vx::network::CompartmentConnectionConductance : public grenade::vx::network::CompartmentConnection
#include <conductance.h>

Public Functions

CompartmentConnectionConductance() = default
CompartmentConnectionConductance(double value)
virtual std::unique_ptr<CompartmentConnection> copy() const

Copy object.

virtual std::unique_ptr<CompartmentConnection> move()

Move object.

bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

virtual std::ostream &print(std::ostream &os) const

Print object.

This method is to be implemented by derived classes.

Public Members

ParameterSpace parameter_space
ParameterSpace::Parameterization parameterization

Protected Functions

bool is_equal_to(CompartmentConnection const &other) const
virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

struct grenade::vx::network::CompartmentConnectionConductance::ParameterSpace
#include <conductance.h>

Public Functions

bool contains(Parameterization const &conductance)

Public Members

ParameterInterval<double> conductance_interval
struct grenade::vx::network::CompartmentConnectionConductance::ParameterSpace::Parameterization
#include <conductance.h>

Public Functions

bool operator==(Parameterization const &other) const

Public Members

double conductance
struct grenade::vx::network::CompartmentConnectionOnNeuron : public grenade::vx::network::EdgeOnGraph<CompartmentConnectionOnNeuron, detail::UndirectedGraph>
#include <multicompartment_compartment_connection_on_neuron.h>

Public Types

typedef EdgeOnGraph Base
typedef Backend::edge_descriptor Value

Public Functions

EdgeOnGraph() = default
EdgeOnGraph(Value const &value)
bool operator!=(EdgeOnGraph const &other) const = default
bool operator==(EdgeOnGraph const &other) const = default
Value const &value() const
struct grenade::vx::network::CompartmentOnNeuron : public grenade::vx::network::VertexOnGraph<CompartmentOnNeuron, detail::UndirectedGraph>
#include <multicompartment_compartment_on_neuron.h>

Public Types

typedef VertexOnGraph Base
typedef Backend::vertex_descriptor Value

Public Functions

size_t hash() const
auto operator<=> (VertexOnGraph const &other) const=default
Value const &value() const
VertexOnGraph() = default
VertexOnGraph(Value const &value)
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)
template<typename T>
struct grenade::vx::network::Copyable
#include <copyable.h>

Object which is copyable.

Template Parameters

T – Derived class

Subclassed by grenade::vx::network::Property< Compartment >, grenade::vx::network::Property< CompartmentConnection >, grenade::vx::network::Property< HardwareConstraint >, grenade::vx::network::Property< HardwareResource >, grenade::vx::network::Property< Mechanism >, grenade::vx::network::Property< NumberTopBottom >, grenade::vx::network::Property< SynapticInputEnvironment >

Public Functions

virtual std::unique_ptr<T> copy() const = 0

Copy object.

template<typename T>
struct grenade::vx::network::detail::ConstructorTransform
#include <constructor_transform.h>

Public Functions

template<typename U>
inline constexpr T operator()(U &&value) const
template<typename T>
struct IsSupportedGraph : public std::false_type
#include <graph.h>
template<typename VertexCollection, typename EdgeCollection, typename Directionality>
struct grenade::vx::network::detail::IsSupportedGraph<boost::adjacency_list<EdgeCollection, VertexCollection, Directionality>>
#include <graph.h>

Public Static Attributes

static constexpr bool value = std::is_same_v<VertexCollection, boost::listS> && (std::is_same_v<EdgeCollection, boost::multisetS> || std::is_same_v<EdgeCollection, boost::setS>) && (std::is_same_v<Directionality, boost::bidirectionalS> || std::is_same_v<Directionality, boost::undirectedS>)
template<typename T, template<typename...> typename Backend = std::unique_ptr>
struct grenade::vx::network::detail::PropertyHolder
#include <property_holder.h>

Holder type for polymorphic property.

It is copyable, value-equality comparable, printable and provides safe access to the stored object.

Template Parameters

  • T – Type of object to store

  • Backend – Backend storage type

Public Functions

PropertyHolder() = default
PropertyHolder(PropertyHolder &&other) = default

Move-construct property holder.

Parameters

other – Other property holder

PropertyHolder(PropertyHolder const &other)

Copy-construct property holder.

Parameters

other – Other property holder

PropertyHolder(T &&value)

Construct property holder.

Parameters

value – Value to store

PropertyHolder(T const &value)

Construct property holder.

Parameters

value – Value to store

explicit operator bool() const

Get whether object is present.

bool operator!=(PropertyHolder const &other) const

Value-compare stored object if present.

Parameters

other – Other property holder

T &operator*() const

Get reference to stored object.

Throws

std::runtime_error – On no object being present

T *operator->() const

Get pointer to stored object.

Throws

std::runtime_error – On no object being present

PropertyHolder &operator=(PropertyHolder &&other) = default

Move-assign property holder.

Parameters

other – Other property holder

PropertyHolder &operator=(PropertyHolder const &other)

Copy-assign property holder.

Parameters

other – Other property holder

PropertyHolder &operator=(T &&other)

Move-assign property holder.

Parameters

other – Other property holder

PropertyHolder &operator=(T const &other)

Copy-assign property holder.

Parameters

other – Other property holder

bool operator==(PropertyHolder const &other) const

Value-compare stored object if present.

Parameters

other – Other property holder

Private Members

Backend<T> m_backend
template<typename Derived, typename Backend>
struct grenade::vx::network::EdgeOnGraph
#include <edge_on_graph.h>

Identifier of edge on graph.

Public Types

typedef EdgeOnGraph Base
typedef Backend::edge_descriptor Value

Public Functions

EdgeOnGraph() = default
EdgeOnGraph(Value const &value)
bool operator!=(EdgeOnGraph const &other) const = default
bool operator==(EdgeOnGraph const &other) const = default
Value const &value() const

Private Functions

std::ostream &print(std::ostream &os) const

Private Members

Value m_value

Friends

inline friend std::ostream &operator<<(std::ostream &os, EdgeOnGraph const &value)
template<typename Derived, typename Base>
struct grenade::vx::network::EmptyProperty : public Base
#include <empty_property.h>

Property type without content for using when the type information alone suffices.

Public Functions

virtual std::unique_ptr<Base> copy() const override
virtual std::unique_ptr<Base> move() override
virtual std::ostream &print(std::ostream &os) const override

Protected Functions

virtual bool is_equal_to(Base const &other) const override
struct grenade::vx::network::Environment
#include <multicompartment_environment.h>

Public Members

std::map<CompartmentOnNeuron, std::vector<detail::PropertyHolder<SynapticInputEnvironment>>> synaptic_connections
template<typename T>
struct grenade::vx::network::EqualityComparable
#include <equality_comparable.h>

Object which is equality comparable.

Template Parameters

Derived – class

Subclassed by grenade::vx::network::Property< Compartment >, grenade::vx::network::Property< CompartmentConnection >, grenade::vx::network::Property< HardwareConstraint >, grenade::vx::network::Property< HardwareResource >, grenade::vx::network::Property< Mechanism >, grenade::vx::network::Property< NumberTopBottom >, grenade::vx::network::Property< SynapticInputEnvironment >

Public Functions

bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

Protected Functions

virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

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(std::vector<Neuron> neurons, 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
std::vector<Neuron> neurons = {}

Friends

friend std::ostream &operator<<(std::ostream &os, ExternalSourcePopulation const &population)
struct grenade::vx::network::ExternalSourcePopulation::Neuron
#include <external_source_population.h>

Public Functions

Neuron(bool enable_record_spikes = false)
bool operator!=(Neuron const &other) const = default
bool operator==(Neuron const &other) const = default

Public Members

bool enable_record_spikes

Friends

friend std::ostream &operator<<(std::ostream &os, Neuron const &value)
template<typename Derived, typename Backend, typename VertexT, typename EdgeT, typename VertexDescriptorT, typename EdgeDescriptorT, template<typename...> typename Holder>
struct grenade::vx::network::Graph
#include <graph.h>

Graph containing storage for element properties.

Template Parameters

  • Derived – Derived graph class

  • Backend – Backend graph implementation without storage, required to be a boost::adjacency_list with descriptor stability across mutable operations and bidirectional or undirected directionality

  • VertexT – Vertex property type

  • EdgeT – Edge property type

  • VertexDescriptorT – Vertex descriptor type

  • EdgeDescriptorT – Edge descriptor type

  • Holder – Storage template to store EdgeT and VertexT for each element in the graph

Public Types

typedef boost::transform_iterator<typename detail::ConstructorTransform<VertexDescriptor>, typename Backend::adjacency_iterator> AdjacencyIterator
typedef EdgeT Edge
typedef EdgeDescriptorT EdgeDescriptor
typedef boost::transform_iterator<typename detail::ConstructorTransform<EdgeDescriptor>, typename Backend::edge_iterator> EdgeIterator
typedef boost::transform_iterator<typename detail::ConstructorTransform<EdgeDescriptor>, typename Backend::in_edge_iterator> InEdgeIterator
typedef boost::transform_iterator<typename detail::ConstructorTransform<VertexDescriptor>, typename Backend::inv_adjacency_iterator> InvAdjacencyIterator
typedef boost::transform_iterator<typename detail::ConstructorTransform<EdgeDescriptor>, typename Backend::out_edge_iterator> OutEdgeIterator
typedef VertexT Vertex
typedef VertexDescriptorT VertexDescriptor
typedef boost::transform_iterator<typename detail::ConstructorTransform<VertexDescriptor>, typename Backend::vertex_iterator> VertexIterator

Public Functions

Graph() = default

Construct graph without elements.

Graph(Graph &&other)

Move graph.

Graph(Graph const &other)

Copy graph.

The copy creates new descriptors for every element.

virtual EdgeDescriptor add_edge(VertexDescriptor const &source, VertexDescriptor const &target, Edge &&edge)

Add edge between vertices into graph.

Parameters

  • source – Source vertex descriptor of edge to add

  • target – Target vertex descriptor of edge to add

  • edge – Edge property

Throws

  • std::runtime_error – On edge yielding an invalid graph

  • std::runtime_error – On edge already present in graph

  • std::out_of_range – On source or target of edge not present in graph

Returns

Edge descriptor which in the case of an undirected graph matches the descriptors given by out_edges

virtual EdgeDescriptor add_edge(VertexDescriptor const &source, VertexDescriptor const &target, Edge const &edge)

Add edge between vertices into graph.

Parameters

  • source – Source vertex descriptor of edge to add

  • target – Target vertex descriptor of edge to add

  • edge – Edge property

Throws

  • std::runtime_error – On edge yielding an invalid graph

  • std::runtime_error – On edge already present in graph

  • std::out_of_range – On source or target of edge not present in graph

Returns

Edge descriptor which in the case of an undirected graph matches the descriptors given by out_edges

virtual VertexDescriptor add_vertex(Vertex &&vertex)

Add vertex into graph.

Parameters

vertex – Vertex to add

Returns

Descriptor to vertex in graph

virtual VertexDescriptor add_vertex(Vertex const &vertex)

Add vertex into graph.

Parameters

vertex – Vertex to add

Returns

Descriptor to vertex in graph

std::pair<AdjacencyIterator, AdjacencyIterator> adjacent_vertices(VertexDescriptor const &descriptor) const

Get iterator range over vertices adjacent to given vertex.

This is the case if there’s an edge from the given vertex to the other vertex.

Parameters

descriptor – Vertex descriptor

Throws

std::out_of_range – On vertex not present in graph

virtual void clear_in_edges(VertexDescriptor const &descriptor)

Remove all in-edges of a vertex.

Parameters

descriptor – Vertex descriptor

Throws

std::out_of_range – On vertex not present in graph

virtual void clear_out_edges(VertexDescriptor const &descriptor)

Remove all out-edges of a vertex.

Parameters

descriptor – Vertex descriptor

Throws

std::out_of_range – On vertex not present in graph

virtual void clear_vertex(VertexDescriptor const &descriptor)

Remove all edges to and from a vertex.

Parameters

descriptor – Vertex descriptor

Throws

std::out_of_range – On vertex not present in graph

bool contains(EdgeDescriptor const &descriptor) const

Get whether graph contains given edge.

Parameters

descriptor – Descriptor to edge

bool contains(VertexDescriptor const &descriptor) const

Get whether graph contains given vertex.

Parameters

descriptor – Descriptor to vertex

std::pair<OutEdgeIterator, OutEdgeIterator> edge_range(VertexDescriptor const &source, VertexDescriptor const &target) const

Get iterator range over out-edges between given source and target vertex.

For an undirected graph, the edge descriptors given here match the edge properties.

Parameters

  • source – Source vertex descriptor

  • target – Target vertex descriptor

Throws

std::out_of_range – On source or target vertex not present in graph

std::pair<EdgeIterator, EdgeIterator> edges() const

Get iterator range over edges.

Edge const &get(EdgeDescriptor const &descriptor) const

Get edge property.

Parameters

descriptor – Edge descriptor

Throws

std::out_of_range – On edge not being present in graph

Vertex const &get(VertexDescriptor const &descriptor) const

Get vertex property.

Parameters

descriptor – Vertex descriptor

Throws

std::out_of_range – On vertex not being present in graph

size_t in_degree(VertexDescriptor const &descriptor) const

Get in-degree of given vertex.

Parameters

descriptor – Vertex descriptor

Throws

std::out_of_range – On vertex not present in graph

std::pair<InEdgeIterator, InEdgeIterator> in_edges(VertexDescriptor const &descriptor) const

Get iterator range over in-edges of given vertex.

For an undirected graph, the edge descriptors given here don’t match the edge properties since they are describing the reversed edges.

Parameters

descriptor – Vertex descriptor

Throws

std::out_of_range – On vertex not present in graph

std::pair<InvAdjacencyIterator, InvAdjacencyIterator> inv_adjacent_vertices(VertexDescriptor const &descriptor) const

Get iterator range over vertices to which given vertex is adjacent.

This is the case if there’s an edge from the other vertex to the given vertex.

Parameters

descriptor – Vertex descriptor

Throws

std::out_of_range – On vertex not present in graph

size_t num_edges() const

Get number of edges in graph.

size_t num_vertices() const

Get number of vertices in graph.

bool operator!=(Graph const &other) const
Graph &operator=(Graph &&other)

Move graph.

Graph &operator=(Graph const &other)

Copy graph.

The copy creates new descriptors for every element.

bool operator==(Graph const &other) const

Get whether graphs are equal.

This is the case exactly if all vertex descriptors and properties as well as all edge properties match in order and the edges connect the same vertices.

size_t out_degree(VertexDescriptor const &descriptor) const

Get out-degree of given vertex.

Parameters

descriptor – Vertex descriptor

Throws

std::out_of_range – On vertex not present in graph

std::pair<OutEdgeIterator, OutEdgeIterator> out_edges(VertexDescriptor const &descriptor) const

Get iterator range over out-edges of given vertex.

For an undirected graph, the edge descriptors given here match the edge properties.

Parameters

descriptor – Vertex descriptor

Throws

std::out_of_range – On vertex not present in graph

virtual void remove_edge(EdgeDescriptor const &descriptor)

Remove edge from graph.

Parameters

descriptor – Edge descriptor to remove

Throws

std::out_of_range – On edge not present in graph

virtual void remove_edge(VertexDescriptor const &source, VertexDescriptor const &target)

Removes all edges between source and target vertex from graph.

Parameters

  • source – Vertex descriptor of source of edge(s) to remove

  • target – Vertex descriptor of target of edge(s) to remove

Throws

std::out_of_range – On vertices not present in graph

virtual void remove_vertex(VertexDescriptor const &descriptor)

Remove vertex.

Parameters

descriptor – Vertex descriptor

Throws

  • std::out_of_range – On vertex not present in graph

  • std::runtime_error – On edges being present to or from vertex

void set(EdgeDescriptor const &descriptor, Edge &&vertex)

Set edge property.

Parameters

  • descriptor – Edge descriptor

  • vertex – Edge property

Throws

  • std::out_of_range – On edge not being present in graph

  • std::runtime_error – On edge property change yielding invalid graph

void set(EdgeDescriptor const &descriptor, Edge const &vertex)

Set edge property.

Parameters

  • descriptor – Edge descriptor

  • vertex – Edge property

Throws

  • std::out_of_range – On edge not being present in graph

  • std::runtime_error – On edge property change yielding invalid graph

void set(VertexDescriptor const &descriptor, Vertex &&vertex)

Set vertex property.

Parameters

  • descriptor – Vertex descriptor

  • vertex – Vertex property

Throws

  • std::out_of_range – On vertex not being present in graph

  • std::runtime_error – On vertex property change yielding invalid graph

void set(VertexDescriptor const &descriptor, Vertex const &vertex)

Set vertex property.

Parameters

  • descriptor – Vertex descriptor

  • vertex – Vertex property

Throws

  • std::out_of_range – On vertex not being present in graph

  • std::runtime_error – On vertex property change yielding invalid graph

VertexDescriptor source(EdgeDescriptor const &descriptor) const

Get source vertex of given edge.

Parameters

descriptor – Edge descriptor

Throws

std::out_of_range – On edge not present in graph

VertexDescriptor target(EdgeDescriptor const &descriptor) const

Get target vertex of given edge.

Parameters

descriptor – Edge descriptor

Throws

std::out_of_range – On edge not present in graph

std::pair<VertexIterator, VertexIterator> vertices() const

Get iterator range over vertices.

Private Functions

void check_contains(EdgeDescriptor const &descriptor, char const *description) const
void check_contains(VertexDescriptor const &descriptor, char const *description) const

Private Members

std::unordered_map<EdgeDescriptor, detail::PropertyHolder<Edge, Holder>> m_edges
Backend m_graph
std::unordered_map<VertexDescriptor, detail::PropertyHolder<Vertex, Holder>> m_vertices
struct grenade::vx::network::HardwareConstraint : public grenade::vx::network::Property<HardwareConstraint>
#include <multicompartment_hardware_constraint.h>

Public Functions

virtual std::unique_ptr<HardwareConstraint> copy() const

Copy object.

virtual std::unique_ptr<HardwareConstraint> move()

Move object.

bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

Public Members

NumberTopBottom numbers
detail::PropertyHolder<HardwareResource> resource

Protected Functions

bool is_equal_to(HardwareConstraint const &other) const
virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

virtual std::ostream &print(std::ostream &os) const

Print object.

This method is to be implemented by derived classes.

struct grenade::vx::network::HardwareResource : public grenade::vx::network::Property<HardwareResource>
#include <multicompartment_hardware_resource.h>

Subclassed by grenade::vx::network::EmptyProperty< HardwareResourceCapacity, HardwareResource >, grenade::vx::network::EmptyProperty< HardwareResourceSynapticInputExitatory, HardwareResource >, grenade::vx::network::EmptyProperty< HardwareResourceSynapticInputInhibitory, HardwareResource >

Public Functions

HardwareResource() = default
virtual std::unique_ptr<T> copy() const = 0

Copy object.

virtual std::unique_ptr<T> move() = 0

Move object.

bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

Protected Functions

virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

virtual std::ostream &print(std::ostream &os) const = 0

Print object.

This method is to be implemented by derived classes.

struct grenade::vx::network::HardwareResourceCapacity : public grenade::vx::network::EmptyProperty<HardwareResourceCapacity, HardwareResource>
#include <capacitance.h>

Public Functions

HardwareResourceCapacity() = default
virtual std::unique_ptr<HardwareResource> copy() const override
virtual std::unique_ptr<HardwareResource> move() override
bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

virtual std::ostream &print(std::ostream &os) const override

Protected Functions

virtual bool is_equal_to(HardwareResource const &other) const override
virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

struct grenade::vx::network::HardwareResourcesWithConstraints
#include <multicompartment_hardware_resource_with_constraint.h>

Public Members

std::vector<detail::PropertyHolder<HardwareConstraint>> constraints
std::vector<detail::PropertyHolder<HardwareResource>> resources
struct grenade::vx::network::HardwareResourceSynapticInputExitatory : public grenade::vx::network::EmptyProperty<HardwareResourceSynapticInputExitatory, HardwareResource>
#include <synaptic_input_excitatory.h>

Public Functions

HardwareResourceSynapticInputExitatory() = default
virtual std::unique_ptr<HardwareResource> copy() const override
virtual std::unique_ptr<HardwareResource> move() override
bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

virtual std::ostream &print(std::ostream &os) const override

Protected Functions

virtual bool is_equal_to(HardwareResource const &other) const override
virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

struct grenade::vx::network::HardwareResourceSynapticInputInhibitory : public grenade::vx::network::EmptyProperty<HardwareResourceSynapticInputInhibitory, HardwareResource>
#include <synaptic_input_inhibitory.h>

Public Functions

HardwareResourceSynapticInputInhibitory() = default
virtual std::unique_ptr<HardwareResource> copy() const override
virtual std::unique_ptr<HardwareResource> move() override
bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

virtual std::ostream &print(std::ostream &os) const override

Protected Functions

virtual bool is_equal_to(HardwareResource const &other) const override
virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

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, common::Time const &delay = common::Time(0))
bool operator!=(Connection const &other) const
bool operator==(Connection const &other) const

Public Members

common::Time delay

Time duration by which to delay events across this connection.

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::Mechanism : public grenade::vx::network::Property<Mechanism>
#include <multicompartment_mechanism.h>

Subclassed by grenade::vx::network::MechanismCapacitance, grenade::vx::network::MechanismSynapticInputConductance, grenade::vx::network::MechanismSynapticInputCurrent

Public Functions

virtual bool conflict(Mechanism const &other) const = 0
virtual std::unique_ptr<T> copy() const = 0

Copy object.

virtual HardwareResourcesWithConstraints get_hardware(CompartmentOnNeuron const &compartment, Environment const &environment) const = 0
virtual std::unique_ptr<T> move() = 0

Move object.

bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

virtual bool valid() const = 0

Protected Functions

virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

virtual std::ostream &print(std::ostream &os) const = 0

Print object.

This method is to be implemented by derived classes.

struct grenade::vx::network::MechanismCapacitance : public grenade::vx::network::Mechanism
#include <capacitance.h>

Public Functions

MechanismCapacitance() = default
MechanismCapacitance(ParameterSpace const &parameter_space_in)
virtual bool conflict(Mechanism const &other) const
virtual std::unique_ptr<Mechanism> copy() const

Copy object.

virtual HardwareResourcesWithConstraints get_hardware(CompartmentOnNeuron const &compartment, Environment const &environment) const
virtual std::unique_ptr<Mechanism> move()

Move object.

bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

virtual bool valid() const

Public Members

ParameterSpace parameter_space

Protected Functions

bool is_equal_to(Mechanism const &other) const
virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

virtual std::ostream &print(std::ostream &os) const

Print object.

This method is to be implemented by derived classes.

struct grenade::vx::network::MechanismCapacitance::ParameterSpace
#include <capacitance.h>

Public Functions

ParameterSpace() = default
ParameterSpace(ParameterInterval<double> const &parameter_interval_in, Parameterization const &parameterization_in)
bool operator!=(ParameterSpace const &other) const = default
bool operator==(ParameterSpace const &other) const = default
bool valid() const

Public Members

ParameterInterval<double> capacitance_interval
Parameterization parameterization
struct grenade::vx::network::MechanismCapacitance::ParameterSpace::Parameterization
#include <capacitance.h>

Public Functions

Parameterization() = default
Parameterization(double const &value)
bool operator!=(Parameterization const &other) const = default
bool operator==(Parameterization const &other) const = default

Public Members

double capacitance
struct grenade::vx::network::MechanismSynapticInputConductance : public grenade::vx::network::Mechanism
#include <synaptic_conductance.h>

Public Functions

MechanismSynapticInputConductance() = default
MechanismSynapticInputConductance(ParameterSpace const &parameter_space_in)
virtual bool conflict(Mechanism const &other) const
virtual std::unique_ptr<Mechanism> copy() const

Copy object.

virtual HardwareResourcesWithConstraints get_hardware(CompartmentOnNeuron const &compartment, Environment const &environment) const
virtual std::unique_ptr<Mechanism> move()

Move object.

bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

virtual bool valid() const

Public Members

ParameterSpace parameter_space

Protected Functions

bool is_equal_to(Mechanism const &other) const
virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

virtual std::ostream &print(std::ostream &os) const

Print object.

This method is to be implemented by derived classes.

Private Functions

int round(int i) const
struct grenade::vx::network::MechanismSynapticInputConductance::ParameterSpace
#include <synaptic_conductance.h>

Public Functions

ParameterSpace() = default
ParameterSpace(ParameterInterval<double> const &interval_conductance, ParameterInterval<double> const &interval_potential, ParameterInterval<double> const &interval_time_constant, Parameterization const &paramterization_in)
bool operator!=(ParameterSpace const &other) const = default
bool operator==(ParameterSpace const &other) const = default
bool valid() const

Public Members

ParameterInterval<double> conductance_interval
Parameterization parameterization
ParameterInterval<double> potential_interval
ParameterInterval<double> time_constant_interval
struct grenade::vx::network::MechanismSynapticInputConductance::ParameterSpace::Parameterization
#include <synaptic_conductance.h>

Public Functions

Parameterization() = default
Parameterization(double const &conductance_in, double const &potential_in, double const &time_constant_in)
bool operator!=(Parameterization const &other) const = default
bool operator==(Parameterization const &other) const = default

Public Members

double conductance
double potential
double time_constant
struct grenade::vx::network::MechanismSynapticInputCurrent : public grenade::vx::network::Mechanism
#include <synaptic_current.h>

Public Functions

MechanismSynapticInputCurrent() = default
MechanismSynapticInputCurrent(ParameterSpace const &parameter_space_in)
virtual bool conflict(Mechanism const &other) const
virtual std::unique_ptr<Mechanism> copy() const

Copy object.

virtual HardwareResourcesWithConstraints get_hardware(CompartmentOnNeuron const &compartment, Environment const &environment) const
virtual std::unique_ptr<Mechanism> move()

Move object.

bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

virtual bool valid() const

Public Members

ParameterSpace parameter_space

Protected Functions

bool is_equal_to(Mechanism const &other) const
virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

virtual std::ostream &print(std::ostream &os) const

Print object.

This method is to be implemented by derived classes.

Private Functions

int round(int i) const
struct grenade::vx::network::MechanismSynapticInputCurrent::ParameterSpace
#include <synaptic_current.h>

Public Functions

ParameterSpace() = default
ParameterSpace(ParameterInterval<double> const &interval_current_in, ParameterInterval<double> const &interval_time_constant_in, Parameterization const &paramterization_in)
bool operator!=(ParameterSpace const &other) const = default
bool operator==(ParameterSpace const &other) const = default
bool valid() const

Public Members

ParameterInterval<double> current_interval
Parameterization parameterization
ParameterInterval<double> time_constant_interval
struct grenade::vx::network::MechanismSynapticInputCurrent::ParameterSpace::Parameterization
#include <synaptic_current.h>

Public Functions

Parameterization() = default
Parameterization(double const &current_in, double const &time_constant_in)
bool operator!=(Parameterization const &other) const = default
bool operator==(Parameterization const &other) const = default

Public Members

double current
double time_constant
template<typename T>
struct grenade::vx::network::Movable
#include <movable.h>

Object which is movable.

Template Parameters

T – Derived class

Subclassed by grenade::vx::network::Property< Compartment >, grenade::vx::network::Property< CompartmentConnection >, grenade::vx::network::Property< HardwareConstraint >, grenade::vx::network::Property< HardwareResource >, grenade::vx::network::Property< Mechanism >, grenade::vx::network::Property< NumberTopBottom >, grenade::vx::network::Property< SynapticInputEnvironment >

Public Functions

virtual std::unique_ptr<T> move() = 0

Move object.

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::Neuron : private grenade::vx::network::Graph<Neuron, detail::UndirectedGraph, Compartment, CompartmentConnection, CompartmentOnNeuron, CompartmentConnectionOnNeuron, std::unique_ptr>
#include <multicompartment_neuron.h>

Public Types

typedef VertexIterator CompartmentIterator

Public Functions

Neuron() = default
CompartmentOnNeuron add_compartment(Compartment const &compartment)
CompartmentConnectionOnNeuron add_compartment_connection(CompartmentOnNeuron source, CompartmentOnNeuron target, CompartmentConnection const &edge)
std::pair<CompartmentIterator, CompartmentIterator> compartment_iterators() const
bool contains(CompartmentOnNeuron const &descriptor) const
CompartmentConnection const &get(CompartmentConnectionOnNeuron const &descriptor) const
Compartment const &get(CompartmentOnNeuron const &descriptor) const
int in_degree(CompartmentOnNeuron const &descriptor) const
size_t num_compartment_connections() const
size_t num_compartments() const
int out_degree(CompartmentOnNeuron const &descriptor) const
void remove_compartment(CompartmentOnNeuron descriptor)
void remove_compartment_connection(CompartmentConnectionOnNeuron descriptor)
void set(CompartmentConnectionOnNeuron const &descriptor, CompartmentConnection const &connection)
void set(CompartmentOnNeuron const &descriptor, Compartment const &compartment)
CompartmentOnNeuron source(CompartmentConnectionOnNeuron const &descriptor) const
CompartmentOnNeuron target(CompartmentConnectionOnNeuron const &descriptor) const
bool valid()

Private Functions

bool contains(EdgeDescriptor const &descriptor) const

Get whether graph contains given edge.

Parameters

descriptor – Descriptor to edge

void set(EdgeDescriptor const &descriptor, Edge &&vertex)

Set edge property.

Parameters

  • descriptor – Edge descriptor

  • vertex – Edge property

Throws

  • std::out_of_range – On edge not being present in graph

  • std::runtime_error – On edge property change yielding invalid graph

void set(VertexDescriptor const &descriptor, Vertex &&vertex)

Set vertex property.

Parameters

  • descriptor – Vertex descriptor

  • vertex – Vertex property

Throws

  • std::out_of_range – On vertex not being present in graph

  • std::runtime_error – On vertex property change yielding invalid graph

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::NumberTopBottom : public grenade::vx::network::Property<NumberTopBottom>
#include <multicompartment_top_bottom.h>

Public Functions

NumberTopBottom()
NumberTopBottom(size_t number_total_in, size_t number_top_in, size_t number_bottom_in)
virtual std::unique_ptr<NumberTopBottom> copy() const

Copy object.

virtual std::unique_ptr<NumberTopBottom> move()

Move object.

bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

NumberTopBottom operator+=(NumberTopBottom const &other)
bool operator<(NumberTopBottom const &other) const
bool operator<=(NumberTopBottom const &other) const
bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

bool operator==(NumberTopBottom const &other) const
bool operator>(NumberTopBottom const &other) const

Public Members

size_t number_bottom
size_t number_top
size_t number_total

Protected Functions

bool is_equal_to(NumberTopBottom const &other) const
virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

virtual std::ostream &print(std::ostream &os) const

Print object.

This method is to be implemented by derived classes.

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 = {}
template<class T>
struct grenade::vx::network::ParameterInterval
#include <parameter_interval.h>

Public Functions

ParameterInterval() = default
ParameterInterval(T lower_limit, T upper_limit)
bool contains(T const &parameter) const
T const &get_lower() const
T const &get_upper() const
bool operator!=(ParameterInterval const &other) const = default
bool operator==(ParameterInterval const &other) const = default

Private Members

T m_lower_limit = {}
T m_upper_limit = {}
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::Printable
#include <printable.h>

Object which is printable.

Subclassed by grenade::vx::network::Property< Compartment >, grenade::vx::network::Property< CompartmentConnection >, grenade::vx::network::Property< HardwareConstraint >, grenade::vx::network::Property< HardwareResource >, grenade::vx::network::Property< Mechanism >, grenade::vx::network::Property< NumberTopBottom >, grenade::vx::network::Property< SynapticInputEnvironment >, grenade::vx::network::Property< Derived >

Public Functions

virtual ~Printable()

Protected Functions

virtual std::ostream &print(std::ostream &os) const = 0

Print object.

This method is to be implemented by derived classes.

Friends

friend std::ostream &operator<<(std::ostream &os, Printable const &printable)

Ostream operator for all objects which are derived from Printable.

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
template<typename Derived>
struct grenade::vx::network::Property : public grenade::vx::network::Copyable<Derived>, public grenade::vx::network::Movable<Derived>, public grenade::vx::network::Printable, public grenade::vx::network::EqualityComparable<Derived>
#include <property.h>

Property, which we define to have the following properties:

  • copyable

  • movable

  • printable

  • equality-comparable

Public Functions

virtual std::unique_ptr<Derived> copy() const = 0

Copy object.

virtual std::unique_ptr<Derived> move() = 0

Move object.

bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

Protected Functions

virtual bool is_equal_to(Derived const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

virtual std::ostream &print(std::ostream &os) const = 0

Print object.

This method is to be implemented by derived classes.

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::ResourceManager
#include <multicompartment_resource_manager.h>

Public Functions

CompartmentOnNeuron add_config(CompartmentOnNeuron const &compartment, Neuron const &neuron, Environment const &environment)
NumberTopBottom const &get_config(CompartmentOnNeuron const &compartment) const
void remove_config(CompartmentOnNeuron const &compartment)

Private Members

std::map<CompartmentOnNeuron, detail::PropertyHolder<NumberTopBottom>> resource_map
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_background_to_l2(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_from_l2_to_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, Network::ExecutionInstance const &network) 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, Network::ExecutionInstance const &network) 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
struct grenade::vx::network::SynapticInputEnvironment : public grenade::vx::network::Property<SynapticInputEnvironment>
#include <multicompartment_synaptic_input_environment.h>

Subclassed by grenade::vx::network::SynapticInputEnvironmentConductance, grenade::vx::network::SynapticInputEnvironmentCurrent

Public Functions

SynapticInputEnvironment() = default
SynapticInputEnvironment(bool exitatory, int number)
SynapticInputEnvironment(bool exitatory, NumberTopBottom numbers)
virtual std::unique_ptr<SynapticInputEnvironment> copy() const

Copy object.

virtual std::unique_ptr<SynapticInputEnvironment> move()

Move object.

bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

Public Members

bool exitatory
NumberTopBottom number_of_inputs

Protected Functions

virtual bool is_equal_to(SynapticInputEnvironment const &other) const
virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

virtual std::ostream &print(std::ostream &os) const

Print object.

This method is to be implemented by derived classes.

struct grenade::vx::network::SynapticInputEnvironmentConductance : public grenade::vx::network::SynapticInputEnvironment
#include <conductance.h>

Public Functions

SynapticInputEnvironmentConductance() = default
SynapticInputEnvironmentConductance(bool exitatory, int number)
SynapticInputEnvironmentConductance(bool exitatory, NumberTopBottom numbers)
virtual std::unique_ptr<SynapticInputEnvironment> copy() const

Copy object.

virtual std::unique_ptr<SynapticInputEnvironment> move()

Move object.

bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

Public Members

bool exitatory
NumberTopBottom number_of_inputs

Protected Functions

virtual bool is_equal_to(SynapticInputEnvironment const &other) const
bool is_equal_to(SynapticInputEnvironmentConductance const &other) const
virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

virtual std::ostream &print(std::ostream &os) const

Print object.

This method is to be implemented by derived classes.

struct grenade::vx::network::SynapticInputEnvironmentCurrent : public grenade::vx::network::SynapticInputEnvironment
#include <current.h>

Public Functions

SynapticInputEnvironmentCurrent() = default
SynapticInputEnvironmentCurrent(bool exitatory, int number)
SynapticInputEnvironmentCurrent(bool exitatory, NumberTopBottom numbers)
virtual std::unique_ptr<SynapticInputEnvironment> copy() const

Copy object.

virtual std::unique_ptr<SynapticInputEnvironment> move()

Move object.

bool operator!=(EqualityComparable const &other) const

Compare unequal to other derived object.

Parameters

other – Other derived object.

bool operator==(EqualityComparable const &other) const

Compare equal to other derived object.

Parameters

other – Other derived object.

Public Members

bool exitatory
NumberTopBottom number_of_inputs

Protected Functions

virtual bool is_equal_to(SynapticInputEnvironment const &other) const
bool is_equal_to(SynapticInputEnvironmentCurrent const &other) const
virtual bool is_equal_to(T const &other) const = 0

Check whether this instance is equal to the other object.

This method is expected to only be called in the operator==. It is allowed to assume that the other object is of the same type as this instance.

Parameters

other – Other derived object

virtual std::ostream &print(std::ostream &os) const

Print object.

This method is to be implemented by derived classes.

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<std::pair<halco::hicann_dls::vx::v3::SpikeLabel, common::Time>>> translation

Post labels for pre label with according delays.

Public Static Attributes

static constexpr signal_flow::ConnectionType type = signal_flow::ConnectionType::TimedSpikeFromChipSequence
template<typename Derived, typename Backend>
struct grenade::vx::network::VertexOnGraph
#include <vertex_on_graph.h>

Identifier of vertex on graph.

Public Types

typedef VertexOnGraph Base
typedef Backend::vertex_descriptor Value

Public Functions

VertexOnGraph() = default
VertexOnGraph(Value const &value)
size_t hash() const
auto operator<=> (VertexOnGraph const &other) const =default
Value const &value() const

Private Functions

std::ostream &print(std::ostream &os) const

Private Members

Value m_value

Friends

inline friend std::ostream &operator<<(std::ostream &os, VertexOnGraph const &value)
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::ExecutionHealthInfo
#include <execution_health_info.h>

Health information of hardware setups used during execution.

Contains drop counter and chip-FPGA link status information.

Public Functions

void merge(ExecutionHealthInfo &&other)

Merge other execution health info.

This merges all map-like structures.

Parameters

other – Other execution health info to merge

void merge(ExecutionHealthInfo &other)

Merge other execution health info.

This merges all map-like structures.

Parameters

other – Other execution health info to merge

Public Members

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

Friends

friend std::ostream &operator<<(std::ostream &os, ExecutionHealthInfo const &data)
struct grenade::vx::signal_flow::ExecutionHealthInfo::ExecutionInstance
#include <execution_health_info.h>

Public Functions

ExecutionInstance &operator+=(ExecutionInstance const &rhs)

Calculates sum of counter values.

ExecutionInstance &operator-=(ExecutionInstance const &rhs)

Calculates difference of counter values, expects rhs > lhs.

Public Members

halco::common::typed_heap_array<haldls::vx::CrossbarInputDropCounter, halco::hicann_dls::vx::v3::CrossbarInputOnDLS> crossbar_input_drop_counter
halco::common::typed_heap_array<haldls::vx::CrossbarOutputEventCounter, halco::hicann_dls::vx::v3::CrossbarOutputOnDLS> crossbar_output_event_counter
haldls::vx::v3::HicannARQStatus hicann_arq_status
halco::common::typed_heap_array<haldls::vx::v3::PhyStatus, halco::hicann_dls::vx::v3::PhyStatusOnFPGA> phy_status

Friends

friend std::ostream &operator<<(std::ostream &os, ExecutionInstance const &data)
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, lola::vx::v3::ExternalPPUDRAMMemoryBlock>> 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, lola::vx::v3::ExternalPPUDRAMMemoryBlock>>>> 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<ExecutionHealthInfo> execution_health_info

Optional health information of performed execution to be filled by executor.

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
enumerator periodic_on_dram
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_declaration() 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

RawRecording()
RawRecording(size_t scratchpad_memory_size, bool placement_in_dram)
bool operator!=(RawRecording const &other) const
bool operator==(RawRecording const &other) const

Public Members

bool placement_in_dram

Whether to place the recording data in dram on the FPGA or in block ram.

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

TimedRecording()
TimedRecording(std::map<std::string, Observable> observables, bool placement_in_dram)
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.

bool placement_in_dram

Whether to place the recording data in dram on the FPGA or in block ram.

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<typename T>
struct hash
template<>
struct std::hash<grenade::vx::network::CompartmentConnectionOnNeuron>
#include <multicompartment_compartment_connection_on_neuron.h>

Public Functions

inline size_t operator()(grenade::vx::network::CompartmentConnectionOnNeuron const &value) const
template<>
struct std::hash<grenade::vx::network::CompartmentOnNeuron>
#include <multicompartment_compartment_on_neuron.h>

Public Functions

inline size_t operator()(grenade::vx::network::CompartmentOnNeuron const &value) const
template<>
struct std::hash<grenade::vx::network::detail::BidirectionalMultiGraph::edge_descriptor>
#include <graph.h>

Public Functions

inline size_t operator()(grenade::vx::network::detail::BidirectionalMultiGraph::edge_descriptor const &e) const
template<>
struct std::hash<grenade::vx::network::detail::UndirectedGraph::edge_descriptor>
#include <graph.h>

Public Functions

inline size_t operator()(grenade::vx::network::detail::UndirectedGraph::edge_descriptor const &e) const
template<typename Derived, typename Backend>
struct std::hash<grenade::vx::network::EdgeOnGraph<Derived, Backend>>
#include <edge_on_graph.h>

Public Functions

inline size_t operator()(grenade::vx::network::EdgeOnGraph<Derived, Backend> const &value) const
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<typename Derived, typename Backend>
struct std::hash<grenade::vx::network::VertexOnGraph<Derived, Backend>>
#include <vertex_on_graph.h>

Public Functions

inline size_t operator()(grenade::vx::network::VertexOnGraph<Derived, Backend> const &value) 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 GENPYBIND_TAG_GRENADE_VX_NETWORK
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.

static haldls::vx::v3::Timer::Value const periodic_cadc_fpga_wait_clock_cycles (15 *haldls::vx::v3::Timer::Value::fpga_clock_cycles_per_us)
static haldls::vx::v3::Timer::Value const periodic_cadc_ppu_wait_clock_cycles (10 *haldls::vx::v3::Timer::Value::fpga_clock_cycles_per_us *2)
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 num_cadc_samples_in_extmem_dram = 2048 * 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)
template<typename Derived, typename Backend, typename Vertex, typename Edge, typename VertexDescriptor, typename EdgeDescriptor, template<typename...> typename Holder>
std::ostream &operator<<(std::ostream &os, Graph<Derived, Backend, Vertex, Edge, VertexDescriptor, EdgeDescriptor, Holder> const &value)
template<typename T>
std::ostream &operator<<(std::ostream &os, ParameterInterval<T> const &interval)
std::ostream &operator<<(std::ostream &os, Projection::Connection::Index const &index)
std::ostream &operator<<(std::ostream &os, Receptor::Type const &receptor_type)
template<typename Derived, typename Backend>
std::ostream &operator<<(std::ostream &os, VertexOnGraph<Derived, Backend> const &value)
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 grenade::vx::network::detail

Typedefs

typedef boost::adjacency_list<boost::setS, boost::listS, boost::bidirectionalS> BidirectionalGraph

Bidirectional graph.

We use listS for the vertex descriptors, because we need descriptor stability across removal of vertices, since they are used to access stored properties alongside the graph. In addition we require construction order stability and therefore do not use a set.

We use setS for the edge descriptors, because we need descriptor stability across removal of edges since they are used to access stored properties alongside the graph. We don’t use listS because we want to support edge_range functionality.

typedef boost::adjacency_list<boost::multisetS, boost::listS, boost::bidirectionalS> BidirectionalMultiGraph

Bidirectional (multi-)graph.

We use listS for the vertex descriptors, because we need descriptor stability across removal of vertices, since they are used to access stored properties alongside the graph. In addition we require construction order stability and therefore do not use a set.

We use multisetS for the edge descriptors, because we need descriptor stability across removal of edges since they are used to access stored properties alongside the graph. We don’t use listS because we want to support edge_range functionality.

typedef boost::adjacency_list<boost::setS, boost::listS, boost::undirectedS> UndirectedGraph

Undirected graph.

We use listS for the vertex descriptors, because we need descriptor stability across removal of vertices, since they are used to access stored properties alongside the graph. In addition we require construction order stability and therefore do not use a set.

We use setS for the edge descriptors, because we need descriptor stability across removal of edges since they are used to access stored properties alongside the graph. We don’t use listS because we want to support edge_range functionality.

Functions

template<typename T, template<typename...> typename Backend>
std::ostream &operator<<(std::ostream &os, PropertyHolder<T, Backend> const &value)
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

Typedefs

using T = char[sizeof(T)]

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

Functions

std::ostream &operator<<(std::ostream &os, Status const &value)
template<typename T>
inline constexpr T &uninitialized_cast(uninitialized<T> &raw)

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 haldls
namespace vx
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_config.h
#include “”
#include “”
#include “”
#include “”
#include “”
#include “”
#include “”
#include “”
#include <>
#include <>
file connection_state_storage.h
#include “”
#include “grenade/vx/execution/detail/connection_config.h”
#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/execution_instance_node.h”
#include “grenade/vx/execution/detail/generator/neuron_reset_mask.h”
#include “grenade/vx/execution/detail/generator/ppu.h”
#include “grenade/vx/signal_flow/data.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/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 “”
#include “”
file capmem.h
#include “”
#include “”
#include “”
#include “”
file get_state.h
#include “”
#include “”
#include “”
#include “”
#include “”
#include “”
#include “”
#include “”
file health_info.h
#include “grenade/vx/signal_flow/execution_health_info.h”
#include “”
#include “”
#include “”
#include “”
#include “”
#include “”
#include “”
#include “”
file madc.h
#include “”
#include “”
#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 “grenade/vx/signal_flow/output_data.h”
#include “”
#include “”
#include “”
#include “”
#include “”
#include “”
#include “”
#include “”
#include “”
#include “”
#include “”
file ppu.h
#include “”
#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_health_info.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 copyable.h
#include “grenade/vx/genpybind.h”
#include “”
#include <>
file constructor_transform.h
#include <>
file graph.h
#include <>
#include <>
#include <>
file graph.h
#include “grenade/vx/genpybind.h”
#include “grenade/vx/network/abstract/detail/constructor_transform.h”
#include “grenade/vx/network/abstract/detail/graph.h”
#include “grenade/vx/network/abstract/detail/property_holder.h”
#include “grenade/vx/network/abstract/edge_on_graph.h”
#include “grenade/vx/network/abstract/property.h”
#include “grenade/vx/network/abstract/vertex_on_graph.h”
#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 property_holder.h
#include “grenade/vx/network/abstract/property.h”
#include <>
#include <>
#include <>
#include “”
file edge_on_graph.h
#include “grenade/vx/genpybind.h”
#include “”
#include <>
#include <>
file empty_property.h
#include “grenade/vx/network/abstract/property.h”
#include <>
#include <>
#include <>
#include <>
file equality_comparable.h
#include “”
#include “”
file movable.h
#include “grenade/vx/genpybind.h”
#include “”
#include <>
file multicompartment_compartment.h
#include “grenade/vx/network/abstract/detail/graph.h”
#include “grenade/vx/network/abstract/detail/property_holder.h”
#include “grenade/vx/network/abstract/graph.h”
#include “grenade/vx/network/abstract/multicompartment_hardware_resource_with_constraint.h”
#include “grenade/vx/network/abstract/multicompartment_mechanism.h”
#include “grenade/vx/network/abstract/multicompartment_mechanism_on_compartment.h”
#include “grenade/vx/network/abstract/property.h”
#include <>
#include <>
#include <>
file multicompartment_compartment_connection.h
#include “grenade/vx/network/abstract/parameter_interval.h”
#include “grenade/vx/network/abstract/property.h”
file conductance.h
#include “grenade/vx/network/abstract/multicompartment_compartment_connection.h”
file conductance.h
#include “grenade/vx/network/abstract/multicompartment_synaptic_input_environment.h”
file multicompartment_compartment_connection_on_neuron.h
#include “grenade/vx/network/abstract/detail/graph.h”
#include “grenade/vx/network/abstract/edge_on_graph.h”
file multicompartment_compartment_on_neuron.h
#include “grenade/vx/network/abstract/detail/graph.h”
#include “grenade/vx/network/abstract/vertex_on_graph.h”
file multicompartment_environment.h
#include “grenade/vx/network/abstract/detail/property_holder.h”
#include “grenade/vx/network/abstract/multicompartment_compartment_on_neuron.h”
#include “grenade/vx/network/abstract/multicompartment_synaptic_input_environment.h”
#include <>
file multicompartment_hardware_constraint.h
#include “grenade/vx/network/abstract/multicompartment_hardware_resource.h”
#include “grenade/vx/network/abstract/multicompartment_top_bottom.h”
#include <>
#include <>
file multicompartment_hardware_resource.h
#include “grenade/vx/network/abstract/detail/property_holder.h”
#include “grenade/vx/network/abstract/empty_property.h”
#include “grenade/vx/network/abstract/property.h”
file capacitance.h
#include “grenade/vx/network/abstract/multicompartment_hardware_resource.h”
file capacitance.h
#include “grenade/vx/network/abstract/multicompartment_environment.h”
#include “grenade/vx/network/abstract/multicompartment_hardware_resource/capacitance.h”
#include “grenade/vx/network/abstract/multicompartment_hardware_resource_with_constraint.h”
#include “grenade/vx/network/abstract/multicompartment_mechanism.h”
#include “grenade/vx/network/abstract/parameter_interval.h”
#include <>
file synaptic_input_excitatory.h
#include “grenade/vx/network/abstract/multicompartment_hardware_resource.h”
file synaptic_input_inhibitory.h
#include “grenade/vx/network/abstract/multicompartment_hardware_resource.h”
file multicompartment_hardware_resource_with_constraint.h
#include “grenade/vx/network/abstract/detail/property_holder.h”
#include “grenade/vx/network/abstract/multicompartment_hardware_constraint.h”
#include “grenade/vx/network/abstract/multicompartment_hardware_resource.h”
#include <>
file multicompartment_mechanism.h
#include “grenade/vx/network/abstract/multicompartment_hardware_constraint.h”
#include “grenade/vx/network/abstract/multicompartment_hardware_resource.h”
#include “grenade/vx/network/abstract/property.h”
file synaptic_conductance.h
#include “grenade/vx/network/abstract/multicompartment_environment.h”
#include “grenade/vx/network/abstract/multicompartment_hardware_resource/synaptic_input_excitatory.h”
#include “grenade/vx/network/abstract/multicompartment_hardware_resource/synaptic_input_inhibitory.h”
#include “grenade/vx/network/abstract/multicompartment_hardware_resource_with_constraint.h”
#include “grenade/vx/network/abstract/multicompartment_mechanism.h”
#include “grenade/vx/network/abstract/multicompartment_synaptic_input_environment/conductance.h”
#include “grenade/vx/network/abstract/parameter_interval.h”
file synaptic_current.h
#include “grenade/vx/network/abstract/multicompartment_environment.h”
#include “grenade/vx/network/abstract/multicompartment_hardware_resource/synaptic_input_excitatory.h”
#include “grenade/vx/network/abstract/multicompartment_hardware_resource/synaptic_input_inhibitory.h”
#include “grenade/vx/network/abstract/multicompartment_hardware_resource_with_constraint.h”
#include “grenade/vx/network/abstract/multicompartment_mechanism.h”
#include “grenade/vx/network/abstract/multicompartment_synaptic_input_environment/current.h”
#include “grenade/vx/network/abstract/parameter_interval.h”
file multicompartment_mechanism_on_compartment.h
#include “”
file multicompartment_neuron.h
#include “grenade/vx/network/abstract/detail/graph.h”
#include “grenade/vx/network/abstract/graph.h”
#include “grenade/vx/network/abstract/multicompartment_compartment.h”
#include “grenade/vx/network/abstract/multicompartment_compartment_connection/conductance.h”
#include “grenade/vx/network/abstract/multicompartment_compartment_connection_on_neuron.h”
#include “grenade/vx/network/abstract/multicompartment_compartment_on_neuron.h”
#include <>
file multicompartment_resource_manager.h
#include “grenade/vx/network/abstract/detail/property_holder.h”
#include “grenade/vx/network/abstract/multicompartment_compartment_on_neuron.h”
#include “grenade/vx/network/abstract/multicompartment_environment.h”
#include “grenade/vx/network/abstract/multicompartment_hardware_resource/capacitance.h”
#include “grenade/vx/network/abstract/multicompartment_hardware_resource/synaptic_input_excitatory.h”
#include “grenade/vx/network/abstract/multicompartment_hardware_resource/synaptic_input_inhibitory.h”
#include “grenade/vx/network/abstract/multicompartment_neuron.h”
#include “grenade/vx/network/abstract/multicompartment_top_bottom.h”
#include <>
file multicompartment_synaptic_input_environment.h
#include “grenade/vx/network/abstract/multicompartment_top_bottom.h”
#include “grenade/vx/network/abstract/property.h”
#include <>
file current.h
#include “grenade/vx/network/abstract/multicompartment_synaptic_input_environment.h”
file multicompartment_top_bottom.h
#include “grenade/vx/network/abstract/property.h”
#include <>
#include <>
#include <>
file parameter_interval.h
#include <>
#include “”
file printable.h
#include “grenade/vx/genpybind.h”
#include “”
#include <>
file property.h
#include “grenade/vx/genpybind.h”
#include “grenade/vx/network/abstract/copyable.h”
#include “grenade/vx/network/abstract/equality_comparable.h”
#include “grenade/vx/network/abstract/movable.h”
#include “grenade/vx/network/abstract/printable.h”
file vertex_on_graph.h
#include “grenade/vx/genpybind.h”
#include “”
#include “”
#include <>
#include <>
#include <>
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 <>
#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/common/time.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 <>
#include “”
#include <>
file stopped.h
#include <>
file uninitialized.h
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 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_health_info.h
#include “grenade/vx/common/execution_instance_id.h”
#include “grenade/vx/genpybind.h”
#include “”
#include “”
#include “”
#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_health_info.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_ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE_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.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/network/abstract
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/execution/backend
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/common
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/compute
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/common/detail
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/compute/detail
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/execution/detail
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/network/abstract/detail
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/network/routing/greedy/detail
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/ppu/detail
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/signal_flow/detail
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/execution
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/execution/detail/generator
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/network/routing/greedy
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/network/abstract/multicompartment_compartment_connection
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/network/abstract/multicompartment_hardware_resource
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/network/abstract/multicompartment_mechanism
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/network/abstract/multicompartment_synaptic_input_environment
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/network
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/signal_flow/vertex/plasticity_rule
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/ppu
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/network/routing
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/signal_flow
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/network/vertex/transformation
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/signal_flow/vertex/transformation
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/network/vertex
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx/signal_flow/vertex
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTI4MTE.x/grenade/include/grenade/vx