API Reference: grenade

class grenade::vx::compute::Addition
#include <addition.h>

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

Public Functions

Addition() = default
Addition (std::vector< Int8 > const &other) SYMBOL_VISIBLE

Create single Addition compute graph wrapper.

Parameters

other – Value to add to given data.

size_t input_size () const SYMBOL_VISIBLE
size_t output_size () const SYMBOL_VISIBLE
std::vector< std::vector< Int8 > > run (std::vector< std::vector< Int8 >> const &inputs, lola::vx::v3::Chip const &config, JITGraphExecutor &executor) const SYMBOL_VISIBLE

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

Graph m_graph = {}
Graph::vertex_descriptor m_input_vertex = {}
std::vector<Int8> m_other = {}
Graph::vertex_descriptor m_other_vertex = {}
Graph::vertex_descriptor m_output_vertex = {}

Friends

friend class cereal::access
struct grenade::vx::vertex::Addition
#include <addition.h>

Addition of multiple inputs of Int8 data type.

Public Functions

Addition() = default
explicit  Addition (size_t size) SYMBOL_VISIBLE

Construct addition with specified size.

Parameters

size – Number of data values per input

std::array< Port, 1 > inputs () const SYMBOL_VISIBLE
bool operator!= (Addition const &other) const SYMBOL_VISIBLE
bool operator== (Addition const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static bool variadic_input   = true

Private Functions

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

Private Members

size_t m_size = {}

Friends

friend class cereal::access
friend std::ostream & operator<< (std::ostream &os, Addition const &config) SYMBOL_VISIBLE
struct grenade::vx::network::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) SYMBOL_VISIBLE
struct grenade::vx::network::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) SYMBOL_VISIBLE
struct grenade::vx::network::SynapseDriverOnPADIBusManager::AllocationPolicyBacktracking
#include <synapse_driver_on_padi_bus_manager.h>

Public Functions

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

Public Members

std::optional<std::chrono::milliseconds> max_duration
struct grenade::vx::network::SynapseDriverOnPADIBusManager::AllocationPolicyGreedy
#include <synapse_driver_on_padi_bus_manager.h>

Public Functions

AllocationPolicyGreedy (bool enable_exclusive_first=true) SYMBOL_VISIBLE

Public Members

bool enable_exclusive_first
struct grenade::vx::network::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 SYMBOL_VISIBLE
bool operator== (AllocationRequest const &other) const SYMBOL_VISIBLE
bool valid () const SYMBOL_VISIBLE

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) SYMBOL_VISIBLE
struct grenade::vx::network::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 SYMBOL_VISIBLE

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 SYMBOL_VISIBLE
bool operator== (AllocationRequest const &other) const SYMBOL_VISIBLE
size_t size () const SYMBOL_VISIBLE

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) SYMBOL_VISIBLE
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) SYMBOL_VISIBLE

Create single ArgMax compute graph wrapper.

Parameters

size – Size of operation.

size_t input_size () const SYMBOL_VISIBLE
size_t output_size () const SYMBOL_VISIBLE
std::vector< std::vector< UInt32 > > run (std::vector< std::vector< Int8 >> const &inputs, lola::vx::v3::Chip const &config, JITGraphExecutor &executor) const SYMBOL_VISIBLE

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

Graph m_graph
Graph::vertex_descriptor m_input_vertex = {}
Graph::vertex_descriptor m_output_vertex = {}

Friends

friend class cereal::access
struct grenade::vx::vertex::ArgMax
#include <argmax.h>

ArgMax of multiple inputs.

Public Functions

ArgMax() = default
explicit  ArgMax (size_t size, ConnectionType type) SYMBOL_VISIBLE

Construct operation with specified size.

Parameters

  • size – Number of data values

  • type – Type of data to compute argmax over

std::array< Port, 1 > inputs () const SYMBOL_VISIBLE
bool operator!= (ArgMax const &other) const SYMBOL_VISIBLE
bool operator== (ArgMax const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static bool variadic_input   = false

Private Functions

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

Private Members

size_t m_size = {}
ConnectionType m_type = {}

Friends

friend class cereal::access
friend std::ostream & operator<< (std::ostream &os, ArgMax const &config) SYMBOL_VISIBLE
struct grenade::vx::network::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 SYMBOL_VISIBLE
bool operator== (BackgroundConnection const &other) const SYMBOL_VISIBLE
halco::hicann_dls::vx::v3::PADIBusOnDLS toPADIBusOnDLS () const SYMBOL_VISIBLE

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

Public Members

std::pair<ProjectionDescriptor, size_t> descriptor

Descriptor of connection in abstract network.

Projection::ReceptorType 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::SourceOnPADIBusManager::BackgroundSource
#include <source_on_padi_bus_manager.h>

Properties of a background source.

Public Members

std::map<Projection::ReceptorType, 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::vertex::BackgroundSpikeSource
#include <background_spike_source.h>

Background event source to the Crossbar.

Public Types

typedef haldls::vx::BackgroundSpikeSource Config
typedef halco::hicann_dls::vx::BackgroundSpikeSourceOnDLS Coordinate

Public Functions

BackgroundSpikeSource() = default
BackgroundSpikeSource (Config const &config, Coordinate const &coordinate) SYMBOL_VISIBLE

Construct BackgroundSpikeSource.

Parameters

  • config – Config to use

  • coordinate – Coordinate to use

Config const  & get_config () const SYMBOL_VISIBLE
Coordinate const  & get_coordinate () const SYMBOL_VISIBLE
inline constexpr std::array<Port, 0> inputs() const
bool operator!= (BackgroundSpikeSource const &other) const SYMBOL_VISIBLE
bool operator== (BackgroundSpikeSource const &other) const SYMBOL_VISIBLE
inline constexpr Port output() const

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static 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 class cereal::access
friend std::ostream & operator<< (std::ostream &os, BackgroundSpikeSource const &config) SYMBOL_VISIBLE
struct grenade::vx::network::BackgroundSpikeSourcePopulation
#include <population.h>

BackgroundSpikeSource spike source population.

Public Types

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

Placement of the source.

Public Functions

BackgroundSpikeSourcePopulation() = default
BackgroundSpikeSourcePopulation (size_t size, Coordinate const &coordinate, Config const &config) SYMBOL_VISIBLE
bool operator!= (BackgroundSpikeSourcePopulation const &other) const SYMBOL_VISIBLE
bool operator== (BackgroundSpikeSourcePopulation const &other) const SYMBOL_VISIBLE

Public Members

struct grenade::vx::network::BackgroundSpikeSourcePopulation::Config config
Coordinate coordinate
size_t size = {0}

Number of individual sources.

Friends

friend std::ostream & operator<< (std::ostream &os, BackgroundSpikeSourcePopulation const &population) SYMBOL_VISIBLE
struct grenade::vx::ExecutionInstanceBuilder::BatchEntry

Public Types

typedef std::optional<stadls::vx::v3::PlaybackProgram::ContainerTicket<haldls::vx::v3::NullPayloadReadable>> event_guard_ticket_type
typedef halco::common::typed_array<std::optional<stadls::vx::v3::PlaybackProgram::ContainerTicket<lola::vx::v3::ExternalPPUMemoryBlock>>, halco::hicann_dls::vx::PPUOnDLS> ticket_extmem_type
typedef halco::common::typed_array<std::optional<stadls::vx::v3::PlaybackProgram::ContainerTicket<haldls::vx::v3::PPUMemoryBlock>>, halco::hicann_dls::vx::PPUOnDLS> ticket_ppu_type

Public Members

ticket_extmem_type m_extmem_result
ticket_ppu_type m_ppu_mailbox
ticket_ppu_type 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
struct grenade::vx::generator::BlockingPPUCommand
#include <ppu.h>

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

Public Types

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

Public Functions

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

Construct blocking PPU command.

Parameters

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

  • status – Command to place

Protected Functions

stadls::vx::v3::PlaybackGeneratorReturn< Result > generate () const SYMBOL_VISIBLE

Private Members

halco::hicann_dls::vx::v3::PPUMemoryWordOnPPU m_coord
grenade::vx::ppu::Status m_status

Friends

friend auto generate(BlockingPPUCommand const&)
struct grenade::vx::CachingCompiler : public grenade::vx::Compiler
#include <ppu.h>

Compiler with global cache of compiled programs.

Public Functions

std::pair< lola::vx::v3::PPUElfFile::symbols_type, haldls::vx::v3::PPUMemoryBlock > compile (std::vector< std::string > sources) SYMBOL_VISIBLE

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

Public Members

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

Public Static Attributes

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

Private Static Functions

static ProgramCache &get_program_cache()
struct grenade::vx::vertex::CADCMembraneReadoutView
#include <cadc_membrane_readout_view.h>

Readout of membrane voltages via the CADC.

Public Types

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 Mode

Values:

enumerator hagen
enumerator periodic
typedef halco::hicann_dls::vx::v3::SynramOnDLS Synram

Public Functions

CADCMembraneReadoutView() = default
template<typename ColumnsT, typename SynramT>
explicit CADCMembraneReadoutView(ColumnsT &&columns, SynramT &&synram, Mode const &mode)

Construct CADCMembraneReadoutView with specified size.

Parameters

columns – Columns to read out

Columns const  & get_columns () const SYMBOL_VISIBLE
Mode const  & get_mode () const SYMBOL_VISIBLE
Synram const  & get_synram () const SYMBOL_VISIBLE
std::vector< Port > inputs () const SYMBOL_VISIBLE
bool operator!= (CADCMembraneReadoutView const &other) const SYMBOL_VISIBLE
bool operator== (CADCMembraneReadoutView const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE
bool supports_input_from (NeuronView const &input, std::optional< PortRestriction > const &restriction) const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static bool variadic_input   = false

Private Functions

void check (Columns const &columns) SYMBOL_VISIBLE
template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Columns m_columns = {}
Mode m_mode = {}
Synram m_synram = {}

Friends

friend class cereal::access
friend std::ostream & operator<< (std::ostream &os, CADCMembraneReadoutView const &config) SYMBOL_VISIBLE
struct grenade::vx::network::CADCRecording
#include <cadc_recording.h>

CADC recording of a collection of neurons.

Public Functions

CADCRecording() = default
CADCRecording (std::vector< Neuron > const &neurons) SYMBOL_VISIBLE
bool operator!= (CADCRecording const &other) const SYMBOL_VISIBLE
bool operator== (CADCRecording const &other) const SYMBOL_VISIBLE

Public Members

std::vector<Neuron> neurons = {}
template<typename VertexVariant>
struct CheckVertexConcept
template<typename ...Vertex>
struct grenade::vx::detail::CheckVertexConcept<std::variant<Vertex...>> : public grenade::vx::VertexConcept<Vertex>
#include <vertex_concept.h>

Public Static Attributes

template<typename V> static constexpr static bool has_can_connect_different_execution_instances_v   =     has_can_connect_different_execution_instances<V>::value
template<typename V> static constexpr static bool has_inputs_v   = has_inputs<V>::value
template<typename V> static constexpr static bool has_output_v   = has_output<V>::value
template<typename V> static constexpr static bool has_variadic_input_v   = has_variadic_input<V>::value
struct grenade::vx::Compiler
#include <ppu.h>

Compiler for PPU programs.

Subclassed by grenade::vx::CachingCompiler

Public Functions

Compiler () SYMBOL_VISIBLE
std::pair< lola::vx::v3::PPUElfFile::symbols_type, haldls::vx::v3::PPUMemoryBlock > compile (std::vector< std::string > sources) SYMBOL_VISIBLE

Compile sources into target program.

Public Members

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

Public Static Attributes

static constexpr auto name = "powerpc-ppu-g++"
struct grenade::vx::transformation::Concatenation : public grenade::vx::vertex::Transformation::Function
#include <concatenation.h>

Public Types

typedef IODataMap::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 bool equal(vertex::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 class cereal::access
struct grenade::vx::network::BackgroundSpikeSourcePopulation::Config
#include <population.h>

Configuration of the source.

Public Functions

bool operator!= (Config const &other) const SYMBOL_VISIBLE
bool operator== (Config const &other) const SYMBOL_VISIBLE

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) SYMBOL_VISIBLE
struct grenade::vx::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 SYMBOL_VISIBLE
bool operator== (Config const &other) const SYMBOL_VISIBLE

Public Members

bool enable_reset
std::optional<Label> label

Private Functions

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

Friends

friend class cereal::access
struct grenade::vx::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 SYMBOL_VISIBLE
bool operator== (Config const &other) const SYMBOL_VISIBLE

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 class cereal::access
struct grenade::vx::backend::Connection
#include <connection.h>

Connection to hardware/simulation ensuring proper initialisation.

Public Types

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

Accepted initialization generators.

Public Functions

Connection () SYMBOL_VISIBLE
Connection (hxcomm::vx::ConnectionVariant &&connection) SYMBOL_VISIBLE
Connection (hxcomm::vx::ConnectionVariant &&connection, Init const &init) SYMBOL_VISIBLE
stadls::vx::v3::ReinitStackEntry create_reinit_stack_entry () SYMBOL_VISIBLE
std::string get_bitfile_info () const SYMBOL_VISIBLE
hxcomm::ConnectionTimeInfo get_time_info () const SYMBOL_VISIBLE
std::string get_unique_identifier (std::optional< std::string > const &hwdb_path) const SYMBOL_VISIBLE
bool is_quiggeldy () const SYMBOL_VISIBLE
hxcomm::vx::ConnectionVariant && release () SYMBOL_VISIBLE

Public Static Attributes

static constexpr char name[] = "Connection"

Private Members

hxcomm::vx::ConnectionVariant m_connection
size_t m_expected_link_notification_count
stadls::vx::v3::ReinitStackEntry m_init

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::network::Projection::Connection
#include <projection.h>

Single neuron connection.

Public Types

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

Public Functions

Connection() = default
Connection (size_t index_pre, size_t index_post, Weight weight) SYMBOL_VISIBLE
bool operator!= (Connection const &other) const SYMBOL_VISIBLE
bool operator== (Connection const &other) const SYMBOL_VISIBLE

Public Members

size_t index_post

Index of neuron in post-synaptic population.

size_t 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) SYMBOL_VISIBLE
struct grenade::vx::ConnectionStateStorage
#include <connection_state_storage.h>

Public Members

lola::vx::v3::Chip current_config
std::vector<fisch::vx::word_access_type::Omnibus> current_config_words
bool enable_differential_config
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
struct grenade::vx::network::ConnectumConnection
#include <connectum.h>

Public Types

typedef std::pair<PopulationDescriptor, size_t> Source

Public Functions

bool operator!= (ConnectumConnection const &other) const SYMBOL_VISIBLE
bool operator== (ConnectumConnection const &other) const SYMBOL_VISIBLE

Public Members

Projection::ReceptorType receptor_type
Source source
halco::hicann_dls::vx::v3::AtomicNeuronOnDLS target
Projection::Connection::Weight weight

Friends

friend std::ostream & operator<< (std::ostream &os, ConnectumConnection const &config) SYMBOL_VISIBLE
struct grenade::vx::ConstantReferenceIODataMap
#include <io_data_map.h>

Data map of constant references to data used for external data input in graph execution.

For each type of data a separate member allows access.

Public Types

typedef IODataMap::Entry Entry

Public Functions

ConstantReferenceIODataMap () SYMBOL_VISIBLE
void clear () SYMBOL_VISIBLE

Clear content of map.

Public Members

std::map<detail::vertex_descriptor, Entry const&> data

Data is connected to specified vertex descriptors.

Batch-support is enabled by storing batch-size many data elements aside each-other.

std::unordered_map<coordinate::ExecutionInstance, std::vector<haldls::vx::v3::Timer::Value>> runtime

Runtime data.

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<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, haldls::vx::v3::Timer::Value wait_between_events = haldls::vx::v3::Timer::Value(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 SYMBOL_VISIBLE
size_t output_size () const SYMBOL_VISIBLE
std::vector< std::vector< Int8 > > run (Activations const &inputs, lola::vx::v3::Chip const &config, JITGraphExecutor &executor) const SYMBOL_VISIBLE

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) SYMBOL_VISIBLE
template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

bool m_enable_loopback = {false}
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 = {}
haldls::vx::v3::Timer::Value m_wait_between_events = {}

Friends

friend class cereal::access
class grenade::vx::compute::ConvertingReLU
#include <converting_relu.h>

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

Public Functions

ConvertingReLU() = default
ConvertingReLU (size_t size, uint32_t shift) SYMBOL_VISIBLE

Create single ConvertingReLU compute graph wrapper.

Parameters

  • size – Size of operation

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

size_t input_size () const SYMBOL_VISIBLE
size_t output_size () const SYMBOL_VISIBLE
std::vector< std::vector< UInt5 > > run (std::vector< std::vector< Int8 >> const &inputs, lola::vx::v3::Chip const &config, JITGraphExecutor &executor) const SYMBOL_VISIBLE

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

Graph m_graph = {}
Graph::vertex_descriptor m_input_vertex = {}
Graph::vertex_descriptor m_output_vertex = {}

Friends

friend class cereal::access
struct grenade::vx::vertex::ConvertingReLU
#include <converting_relu.h>

ConvertingReLU of multiple inputs from Int8 to UInt5.

Public Functions

ConvertingReLU() = default
explicit  ConvertingReLU (size_t size, uint32_t shift) SYMBOL_VISIBLE

Construct operation with specified size and configuration.

Parameters

  • size – Number of data values per input

  • shift – Number of bits to shift after relu before clamping

uint32_t get_shift () const SYMBOL_VISIBLE
std::array< Port, 1 > inputs () const SYMBOL_VISIBLE
bool operator!= (ConvertingReLU const &other) const SYMBOL_VISIBLE
bool operator== (ConvertingReLU const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static bool variadic_input   = false

Private Functions

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

Private Members

uint32_t m_shift = {}
size_t m_size = {}

Friends

friend class cereal::access
friend std::ostream & operator<< (std::ostream &os, ConvertingReLU const &config) SYMBOL_VISIBLE
struct grenade::vx::vertex::CrossbarL2Input
#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 Functions

CrossbarL2Input() = default

Construct CrossbarL2Input.

inline constexpr std::array<Port, 1> inputs() const
bool operator!= (CrossbarL2Input const &other) const SYMBOL_VISIBLE
bool operator== (CrossbarL2Input const &other) const SYMBOL_VISIBLE
inline constexpr Port output() const

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static bool variadic_input   = false

Private Functions

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

Friends

friend class cereal::access
friend std::ostream & operator<< (std::ostream &os, CrossbarL2Input const &config) SYMBOL_VISIBLE
struct grenade::vx::vertex::CrossbarL2Output
#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 Functions

inline CrossbarL2Output()

Construct CrossbarL2Output.

inline constexpr std::array<Port, 1> inputs() const
bool operator!= (CrossbarL2Output const &other) const SYMBOL_VISIBLE
bool operator== (CrossbarL2Output const &other) const SYMBOL_VISIBLE
inline constexpr Port output() const
bool supports_input_from (CrossbarNode const &input, std::optional< PortRestriction > const &restriction) const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static bool variadic_input   = true

Private Functions

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

Friends

friend class cereal::access
friend std::ostream & operator<< (std::ostream &os, CrossbarL2Output const &config) SYMBOL_VISIBLE
struct grenade::vx::vertex::CrossbarNode
#include <crossbar_node.h>

Crossbar node.

Public Types

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) SYMBOL_VISIBLE

Construct node at specified location with specified configuration.

Parameters

  • coordinate – Location

  • config – Configuration

Config const  & get_config () const SYMBOL_VISIBLE
Coordinate const  & get_coordinate () const SYMBOL_VISIBLE
inline constexpr std::array<Port, 1> inputs() const
bool operator!= (CrossbarNode const &other) const SYMBOL_VISIBLE
bool operator== (CrossbarNode const &other) const SYMBOL_VISIBLE
inline constexpr Port output() const
bool supports_input_from (BackgroundSpikeSource const &input, std::optional< PortRestriction > const &restriction) const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static 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 class cereal::access
friend std::ostream & operator<< (std::ostream &os, CrossbarNode const &config) SYMBOL_VISIBLE
struct grenade::vx::vertex::DataInput
#include <data_input.h>

Formatted data input from memory.

Public Functions

DataInput() = default
explicit  DataInput (ConnectionType output_type, size_t size) SYMBOL_VISIBLE

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 SYMBOL_VISIBLE
bool operator!= (DataInput const &other) const SYMBOL_VISIBLE
bool operator== (DataInput const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = true
static constexpr static 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 class cereal::access
friend std::ostream & operator<< (std::ostream &os, DataInput const &config) SYMBOL_VISIBLE
struct grenade::vx::vertex::DataOutput
#include <data_output.h>

Formatted data output to memory.

Public Functions

DataOutput() = default
explicit  DataOutput (ConnectionType input_type, size_t size) SYMBOL_VISIBLE

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 SYMBOL_VISIBLE
bool operator!= (DataOutput const &other) const SYMBOL_VISIBLE
bool operator== (DataOutput const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = true
static constexpr static 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 class cereal::access
friend std::ostream & operator<< (std::ostream &os, DataOutput const &config) SYMBOL_VISIBLE
struct grenade::vx::network::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::coordinate::ExecutionIndex : public halco::common::detail::BaseType<ExecutionIndex, size_t>
#include <execution_instance.h>

Unique temporal identifier for a execution instance.

ExecutionIndex separates execution where a memory barrier is needed for data movement completion. No guarantees are made on execution order TODO: move to halco? Is this a hardware abstraction layer coordinate?

Public Functions

inline explicit constexpr ExecutionIndex(value_type const value = 0)
struct grenade::vx::coordinate::ExecutionInstance
#include <execution_instance.h>

Execution instance identifier.

An execution instance describes a unique physically placed isolated execution. It is placed physically on a global DLS instance.

Public Functions

ExecutionInstance() = default
explicit  ExecutionInstance (ExecutionIndex execution_index, halco::hicann_dls::vx::v3::DLSGlobal dls) SYMBOL_VISIBLE
size_t hash () const SYMBOL_VISIBLE
bool operator!= (ExecutionInstance const &other) const SYMBOL_VISIBLE
bool operator== (ExecutionInstance const &other) const SYMBOL_VISIBLE
halco::hicann_dls::vx::v3::DLSGlobal toDLSGlobal () const SYMBOL_VISIBLE
ExecutionIndex toExecutionIndex () const SYMBOL_VISIBLE

Private Functions

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

Private Members

halco::hicann_dls::vx::v3::DLSGlobal m_dls_global
ExecutionIndex m_execution_index

Friends

friend class cereal::access
friend size_t hash_value (ExecutionInstance const &e) SYMBOL_VISIBLE
friend std::ostream & operator<< (std::ostream &os, ExecutionInstance const &instance) SYMBOL_VISIBLE
class grenade::vx::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 (Graph const &graph, coordinate::ExecutionInstance const &execution_instance, IODataMap const &input_list, IODataMap const &data_output, std::optional< lola::vx::v3::PPUElfFile::symbols_type > const &ppu_symbols, ExecutionInstancePlaybackHooks &playback_hooks) SYMBOL_VISIBLE

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

  • playback_hooks – Playback sequences to inject

PlaybackPrograms generate () SYMBOL_VISIBLE

Generate playback sequence.

Returns

PlaybackPrograms generated via local graph traversal

IODataMap post_process () SYMBOL_VISIBLE

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

IODataMap of locally computed results

void post_process (Graph::vertex_descriptor const vertex) SYMBOL_VISIBLE
void pre_process () SYMBOL_VISIBLE

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 (Graph::vertex_descriptor const descriptor) const SYMBOL_VISIBLE

Check if any incoming vertex requires post processing.

Parameters

descriptor – Vertex descriptor to check for

Returns

Boolean value

template<typename Vertex>
void process(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<vertex::CADCMembraneReadoutView::Mode> m_cadc_readout_mode
std::vector<stadls::vx::v3::PlaybackProgram> m_chunked_program
IODataMap const &m_data_output
std::optional<Graph::vertex_descriptor> m_event_input_vertex
std::optional<Graph::vertex_descriptor> m_event_output_vertex
coordinate::ExecutionInstance m_execution_instance
Graph const &m_graph
bool m_has_plasticity_rule = {false}
IODataMap const &m_input_list
IODataMap m_local_data
IODataMap m_local_data_output
ConstantReferenceIODataMap m_local_external_data
std::optional<Graph::vertex_descriptor> m_madc_readout_vertex
generator::NeuronResetMask m_neuron_resets
ExecutionInstancePlaybackHooks &m_playback_hooks
std::vector<Graph::vertex_descriptor> m_post_vertices
bool m_postprocessing
std::optional<lola::vx::v3::PPUElfFile::symbols_type> m_ppu_symbols
ticket_request_type m_ticket_requests
class grenade::vx::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 (Graph const &graph, coordinate::ExecutionInstance const &execution_instance, lola::vx::v3::Chip &config) SYMBOL_VISIBLE

Construct visitor.

Parameters

  • graph – Graph to use for locality and property lookup

  • execution_instance – Local execution instance to visit

  • config – Configuration to alter

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

Perform visit operation and generate initial configuration.

Returns

Reference to altered chip object and optional PPU program symbols

Private Functions

void pre_process () SYMBOL_VISIBLE

Preprocess by single visit of all local vertices.

template<typename Vertex>
void process(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
coordinate::ExecutionInstance m_execution_instance
Graph const &m_graph
std::vector<std::tuple<vertex::PlasticityRule, std::vector<std::pair<halco::hicann_dls::vx::v3::SynramOnDLS, ppu::SynapseArrayViewHandle>>>> m_plasticity_rules
bool m_requires_ppu
bool m_used_madc
struct grenade::vx::ExecutionInstanceNode
#include <execution_instance_node.h>

Content of a execution node.

On invokation 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 (IODataMap &data_map, IODataMap const &input_data_map, Graph const &graph, coordinate::ExecutionInstance const &execution_instance, lola::vx::v3::Chip const &initial_config, backend::Connection &connection, ConnectionStateStorage &connection_state_storage, std::mutex &connection_mutex, ExecutionInstancePlaybackHooks &playback_hooks) SYMBOL_VISIBLE
void operator() (tbb::flow::continue_msg) SYMBOL_VISIBLE

Private Members

backend::Connection &connection
std::mutex &connection_mutex
ConnectionStateStorage &connection_state_storage
IODataMap &data_map
coordinate::ExecutionInstance execution_instance
Graph const &graph
lola::vx::v3::Chip const &initial_config
IODataMap const &input_data_map
log4cxx::Logger *logger
ExecutionInstancePlaybackHooks &playback_hooks
struct grenade::vx::ExecutionInstancePlaybackHooks
#include <execution_instance_playback_hooks.h>

Playback program hooks for an execution instance.

Public Functions

ExecutionInstancePlaybackHooks() = default
ExecutionInstancePlaybackHooks(ExecutionInstancePlaybackHooks&&) = default
ExecutionInstancePlaybackHooks(ExecutionInstancePlaybackHooks const&) = delete
ExecutionInstancePlaybackHooks (stadls::vx::v3::PlaybackProgramBuilder &pre_static_config, stadls::vx::v3::PlaybackProgramBuilder &pre_realtime, stadls::vx::v3::PlaybackProgramBuilder &post_realtime) SYMBOL_VISIBLE
ExecutionInstancePlaybackHooks &operator=(ExecutionInstancePlaybackHooks&&) = default
ExecutionInstancePlaybackHooks &operator=(ExecutionInstancePlaybackHooks const&) = delete

Public Members

stadls::vx::v3::PlaybackProgramBuilder post_realtime
stadls::vx::v3::PlaybackProgramBuilder pre_realtime
stadls::vx::v3::PlaybackProgramBuilder pre_static_config
struct grenade::vx::network::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 SYMBOL_VISIBLE
bool operator== (ExternalConnection const &other) const SYMBOL_VISIBLE
halco::hicann_dls::vx::v3::PADIBusBlockOnDLS toPADIBusBlockOnDLS () const SYMBOL_VISIBLE

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

Public Members

std::pair<ProjectionDescriptor, size_t> descriptor

Descriptor of connection in abstract network.

Projection::ReceptorType receptor_type

Receptor type of connection.

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

Target neuron.

struct grenade::vx::vertex::ExternalInput
#include <external_input.h>

External input data source.

Public Functions

ExternalInput() = default
explicit  ExternalInput (ConnectionType output_type, size_t size) SYMBOL_VISIBLE

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 SYMBOL_VISIBLE
bool operator== (ExternalInput const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static 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 class cereal::access
friend std::ostream & operator<< (std::ostream &os, ExternalInput const &config) SYMBOL_VISIBLE
struct grenade::vx::network::ExternalPopulation
#include <population.h>

External spike source population.

Public Functions

ExternalPopulation() = default
ExternalPopulation (size_t size) SYMBOL_VISIBLE
bool operator!= (ExternalPopulation const &other) const SYMBOL_VISIBLE
bool operator== (ExternalPopulation const &other) const SYMBOL_VISIBLE

Public Members

size_t size = {0}

Number of individual sources.

Friends

friend std::ostream & operator<< (std::ostream &os, ExternalPopulation const &population) SYMBOL_VISIBLE
struct grenade::vx::network::SourceOnPADIBusManager::ExternalSource
#include <source_on_padi_bus_manager.h>

Properties of an external source.

Public Members

std::map<Projection::ReceptorType, halco::common::typed_array<size_t, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS>> out_degree

Number of required synapses per atomic neuron.

struct grenade::vx::vertex::Transformation::Function
#include <transformation.h>

Function base for transforming a single input value to a single output value.

Subclassed by grenade::vx::transformation::Concatenation, grenade::vx::transformation::MACSpikeTrainGenerator

Public Types

typedef IODataMap::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 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

class grenade::vx::Graph
#include <graph.h>

Placed computation graph.

A vertex represent 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::unordered_map<edge_descriptor, std::optional<PortRestriction>> edge_property_map_type
typedef boost::bimap<vertex_descriptor, boost::bimaps::unordered_set_of<coordinate::ExecutionInstance>> execution_instance_map_type
typedef detail::graph_type graph_type
typedef std::map<coordinate::ExecutionIndex, std::map<halco::hicann_dls::vx::v3::DLSGlobal, std::vector<Graph::vertex_descriptor>>> ordered_vertices_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
typedef std::vector<std::shared_ptr<Vertex>> vertex_property_map_type

Public Functions

Graph (bool enable_acyclicity_check=true) SYMBOL_VISIBLE

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 &&) SYMBOL_VISIBLE
Graph (Graph const &) SYMBOL_VISIBLE
vertex_descriptor add (vertex_descriptor vertex_reference, coordinate::ExecutionInstance execution_instance, std::vector< Input > inputs) SYMBOL_VISIBLE

Add vertex by reference on specified execution instance with specified inputs.

This is to be used to update input relations. TODO: Do we want this and thereby have a separate resource manager? 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, coordinate::ExecutionInstance 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: Do we want this and thereby have a separate resource manager? 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 SYMBOL_VISIBLE

Get constant reference to edge property map.

Returns

Constant reference to edge property map

graph_type const  & get_execution_instance_graph () const SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

Get constant reference to vertex property map.

Returns

Constant reference to vertex property map

graph_type const  & get_graph () const SYMBOL_VISIBLE

Get constant reference to underlying graph.

Returns

Constant reference to underlying graph

vertex_descriptor_map_type const  & get_vertex_descriptor_map () const SYMBOL_VISIBLE

Get constant reference to vertex descriptor map.

Returns

Constant reference to vertex descriptor map

Vertex const  & get_vertex_property (vertex_descriptor descriptor) const SYMBOL_VISIBLE

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 SYMBOL_VISIBLE
Graph & operator= (Graph &&) SYMBOL_VISIBLE
Graph & operator= (Graph const &) SYMBOL_VISIBLE
bool operator== (Graph const &other) const SYMBOL_VISIBLE
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, coordinate::ExecutionInstance const &execution_instance, std::vector< Input > const &inputs) SYMBOL_VISIBLE
void add_log (vertex_descriptor descriptor, coordinate::ExecutionInstance const &execution_instance, hate::Timer const &timer) SYMBOL_VISIBLE
template<typename Vertex, typename InputVertex>
void check_execution_instances(Vertex const &vertex, InputVertex const &input_vertex, coordinate::ExecutionInstance const &vertex_execution_instance, coordinate::ExecutionInstance const &input_vertex_execution_instance)
void check_inputs (Vertex const &vertex, coordinate::ExecutionInstance const &execution_instance, std::vector< Input > const &inputs) SYMBOL_VISIBLE
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) SYMBOL_VISIBLE
void update_and_relocate (vertex_descriptor vertex_reference, Vertex &&vertex, std::vector< Input > inputs) SYMBOL_VISIBLE

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::Logger *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 class cereal::access
friend std::ostream & operator<< (std::ostream &os, Graph const &graph) SYMBOL_VISIBLE
struct grenade::vx::network::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 SYMBOL_VISIBLE

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) SYMBOL_VISIBLE
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::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 static 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::VertexConcept::has_inputs<V, std::void_t<decltype(&V::inputs)>>
#include <vertex_concept.h>

Public Static Attributes

static constexpr static bool value   =       detail::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::VertexConcept::has_output<V, std::void_t<decltype(&V::output)>>
#include <vertex_concept.h>

Public Static Attributes

static constexpr static 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::VertexConcept::has_variadic_input<V, std::void_t<decltype(&V::variadic_input)>>
#include <vertex_concept.h>

Public Static Attributes

static constexpr static bool value   = std::is_same_v<decltype(V::variadic_input), bool const>
template<>
struct std::hash<grenade::vx::coordinate::ExecutionInstance>
#include <execution_instance.h>

Public Functions

inline size_t operator()(grenade::vx::coordinate::ExecutionInstance const &t) const
template<>
struct std::hash<grenade::vx::detail::graph_type::edge_descriptor>
#include <graph_representation.h>

Public Functions

inline size_t operator()(grenade::vx::detail::graph_type::edge_descriptor const &e) const
struct grenade::vx::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 SYMBOL_VISIBLE
bool operator== (Input const &other) const SYMBOL_VISIBLE

Public Members

descriptor_type descriptor
std::optional<PortRestriction> port_restriction

Friends

friend std::ostream & operator<< (std::ostream &os, Input const &data) SYMBOL_VISIBLE
class grenade::vx::network::InputGenerator
#include <generate_input.h>

Public Functions

InputGenerator (NetworkGraph const &network_graph, size_t batch_size=1) SYMBOL_VISIBLE
void add (std::vector< std::vector< std::vector< TimedSpike::Time >>> const &times, PopulationDescriptor population) SYMBOL_VISIBLE
void add (std::vector< std::vector< TimedSpike::Time >> const &times, PopulationDescriptor population) SYMBOL_VISIBLE
void add (std::vector< TimedSpike::Time > const &times, PopulationDescriptor population) SYMBOL_VISIBLE
parent def ("add", [convert_ms](GENPYBIND_PARENT_TYPE &self, std::vector< float > const &times, grenade::vx::network::PopulationDescriptor const population) { std::vector< grenade::vx::TimedSpike::Time > gtimes;gtimes.reserve(times.size());std::transform(times.begin(), times.end(), std::back_inserter(gtimes), convert_ms);self.add(gtimes, population);}, parent->py::arg("times"), parent->py::arg("population"))
parent def ("add", [convert_ms](GENPYBIND_PARENT_TYPE &self, std::vector< std::vector< float >> const &times, grenade::vx::network::PopulationDescriptor const population) { std::vector< std::vector< grenade::vx::TimedSpike::Time >> gtimes;gtimes.resize(times.size());for(size_t i=0;auto &gt :gtimes) { gt.reserve(times.at(i).size());i++;} for(size_t i=0;auto &t :times) { std::transform(t.begin(), t.end(), std::back_inserter(gtimes.at(i)), convert_ms);i++;} self.add(gtimes, population);}, parent->py::arg("times"), parent->py::arg("population"))
parent def ("add", [convert_ms](GENPYBIND_PARENT_TYPE &self, std::vector< std::vector< std::vector< float >>> const &times, grenade::vx::network::PopulationDescriptor const population) { std::vector< std::vector< std::vector< grenade::vx::TimedSpike::Time >>> gtimes;gtimes.resize(times.size());for(size_t b=0;auto &gt_b :gtimes) { gt_b.resize(times.at(b).size());for(size_t i=0;auto &gt :gt_b) { gt.reserve(times.at(b).at(i).size());i++;} for(size_t i=0;auto &t :times.at(b)) { std::transform(t.begin(), t.end(), std::back_inserter(gtimes.at(b).at(i)), convert_ms);i++;} b++;} self.add(gtimes, population);}, parent->py::arg("times"), parent->py::arg("population"))
struct grenade::vx::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::network::RoutingConstraints::InternalConnection
#include <routing_constraints.h>

Synaptic connection between a pair of on-chip neurons.

Public Functions

bool operator!= (InternalConnection const &other) const SYMBOL_VISIBLE
bool operator== (InternalConnection const &other) const SYMBOL_VISIBLE
halco::hicann_dls::vx::v3::PADIBusOnDLS toPADIBusOnDLS () const SYMBOL_VISIBLE

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

Public Members

std::pair<ProjectionDescriptor, size_t> descriptor

Descriptor of connection in abstract network.

Projection::ReceptorType 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::SourceOnPADIBusManager::InternalSource
#include <source_on_padi_bus_manager.h>

Properties of an internal source.

Public Functions

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

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<Projection::ReceptorType, halco::common::typed_array<size_t, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS>> out_degree

Number of required synapses per atomic neuron.

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::IODataList
#include <io_data_list.h>

Flat data list used for external data exchange in graph execution.

Entries are assumed to be in order with the occurence of ExternalInput vertices in the corresponding graph (via boost::vertices()).

Public Types

typedef IODataMap::Entry Entry

Public Functions

IODataList() = default
void from_input_map (IODataMap const &map, Graph const &graph) SYMBOL_VISIBLE

Convert to data list from data map with regard to the input vertices of the graph.

Parameters

  • map – Map to convert

  • graph – Graph to use as reference for vertices

void from_output_map (IODataMap const &map, Graph const &graph, bool only_unconnected=true) SYMBOL_VISIBLE

Convert to data list from data map with regard to the output vertices of the graph.

Parameters

  • map – Map to convert

  • graph – Graph to use as reference for vertices

  • only_unconnected – Whether to convert only output vertices without out edges

IODataMap to_input_map (Graph const &graph) const SYMBOL_VISIBLE

Convert from data list to data map with regard to the input vertices of the graph.

Parameters

graph – Graph to use as reference for vertices

Returns

Converted Map

IODataMap to_output_map (Graph const &graph, bool only_unconnected=true) const SYMBOL_VISIBLE

Convert from data list to data map with regard to the output vertices of the graph.

Parameters

  • graph – Graph to use as reference for vertices

  • only_unconnected – Whether to convert only output vertices without out edges

Returns

Converted Map

Public Members

std::list<Entry> data = {}

List of data entries.

struct grenade::vx::IODataMap
#include <io_data_map.h>

Data map used for external data exchange in graph execution.

For each type of data a separate member allows access.

Public Types

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

Public Functions

IODataMap () SYMBOL_VISIBLE
IODataMap (IODataMap &&other) SYMBOL_VISIBLE
IODataMap(IODataMap const&) = delete
size_t batch_size () const SYMBOL_VISIBLE

Get number of elements in each batch of data.

Returns

Number of elements in batch

void clear () SYMBOL_VISIBLE

Clear content of map.

bool empty () const SYMBOL_VISIBLE

Get whether the map does not contain any elements.

Returns

Boolean value

void merge (IODataMap &&other) SYMBOL_VISIBLE

Merge other map content into this one’s.

Parameters

other – Other map to merge into this instance

void merge (IODataMap &other) SYMBOL_VISIBLE

Merge other map content into this one’s.

Parameters

other – Other map to merge into this instance

IODataMap & operator= (IODataMap &&other) SYMBOL_VISIBLE
bool valid () const SYMBOL_VISIBLE

Check that all map entries feature the same batch_size value.

Returns

Boolean value

Public Members

std::map<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.

std::unordered_map<coordinate::ExecutionInstance, std::vector<haldls::vx::v3::Timer::Value>> 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, Port const &port) SYMBOL_VISIBLE

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.

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>
class grenade::vx::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::unordered_map<coordinate::ExecutionInstance, lola::vx::v3::Chip> ChipConfigs
typedef std::tuple<bool> init_parameters_type
typedef std::unordered_map<coordinate::ExecutionInstance, ExecutionInstancePlaybackHooks> PlaybackHooks

Public Functions

JITGraphExecutor (bool enable_differential_config=true) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

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 SYMBOL_VISIBLE
std::map< halco::hicann_dls::vx::v3::DLSGlobal, hxcomm::ConnectionTimeInfo > get_time_info () const SYMBOL_VISIBLE
std::map< halco::hicann_dls::vx::v3::DLSGlobal, std::string > get_unique_identifier (std::optional< std::string > const &hwdb_path) const SYMBOL_VISIBLE
std::map< halco::hicann_dls::vx::v3::DLSGlobal, backend::Connection > && release_connections () SYMBOL_VISIBLE

Release contained connections.

Returns

Connections to the associated hardware

Public Static Attributes

static constexpr char name[] = "JITGraphExecutor"

Private Functions

void check(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(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, ConnectionStateStorage> m_connection_state_storages
std::map<halco::hicann_dls::vx::v3::DLSGlobal, backend::Connection> m_connections
bool m_enable_differential_config

Friends

friend IODataMap run(JITGraphExecutor &executor, Graph const &graph, IODataMap const &input, ChipConfigs const &initial_config, PlaybackHooks &playback_hooks)

Run the specified graph with specified inputs on the supplied executor.

Parameters

  • executor – Executor to use

  • graph – Graph to execute

  • input – List of input values to use

  • initial_config – Map of initial configuration

  • playback_hooks – Map of playback sequence collections to be inserted at specified execution instances

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<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, haldls::vx::v3::Timer::Value wait_between_events = haldls::vx::v3::Timer::Value(25), bool enable_loopback = false)

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

size_t input_size () const SYMBOL_VISIBLE
size_t output_size () const SYMBOL_VISIBLE
std::vector< std::vector< Int8 > > run (Activations const &inputs, lola::vx::v3::Chip const &config, JITGraphExecutor &executor) const SYMBOL_VISIBLE

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 () SYMBOL_VISIBLE
template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

bool m_enable_loopback = {false}
Graph m_graph = {}
Graph::vertex_descriptor m_input_vertex = {}
size_t m_num_sends = {}
Graph::vertex_descriptor m_output_vertex = {}
haldls::vx::v3::Timer::Value m_wait_between_events = {}
Weights m_weights = {}

Private Static Functions

static Graph::vertex_descriptor insert_synram (Graph &graph, Weights &&weights, coordinate::ExecutionInstance const &instance, halco::hicann_dls::vx::v3::HemisphereOnDLS const &hemisphere, Graph::vertex_descriptor crossbar_input_vertex) SYMBOL_VISIBLE

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

  • crossbar_input_vertex – Incoming crossbar input vertex to use

Returns

Data output vertex to measured membrane potential values

Friends

friend class cereal::access
struct grenade::vx::transformation::MACSpikeTrainGenerator : public grenade::vx::vertex::Transformation::Function
#include <mac_spiketrain_generator.h>

Public Types

typedef IODataMap::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, haldls::vx::v3::Timer::Value wait_between_events) SYMBOL_VISIBLE

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 () SYMBOL_VISIBLE
virtual Value apply (std::vector< Value > const &value) const SYMBOL_VISIBLE

Apply function on input value.

Parameters

value – Input value

Returns

Transformed output value

virtual bool equal (vertex::Transformation::Function const &other) const SYMBOL_VISIBLE
virtual std::vector< Port > inputs () const SYMBOL_VISIBLE

Provided input ports provided.

Returns

Port

virtual Port output () const SYMBOL_VISIBLE

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 = {}
haldls::vx::Timer::Value m_wait_between_events = {}

Private Static Functions

static std::optional< haldls::vx::v3::SpikeLabel > get_spike_label (halco::hicann_dls::vx::v3::SynapseDriverOnDLS const &driver, UInt5 const value) SYMBOL_VISIBLE

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 class cereal::access
struct grenade::vx::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::v3::PlaybackGeneratorReturn< Result > generate () const SYMBOL_VISIBLE

Friends

friend auto generate(MADCArm const&)
struct grenade::vx::vertex::MADCReadoutView
#include <madc_readout.h>

Readout of neuron voltages via the MADC.

Public Types

typedef lola::vx::v3::AtomicNeuron::Readout::Source Config
typedef halco::hicann_dls::vx::v3::AtomicNeuronOnDLS Coord

Public Functions

MADCReadoutView() = default
explicit  MADCReadoutView (Coord const &coord, Config const &config) SYMBOL_VISIBLE

Construct MADCReadoutView.

Parameters

  • coord – Neuron to read out

  • config – Source to read out at neuron

Config const  & get_config () const SYMBOL_VISIBLE
Coord const  & get_coord () const SYMBOL_VISIBLE
std::array< Port, 1 > inputs () const SYMBOL_VISIBLE
bool operator!= (MADCReadoutView const &other) const SYMBOL_VISIBLE
bool operator== (MADCReadoutView const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE
bool supports_input_from (NeuronView const &input, std::optional< PortRestriction > const &restriction) const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static bool variadic_input   = false

Private Functions

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

Private Members

Config m_config = {}
Coord m_coord = {}

Friends

friend class cereal::access
friend std::ostream & operator<< (std::ostream &os, MADCReadoutView const &config) SYMBOL_VISIBLE
struct grenade::vx::network::MADCRecording
#include <madc_recording.h>

MADC recording of a single neuron.

Public Types

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

Public Functions

MADCRecording() = default
MADCRecording (PopulationDescriptor population, size_t index, Source source) SYMBOL_VISIBLE
bool operator!= (MADCRecording const &other) const SYMBOL_VISIBLE
bool operator== (MADCRecording const &other) const SYMBOL_VISIBLE

Public Members

size_t index = {0}
PopulationDescriptor population = {}
Source source = {Source::membrane}
struct grenade::vx::generator::MADCStart
#include <madc.h>

Generator for a playback program snippet from starting the MADC.

Public Types

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

Protected Functions

stadls::vx::v3::PlaybackGeneratorReturn< Result > generate () const SYMBOL_VISIBLE

Friends

friend auto generate(MADCStart const&)
struct grenade::vx::generator::MADCStop
#include <madc.h>

Generator for a playback program snippet from stopping the MADC.

Public Types

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

Protected Functions

stadls::vx::v3::PlaybackGeneratorReturn< Result > generate () const SYMBOL_VISIBLE

Friends

friend auto generate(MADCStop const&)
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 SYMBOL_VISIBLE
bool operator== (Network const &other) const SYMBOL_VISIBLE

Public Members

std::optional<CADCRecording> const cadc_recording
std::chrono::microseconds const construction_duration

Duration spent during construction of network.

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

std::optional<MADCRecording> const madc_recording
std::map<PlasticityRuleDescriptor, PlasticityRule> const plasticity_rules
std::map<PopulationDescriptor, std::variant<Population, ExternalPopulation, BackgroundSpikeSourcePopulation>> const populations
std::map<ProjectionDescriptor, Projection> const projections

Friends

friend std::ostream & operator<< (std::ostream &os, Network const &network) SYMBOL_VISIBLE
class grenade::vx::network::NetworkBuilder
#include <network_builder.h>

Public Functions

NetworkBuilder () SYMBOL_VISIBLE
PopulationDescriptor add (BackgroundSpikeSourcePopulation const &population) SYMBOL_VISIBLE

Add on-chip background spike source population.

Parameters

population – Population to add

void add (CADCRecording const &cadc_recording) SYMBOL_VISIBLE

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

PopulationDescriptor add (ExternalPopulation const &population) SYMBOL_VISIBLE

Add off-chip population.

Parameters

population – Population to add

void add (MADCRecording const &madc_recording) SYMBOL_VISIBLE

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

PlasticityRuleDescriptor add (PlasticityRule const &plasticity_rule) SYMBOL_VISIBLE
PopulationDescriptor add (Population const &population) SYMBOL_VISIBLE

Add on-chip population.

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

Parameters

population – Population to add

ProjectionDescriptor add (Projection const &projection) SYMBOL_VISIBLE

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 () SYMBOL_VISIBLE

Private Members

std::optional<CADCRecording> m_cadc_recording = {std::nullopt}
std::chrono::microseconds m_duration
log4cxx::Logger *m_logger
std::optional<MADCRecording> m_madc_recording = {std::nullopt}
std::map<PlasticityRuleDescriptor, PlasticityRule> m_plasticity_rules = {}
std::map<PopulationDescriptor, std::variant<Population, ExternalPopulation, BackgroundSpikeSourcePopulation>> m_populations = {}
std::map<ProjectionDescriptor, Projection> m_projections = {}
struct grenade::vx::network::NetworkGraph
#include <network_graph.h>

Hardware graph representation of a placed and routed network.

Public Types

typedef std::vector<PlacedConnection> PlacedConnections
typedef std::map<PopulationDescriptor, std::vector<std::vector<std::optional<haldls::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 Functions

NetworkGraph() = default
std::vector< Graph::vertex_descriptor > get_cadc_sample_output_vertex () const SYMBOL_VISIBLE

Vertex descriptor from which to extract recorded cadc sample data.

std::optional< Graph::vertex_descriptor > get_event_input_vertex () const SYMBOL_VISIBLE

Vertex descriptor at which to insert external spike data.

std::optional< Graph::vertex_descriptor > get_event_output_vertex () const SYMBOL_VISIBLE

Vertex descriptor from which to extract recorded spike data.

Graph const  & get_graph () const SYMBOL_VISIBLE

Graph representing the network.

std::optional< Graph::vertex_descriptor > get_madc_sample_output_vertex () const SYMBOL_VISIBLE

Vertex descriptor from which to extract recorded madc sample data.

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

Underlying network.

PlacedConnection get_placed_connection (ProjectionDescriptor descriptor, size_t index) const SYMBOL_VISIBLE
PlacedConnections get_placed_connections (ProjectionDescriptor descriptor) const SYMBOL_VISIBLE
SpikeLabels const  & get_spike_labels () const SYMBOL_VISIBLE
bool valid () const SYMBOL_VISIBLE

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::map<PopulationDescriptor, std::map<halco::hicann_dls::vx::HemisphereOnDLS, Graph::vertex_descriptor>> m_background_spike_source_vertices
std::vector<Graph::vertex_descriptor> m_cadc_sample_output_vertex
std::chrono::microseconds m_construction_duration
std::optional<Graph::vertex_descriptor> m_event_input_vertex
std::optional<Graph::vertex_descriptor> m_event_output_vertex
Graph m_graph
std::optional<Graph::vertex_descriptor> m_madc_sample_output_vertex
std::shared_ptr<Network> m_network
std::map<PopulationDescriptor, std::map<halco::hicann_dls::vx::HemisphereOnDLS, Graph::vertex_descriptor>> m_neuron_vertices
std::map<PlasticityRuleDescriptor, Graph::vertex_descriptor> m_plasticity_rule_vertices
std::chrono::microseconds m_routing_duration
SpikeLabels m_spike_labels
std::map<ProjectionDescriptor, std::map<halco::hicann_dls::vx::HemisphereOnDLS, Graph::vertex_descriptor>> m_synapse_vertices
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 graph representation for a given network with the given routing result.

Parameters

  • network – Network for which to build hardware graph representation

  • routing_result – Routing result to use matching the given network

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

class grenade::vx::network::NetworkGraphBuilder
#include <network_graph_builder.h>

Network graph builder wrapper for network.

Public Functions

NetworkGraphBuilder (Network const &network) SYMBOL_VISIBLE
void add_background_spike_sources(Graph &graph, Resources &resources, coordinate::ExecutionInstance const &instance, RoutingResult const &routing_result) const
void add_cadc_recording(Graph &graph, Resources &resources, CADCRecording const &cadc_recording, coordinate::ExecutionInstance const &instance) const
void add_crossbar_node(Graph &graph, Resources &resources, halco::hicann_dls::vx::CrossbarNodeOnDLS const &coordinate, RoutingResult const &connection_result, coordinate::ExecutionInstance const &instance) const
void add_external_input(Graph &graph, Resources &resources, coordinate::ExecutionInstance const &instance) const
void add_external_output(Graph &graph, Resources &resources, RoutingResult const &connection_result, coordinate::ExecutionInstance const &instance) const
void add_madc_recording(Graph &graph, Resources &resources, MADCRecording const &madc_recording, coordinate::ExecutionInstance const &instance) const
void add_neuron_event_output(Graph &graph, Resources &resources, halco::hicann_dls::vx::NeuronEventOutputOnDLS const &coordinate, coordinate::ExecutionInstance const &instance) const
void add_neuron_event_outputs(Graph &graph, Resources &resources, coordinate::ExecutionInstance const &instance) const
void add_padi_bus(Graph &graph, Resources &resources, halco::hicann_dls::vx::PADIBusOnDLS const &coordinate, coordinate::ExecutionInstance const &instance) const
void add_plasticity_rules(Graph &graph, Resources &resources, coordinate::ExecutionInstance const &instance) const
void add_population(Graph &graph, Resources &resources, std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, std::vector<Input>> const &input, PopulationDescriptor const &descriptor, RoutingResult const &connection_result, coordinate::ExecutionInstance const &instance) const
void add_populations(Graph &graph, Resources &resources, RoutingResult const &connection_result, coordinate::ExecutionInstance const &instance) const
std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, Input> add_projection_from_background_spike_source(Graph &graph, Resources &resources, ProjectionDescriptor const &descriptor, RoutingResult const &connection_result, coordinate::ExecutionInstance const &instance) const
std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, Input> add_projection_from_external_input(Graph &graph, Resources &resources, ProjectionDescriptor const &descriptor, RoutingResult const &connection_result, coordinate::ExecutionInstance const &instance) const
std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, Input> add_projection_from_internal_input(Graph &graph, Resources &resources, ProjectionDescriptor const &descriptor, RoutingResult const &connection_result, coordinate::ExecutionInstance const &instance) const
void add_synapse_array_view_sparse(Graph &graph, Resources &resources, ProjectionDescriptor descriptor, RoutingResult const &connection_result, coordinate::ExecutionInstance const &instance) const
void add_synapse_driver(Graph &graph, Resources &resources, halco::hicann_dls::vx::SynapseDriverOnDLS const &coordinate, RoutingResult const &connection_result, coordinate::ExecutionInstance const &instance) const
NetworkGraph::SpikeLabels get_spike_labels(RoutingResult const &connection_result)

Public Static Functions

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

Private Members

log4cxx::Logger *m_logger
Network const &m_network
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 SYMBOL_VISIBLE

Get duration spent constructing abstract network (Network).

std::chrono::microseconds get_hardware_network_construction_duration () const SYMBOL_VISIBLE

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

double get_neuron_usage () const SYMBOL_VISIBLE

Get used fraction of neurons vs.

all hardware circuits.

size_t get_num_neurons () const SYMBOL_VISIBLE

Get number of neurons in network graph.

This is the same amount as hardware circuits.

size_t get_num_populations () const SYMBOL_VISIBLE

Get number of populations in network graph.

size_t get_num_projections () const SYMBOL_VISIBLE

Get number of projections in network graph.

size_t get_num_synapse_drivers () const SYMBOL_VISIBLE

Get number of synapse drivers in network graph.

This is the same amount as hardware circuits.

size_t get_num_synapses () const SYMBOL_VISIBLE

Get number of synapses in network graph.

This is the same amount as hardware circuits.

std::chrono::microseconds get_routing_duration () const SYMBOL_VISIBLE

Get duration spent routing the abstract network (Network).

double get_synapse_driver_usage () const SYMBOL_VISIBLE

Get used fraction of synapse drivers vs.

all hardware circuits.

double get_synapse_usage () const SYMBOL_VISIBLE

Get used fraction of synapses vs.

all hardware circuits.

std::chrono::microseconds get_verification_duration () const SYMBOL_VISIBLE

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

Private Members

std::chrono::microseconds m_abstract_network_construction_duration = {0}
std::chrono::microseconds m_hardware_network_construction_duration = {0}
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}
std::chrono::microseconds m_routing_duration = {0}
double m_synapse_driver_usage = {0.}
double m_synapse_usage = {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) SYMBOL_VISIBLE
struct grenade::vx::network::CADCRecording::Neuron
#include <cadc_recording.h>

Public Types

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

Public Functions

Neuron() = default
Neuron (PopulationDescriptor population, size_t index, Source source) SYMBOL_VISIBLE
bool operator!= (Neuron const &other) const SYMBOL_VISIBLE
bool operator== (Neuron const &other) const SYMBOL_VISIBLE

Public Members

size_t index
PopulationDescriptor population
Source source = {Source::membrane}
struct grenade::vx::vertex::NeuronEventOutputView
#include <neuron_event_output_view.h>

A view of neuron event outputs into the routing crossbar.

Public Types

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) SYMBOL_VISIBLE

Construct NeuronEventOutputView with specified neurons.

Parameters

neurons – Incoming neurons

Neurons const  & get_neurons () const SYMBOL_VISIBLE
std::vector< Port > inputs () const SYMBOL_VISIBLE

Input ports are organized in the same order as the specified neuron views.

bool operator!= (NeuronEventOutputView const &other) const SYMBOL_VISIBLE
bool operator== (NeuronEventOutputView const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE

Output ports are sorted neuron event output channels.

bool supports_input_from (NeuronView const &input, std::optional< PortRestriction > const &restriction) const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static bool variadic_input   = false

Private Functions

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

Private Members

Neurons m_neurons = {}

Friends

friend class cereal::access
friend std::ostream & operator<< (std::ostream &os, NeuronEventOutputView const &config) SYMBOL_VISIBLE
class grenade::vx::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::PlaybackProgramBuilder Builder
typedef halco::common::typed_array<bool, halco::hicann_dls::vx::v3::NeuronResetOnDLS> enable_resets_type
typedef hate::Nil Result

Public Functions

NeuronResetMask () SYMBOL_VISIBLE

Public Members

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

Enable reset value per neuron.

Protected Functions

stadls::vx::v3::PlaybackGeneratorReturn< Result > generate () const SYMBOL_VISIBLE

Friends

friend auto generate(NeuronResetMask const&)
struct grenade::vx::vertex::NeuronView
#include <neuron_view.h>

A view of neuron circuits.

TODO: add properties

Public Types

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)

Construct NeuronView with specified neurons.

Parameters

  • columns – Neuron columns

  • enable_resets – Enable values for initial reset of the neurons

  • row – Neuron row

Columns const  & get_columns () const SYMBOL_VISIBLE
Configs const  & get_configs () const SYMBOL_VISIBLE
Row const  & get_row () const SYMBOL_VISIBLE
std::array< Port, 1 > inputs () const SYMBOL_VISIBLE
bool operator!= (NeuronView const &other) const SYMBOL_VISIBLE
bool operator== (NeuronView const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE
bool supports_input_from (SynapseArrayView const &input, std::optional< PortRestriction > const &restriction) const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static bool variadic_input   = true

Private Functions

void check (Columns const &columns, Configs const &configs) SYMBOL_VISIBLE
template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Columns m_columns = {}
Configs m_configs = {}
Row m_row = {}

Friends

friend class cereal::access
friend std::ostream & operator<< (std::ostream &os, NeuronView const &config) SYMBOL_VISIBLE
struct grenade::vx::vertex::PADIBus
#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::PADIBusOnDLS Coordinate

Public Functions

PADIBus() = default
PADIBus (Coordinate const &coordinate) SYMBOL_VISIBLE

Construct PADI bus at specified location.

Parameters

coordinate – Location

Coordinate const  & get_coordinate () const SYMBOL_VISIBLE
inline constexpr std::array<Port, 1> inputs() const
bool operator!= (PADIBus const &other) const SYMBOL_VISIBLE
bool operator== (PADIBus const &other) const SYMBOL_VISIBLE
inline constexpr Port output() const
bool supports_input_from (CrossbarNode const &input, std::optional< PortRestriction > const &restriction) const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static bool variadic_input   = true

Private Functions

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

Private Members

Coordinate m_coordinate = {}

Friends

friend class cereal::access
friend std::ostream & operator<< (std::ostream &os, PADIBus const &config) SYMBOL_VISIBLE
struct grenade::vx::network::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::SourceOnPADIBusManager::Partition
#include <source_on_padi_bus_manager.h>

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

Public Functions

bool valid () const SYMBOL_VISIBLE

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) SYMBOL_VISIBLE
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 &) SYMBOL_VISIBLE
struct grenade::vx::network::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::RoutingResult::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 const label
halco::hicann_dls::vx::v3::SynapseOnSynapseRow const synapse_on_row
halco::hicann_dls::vx::v3::SynapseRowOnDLS const synapse_row
lola::vx::v3::SynapseMatrix::Weight const weight

Friends

friend std::ostream & operator<< (std::ostream &, PlacedConnection const &) SYMBOL_VISIBLE
struct grenade::vx::network::NetworkGraphBuilder::Resources::PlacedPopulation
#include <network_graph_builder.h>

Public Members

std::map<halco::hicann_dls::vx::HemisphereOnDLS, Graph::vertex_descriptor> neurons
struct grenade::vx::network::NetworkGraphBuilder::Resources::PlacedProjection
#include <network_graph_builder.h>

Public Members

std::map<halco::hicann_dls::vx::HemisphereOnDLS, Graph::vertex_descriptor> synapses
struct grenade::vx::network::PlasticityRule
#include <plasticity_rule.h>

Plasticity rule.

Public Functions

PlasticityRule() = default
bool operator!= (PlasticityRule const &other) const SYMBOL_VISIBLE
bool operator== (PlasticityRule const &other) const SYMBOL_VISIBLE

Public Members

std::string kernel = {}

Plasticity rule kernel to be compiled into the PPU program.

std::vector<ProjectionDescriptor> projections = {}

Descriptor to projections this rule has access to.

All projections are required to be dense and in order.

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

Friends

friend std::ostream & operator<< (std::ostream &os, PlasticityRule const &plasticity_rule) SYMBOL_VISIBLE
struct grenade::vx::vertex::PlasticityRule
#include <plasticity_rule.h>

A plasticity rule to operate on synapse array views.

Public Functions

PlasticityRule() = default
PlasticityRule (std::string kernel, Timer const &timer, std::vector< size_t > const &synapse_column_size) SYMBOL_VISIBLE

Construct PlasticityRule with specified kernel, timer and synapse information.

Parameters

  • kernel – Kernel to apply

  • timer – Timer to use

  • synapse_column_size – Column-size of synapse views to alter

std::string const  & get_kernel () const SYMBOL_VISIBLE
Timer const  & get_timer () const SYMBOL_VISIBLE
std::vector< Port > inputs () const SYMBOL_VISIBLE
bool operator!= (PlasticityRule const &other) const SYMBOL_VISIBLE
bool operator== (PlasticityRule const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE
bool supports_input_from (SynapseArrayView const &input, std::optional< PortRestriction > const &restriction) const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static bool variadic_input   = false

Private Functions

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

Private Members

std::string m_kernel
std::vector<size_t> m_synapse_column_size
Timer m_timer

Friends

friend class cereal::access
friend std::ostream & operator<< (std::ostream &os, PlasticityRule const &config) SYMBOL_VISIBLE
struct grenade::vx::network::PlasticityRuleDescriptor : public halco::common::detail::BaseType<PlasticityRuleDescriptor, size_t>
#include <plasticity_rule.h>

Descriptor to be used to identify a plasticity rule.

Public Functions

inline explicit constexpr PlasticityRuleDescriptor(value_type const value = 0)
struct grenade::vx::ExecutionInstanceBuilder::PlaybackPrograms
#include <execution_instance_builder.h>

Public Members

bool has_hook_around_realtime
bool has_plasticity
std::vector<stadls::vx::v3::PlaybackProgram> realtime
struct grenade::vx::network::Population
#include <population.h>

Population of on-chip neurons.

Public Types

typedef std::vector<bool> EnableRecordSpikes

Enable spike recording.

typedef std::vector<halco::hicann_dls::vx::v3::AtomicNeuronOnDLS> Neurons

List of on-chip neurons.

Public Functions

Population() = default
Population (Neurons const &neurons, EnableRecordSpikes const &enable_record_spikes) SYMBOL_VISIBLE
bool operator!= (Population const &other) const SYMBOL_VISIBLE
bool operator== (Population const &other) const SYMBOL_VISIBLE

Public Members

EnableRecordSpikes enable_record_spikes = {}
Neurons neurons = {}

Friends

friend std::ostream & operator<< (std::ostream &os, Population const &population) SYMBOL_VISIBLE
struct grenade::vx::network::PopulationDescriptor : public halco::common::detail::BaseType<PopulationDescriptor, size_t>
#include <population.h>

Descriptor to be used to identify a population.

Public Functions

inline explicit constexpr PopulationDescriptor(value_type const value = 0)
struct grenade::vx::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) SYMBOL_VISIBLE
struct grenade::vx::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) SYMBOL_VISIBLE
bool is_restriction_of (Port const &port) const SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

Get maximal inclusive index.

Returns

Maximum of range

size_t min () const SYMBOL_VISIBLE

Get minimal inclusive index.

Returns

Minimum of range

bool operator!= (PortRestriction const &other) const SYMBOL_VISIBLE
bool operator== (PortRestriction const &other) const SYMBOL_VISIBLE
size_t size () const SYMBOL_VISIBLE

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 class cereal::access
friend std::ostream & operator<< (std::ostream &os, PortRestriction const &data) SYMBOL_VISIBLE
class grenade::vx::PPUProgramGenerator
#include <ppu_program_generator.h>

Public Functions

PPUProgramGenerator() = default
void add (vertex::PlasticityRule const &rule, std::vector< std::pair< halco::hicann_dls::vx::v3::SynramOnDLS, ppu::SynapseArrayViewHandle >> const &synapses) SYMBOL_VISIBLE
std::vector< std::string > done () SYMBOL_VISIBLE

Private Members

std::vector<std::tuple<vertex::PlasticityRule, std::vector<std::pair<halco::hicann_dls::vx::v3::SynramOnDLS, ppu::SynapseArrayViewHandle>>>> m_plasticity_rules
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 Types

typedef std::pair<lola::vx::v3::PPUElfFile::symbols_type, haldls::vx::v3::PPUMemoryBlock> Program

Program information comprised of the symbols and memory image.

Public Members

std::map<std::string, Program> data
std::mutex data_mutex
struct grenade::vx::network::Projection
#include <projection.h>

Projection between populations.

Public Types

typedef std::vector<Connection> Connections

Point-to-point neuron connections type.

enum ReceptorType

Receptor type of connections.

Values:

enumerator excitatory
enumerator inhibitory

Public Functions

Projection() = default
Projection (ReceptorType receptor_type, Connections &&connections, PopulationDescriptor population_pre, PopulationDescriptor population_post) SYMBOL_VISIBLE
Projection (ReceptorType receptor_type, Connections const &connections, PopulationDescriptor population_pre, PopulationDescriptor population_post) SYMBOL_VISIBLE
parent def ("from_numpy", from_numpy)
inline  for (size_t i=0;i< self.connections.size();++i)
inline  if (shape.at(1) !=3)
self connections resize (shape.at(0))

Public Members

Connections connections = {}

Point-to-point neuron connections.

auto const data = pyconnections.unchecked()
bool enable_is_required_dense_in_order = {false}

Enable whether this projection is required to be placed densely and in order.

This is used for on-chip plasticity rules.

PopulationDescriptor population_post = {}

Descriptor to post-synaptic population.

self population_post = population_post
PopulationDescriptor population_pre = {}

Descriptor to pre-synaptic population.

self population_pre = population_pre
ReceptorType receptor_type

Receptor type.

self receptor_type = receptor_type
struct grenade::vx::ProjectionDescriptor : public halco::common::detail::BaseType<ProjectionDescriptor, size_t>
#include <projection.h>

Descriptor to be used to identify a projection.

Public Functions

inline explicit constexpr ProjectionDescriptor(value_type const value = 0)
class grenade::vx::RangeSplit
#include <range_split.h>

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

Public Functions

explicit  RangeSplit (size_t split_size) SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

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
class grenade::vx::compute::ReLU
#include <relu.h>

Compute a rectified linear unit operation.

Public Functions

ReLU() = default
ReLU (size_t size) SYMBOL_VISIBLE

Create single ReLU compute graph wrapper.

Parameters

size – Size of operation.

size_t input_size () const SYMBOL_VISIBLE
size_t output_size () const SYMBOL_VISIBLE
std::vector< std::vector< Int8 > > run (std::vector< std::vector< Int8 >> const &inputs, lola::vx::v3::Chip const &config, JITGraphExecutor &executor) const SYMBOL_VISIBLE

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

Graph m_graph = {}
Graph::vertex_descriptor m_input_vertex = {}
Graph::vertex_descriptor m_output_vertex = {}

Friends

friend class cereal::access
struct grenade::vx::vertex::ReLU
#include <relu.h>

ReLU of multiple inputs of Int8 data type.

Public Functions

ReLU() = default
explicit  ReLU (size_t size) SYMBOL_VISIBLE

Construct operation with specified size.

Parameters

size – Number of data values per input

std::array< Port, 1 > inputs () const SYMBOL_VISIBLE
bool operator!= (ReLU const &other) const SYMBOL_VISIBLE
bool operator== (ReLU const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static bool variadic_input   = false

Private Functions

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

Private Members

size_t m_size = {}

Friends

friend class cereal::access
friend std::ostream & operator<< (std::ostream &os, ReLU const &config) SYMBOL_VISIBLE
struct grenade::vx::network::NetworkGraphBuilder::Resources
#include <network_graph_builder.h>

Public Members

std::map<PopulationDescriptor, std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, Graph::vertex_descriptor>> background_spike_sources
std::vector<Graph::vertex_descriptor> cadc_output
std::optional<Graph::vertex_descriptor> crossbar_l2_input
std::map<halco::hicann_dls::vx::v3::CrossbarNodeOnDLS, Graph::vertex_descriptor> crossbar_nodes
std::optional<Graph::vertex_descriptor> external_input
std::optional<Graph::vertex_descriptor> external_output
std::optional<Graph::vertex_descriptor> madc_output
std::map<halco::hicann_dls::vx::v3::NeuronEventOutputOnDLS, Graph::vertex_descriptor> neuron_event_outputs
std::map<halco::hicann_dls::vx::v3::PADIBusOnDLS, Graph::vertex_descriptor> padi_busses
std::map<PlasticityRuleDescriptor, Graph::vertex_descriptor> plasticity_rules
std::map<PopulationDescriptor, PlacedPopulation> populations
std::map<ProjectionDescriptor, PlacedProjection> projections
std::map<halco::hicann_dls::vx::v3::SynapseDriverOnDLS, Graph::vertex_descriptor> synapse_drivers
struct grenade::vx::network::RoutingBuilder::RoutedConnection

Public Members

std::pair<ProjectionDescriptor, size_t> descriptor
halco::hicann_dls::vx::v3::AtomicNeuronOnDLS target
struct grenade::vx::network::RoutingBuilder
#include <routing_builder.h>

Public Types

typedef RoutingResult Result

Public Functions

RoutingBuilder () SYMBOL_VISIBLE
Result route (Network const &network, std::optional< RoutingOptions > const &options=std::nullopt) const SYMBOL_VISIBLE

Private Functions

void apply_crossbar_nodes_from_background(Result &result) const
void apply_crossbar_nodes_from_internal_to_l2(Result &result) const
void apply_crossbar_nodes_from_l2(Result &result) const
void apply_crossbar_nodes_internal(Result &result) const
void apply_routed_connections(std::map<std::pair<ProjectionDescriptor, size_t>, PlacedConnection> const &placed_connections, std::map<std::pair<PopulationDescriptor, size_t>, haldls::vx::v3::SpikeLabel> const &internal_labels, std::map<std::pair<PopulationDescriptor, size_t>, std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, haldls::vx::v3::SpikeLabel>> const &background_labels, std::map<std::pair<PopulationDescriptor, size_t>, std::map<halco::hicann_dls::vx::v3::PADIBusOnDLS, haldls::vx::v3::SpikeLabel>> const &external_labels, Network const &network, Result &result) const
std::vector<std::pair<PopulationDescriptor, size_t>> apply_source_labels(RoutingConstraints const &constraints, std::map<std::pair<PopulationDescriptor, size_t>, haldls::vx::v3::SpikeLabel> const &internal, std::map<std::pair<PopulationDescriptor, size_t>, std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, haldls::vx::v3::SpikeLabel>> const &background, std::map<std::pair<PopulationDescriptor, size_t>, std::map<halco::hicann_dls::vx::v3::PADIBusOnDLS, haldls::vx::v3::SpikeLabel>> const &external, Network const &network, Result &result) const
std::map<std::pair<PopulationDescriptor, size_t>, std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, haldls::vx::v3::SpikeLabel>> get_background_labels(std::vector<std::pair<PopulationDescriptor, size_t>> const &descriptors, std::vector<SourceOnPADIBusManager::BackgroundSource> const &background_sources, SourceOnPADIBusManager::Partition const &partition, std::vector<SynapseDriverOnDLSManager::Allocation> const &allocations) const
std::pair<std::vector<SourceOnPADIBusManager::BackgroundSource>, std::vector<std::pair<PopulationDescriptor, size_t>>> get_background_sources(RoutingConstraints const &constraints, halco::common::typed_array<RoutingConstraints::PADIBusConstraints, halco::hicann_dls::vx::v3::PADIBusOnDLS> const &padi_bus_constraints, Network const &network) const
std::map<std::pair<PopulationDescriptor, size_t>, std::map<halco::hicann_dls::vx::v3::PADIBusOnDLS, haldls::vx::v3::SpikeLabel>> get_external_labels(std::vector<std::pair<PopulationDescriptor, size_t>> const &descriptors, SourceOnPADIBusManager::Partition const &partition, std::vector<SynapseDriverOnDLSManager::Allocation> const &allocations) const
std::pair<std::vector<SourceOnPADIBusManager::ExternalSource>, std::vector<std::pair<PopulationDescriptor, size_t>>> get_external_sources(RoutingConstraints const &constraints, halco::common::typed_array<RoutingConstraints::PADIBusConstraints, halco::hicann_dls::vx::v3::PADIBusOnDLS> const &padi_bus_constraints, Network const &network) const
std::map<std::pair<PopulationDescriptor, size_t>, haldls::vx::v3::SpikeLabel> get_internal_labels(std::vector<std::pair<PopulationDescriptor, size_t>> const &descriptors, SourceOnPADIBusManager::Partition const &partition, std::vector<SynapseDriverOnDLSManager::Allocation> const &allocations) const
std::pair<std::vector<SourceOnPADIBusManager::InternalSource>, std::vector<std::pair<PopulationDescriptor, size_t>>> get_internal_sources(RoutingConstraints const &constraints, halco::common::typed_array<RoutingConstraints::PADIBusConstraints, halco::hicann_dls::vx::v3::PADIBusOnDLS> const &padi_bus_constraints, Network const &network) const
std::map<std::pair<ProjectionDescriptor, size_t>, PlacedConnection> place_routed_connections(SourceOnPADIBusManager::Partition const &partition, std::vector<std::pair<PopulationDescriptor, size_t>> const &internal_descriptors, std::vector<std::pair<PopulationDescriptor, size_t>> const &background_descriptors, std::vector<std::pair<PopulationDescriptor, size_t>> 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 const &network, Result &result) const
template<typename Connection>
std::map<std::pair<ProjectionDescriptor, size_t>, PlacedConnection> place_routed_connections(std::vector<Connection> const &connections, std::map<Projection::ReceptorType, std::vector<halco::hicann_dls::vx::v3::SynapseRowOnDLS>> const &synapse_rows) const
std::map<std::pair<ProjectionDescriptor, size_t>, 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<ProjectionDescriptor, size_t>, PlacedConnection> place_routed_connections(std::vector<SourceOnPADIBusManager::Partition::Group> const &partition, std::vector<std::pair<PopulationDescriptor, size_t>> const &descriptors, Sources const &sources, std::vector<SynapseDriverOnDLSManager::Allocation> const &padi_bus_allocations, size_t offset, RoutingConstraints const &constraints, Network const &network, Result &result) const
void route_internal_crossbar(RoutingConstraints const &constraints, halco::common::typed_array<RoutingConstraints::PADIBusConstraints, halco::hicann_dls::vx::v3::PADIBusOnDLS> &padi_bus_constraints, Result &result) const

Private Members

log4cxx::Logger *m_logger
struct grenade::vx::network::RoutingConstraints
#include <routing_constraints.h>

Accessors for routing constraints for a given abstract network.

Public Functions

RoutingConstraints (Network const &network) SYMBOL_VISIBLE

Construct constraints from and for an abstract network.

Parameters

network – Abstract network

void check () const SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

Get background connections of network.

Returns

Background connections

std::vector< ExternalConnection > get_external_connections () const SYMBOL_VISIBLE

Get external connections of network.

Returns

External connections

halco::common::typed_array< std::map< Projection::ReceptorType, std::vector< std::pair< ProjectionDescriptor, size_t > > >, halco::hicann_dls::vx::v3::HemisphereOnDLS > get_external_connections_per_hemisphere () const SYMBOL_VISIBLE

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

halco::common::typed_array< std::map< Projection::ReceptorType, std::set< std::pair< PopulationDescriptor, size_t > > >, halco::hicann_dls::vx::v3::HemisphereOnDLS > get_external_sources_to_hemisphere () const SYMBOL_VISIBLE

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

std::vector< InternalConnection > get_internal_connections () const SYMBOL_VISIBLE

Get internal connections of network.

Returns

Internal connections

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

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 SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

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

halco::common::typed_array< std::map< Projection::ReceptorType, size_t >, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS > get_neuron_in_degree_per_receptor_type () const SYMBOL_VISIBLE

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

halco::common::typed_array< halco::common::typed_array< std::map< Projection::ReceptorType, 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 SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

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< Projection::ReceptorType, size_t >, halco::hicann_dls::vx::v3::PADIBusOnDLS > get_num_synapse_rows_per_padi_bus_per_receptor_type () const SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

Get constraints for each PADI-bus.

Private Members

Network const &m_network
struct grenade::vx::network::RoutingOptions
#include <routing_options.h>

Options to be passed to routing algorithm.

Public Types

typedef SynapseDriverOnDLSManager::AllocationPolicy AllocationPolicy

Policy to be used in synapse driver allocation.

typedef SynapseDriverOnDLSManager::AllocationPolicyBacktracking AllocationPolicyBacktracking
typedef SynapseDriverOnDLSManager::AllocationPolicyGreedy AllocationPolicyGreedy

Public Functions

RoutingOptions () SYMBOL_VISIBLE

Public Members

SynapseDriverOnDLSManager::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, RoutingOptions const &options) SYMBOL_VISIBLE
struct grenade::vx::network::RoutingResult
#include <routing_result.h>

Result of connection routing.

Public Types

typedef std::map<PopulationDescriptor, std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, halco::hicann_dls::vx::v3::NeuronLabel>> BackgroundSpikeSourceLabels

Background spike source configuration for each population.

typedef std::map<ProjectionDescriptor, 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<PopulationDescriptor, std::vector<std::vector<haldls::vx::v3::SpikeLabel>>> ExternalSpikeLabels

Spike label corresponding to each neuron in a external population.

typedef std::map<PopulationDescriptor, 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

RoutingResult() = default

Public Members

BackgroundSpikeSourceLabels background_spike_source_labels
Connections connections
CrossbarNodes crossbar_nodes
ExternalSpikeLabels external_spike_labels
InternalNeuronLabels internal_neuron_labels
SynapseDriverRowAddressCompareMasks synapse_driver_compare_masks
SynapseRowModes synapse_row_modes
struct grenade::vx::network::RoutingResult::TimingStatistics timing_statistics

Friends

friend std::ostream & operator<< (std::ostream &, RoutingResult const &) SYMBOL_VISIBLE
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<UInt5>>, std::vector<std::vector<Int8>>, std::vector<std::vector<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, JITGraphExecutor &executor) SYMBOL_VISIBLE

Public Members

std::list<Entry> data

Private Functions

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

Friends

friend class cereal::access
struct grenade::vx::network::SynapseDriverOnPADIBusManager::AllocationRequest::Shape
#include <synapse_driver_on_padi_bus_manager.h>

Single synapse driver collection.

Public Functions

bool operator!= (Shape const &other) const SYMBOL_VISIBLE
bool operator== (Shape const &other) const SYMBOL_VISIBLE

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) SYMBOL_VISIBLE
class grenade::vx::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 SYMBOL_VISIBLE

Get current hemisphere.

coordinate::ExecutionInstance next () SYMBOL_VISIBLE

Get next execution instance.

coordinate::ExecutionInstance next_index () SYMBOL_VISIBLE

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

Private Members

halco::hicann_dls::vx::v3::HemisphereOnDLS m_current_hemisphere
coordinate::ExecutionIndex m_current_index
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 SYMBOL_VISIBLE

Public Members

std::vector<std::string> options_after_source

Compiler options after the source location specification.

std::vector<std::string> options_before_source

Compiler options before the source location specification.

std::vector<std::string> source_codes

Source code additional to the constant base program sources.

struct grenade::vx::network::detail::SourceOnPADIBusManager
#include <source_on_padi_bus_manager.h>

Public Types

typedef grenade::vx::network::SourceOnPADIBusManager::BackgroundSource BackgroundSource
typedef grenade::vx::network::SourceOnPADIBusManager::ExternalSource ExternalSource
typedef grenade::vx::network::SourceOnPADIBusManager::InternalSource InternalSource
typedef grenade::vx::network::SourceOnPADIBusManager::Label Label
typedef grenade::vx::network::SourceOnPADIBusManager::Partition Partition
typedef grenade::vx::network::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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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::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 SynapseDriverOnDLSManager::Label Label

Label to identify events at synapse driver(s).

typedef SynapseDriverOnDLSManager::SynapseDriver SynapseDriver

Synapse driver location.

Public Functions

SourceOnPADIBusManager () SYMBOL_VISIBLE

Construct manager.

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

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

log4cxx::Logger *m_logger
struct grenade::vx::RangeSplit::SubRange
#include <range_split.h>

Sub-range consisting of local size and offset.

Public Members

size_t offset
size_t size
struct grenade::vx::vertex::Subtraction
#include <subtraction.h>

Subtraction of multiple inputs of Int8 data type.

Public Functions

Subtraction() = default
explicit  Subtraction (size_t size) SYMBOL_VISIBLE

Construct subtraction with specified size.

Parameters

size – Number of data values per input

std::array< Port, 1 > inputs () const SYMBOL_VISIBLE
bool operator!= (Subtraction const &other) const SYMBOL_VISIBLE
bool operator== (Subtraction const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static bool variadic_input   = true

Private Functions

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

Private Members

size_t m_size = {}

Friends

friend class cereal::access
friend std::ostream & operator<< (std::ostream &os, Subtraction const &config) SYMBOL_VISIBLE
struct grenade::vx::vertex::SynapseArrayViewSparse::Synapse
#include <synapse_array_view_sparse.h>

Public Functions

bool operator!= (Synapse const &other) const SYMBOL_VISIBLE
bool operator== (Synapse const &other) const SYMBOL_VISIBLE

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 class cereal::access
struct grenade::vx::vertex::SynapseArrayView
#include <synapse_array_view.h>

A rectangular view of synapses connected to a set of synapse drivers.

Public Types

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)

Construct synapse array view.

Parameters

  • synram – Synram location of synapses

  • rows – Coordinates of rows

  • columns – Coordinates of columns

  • weights – Weight values

  • labels – Label values

boost::iterator_range< Columns::const_iterator > get_columns () const SYMBOL_VISIBLE

Accessor to synapse column coordinates via a range.

Returns

Range of synapse column coordinates

boost::iterator_range< Labels::const_iterator > get_labels () const SYMBOL_VISIBLE

Accessor to label configuration via a range.

Returns

Range of label configuration

boost::iterator_range< Rows::const_iterator > get_rows () const SYMBOL_VISIBLE

Accessor to synapse row coordinates via a range.

Returns

Range of synapse row coordinates

Synram const  & get_synram () const SYMBOL_VISIBLE
boost::iterator_range< Weights::const_iterator > get_weights () const SYMBOL_VISIBLE

Accessor to weight configuration via a range.

Returns

Range of weight configuration

std::vector< Port > inputs () const SYMBOL_VISIBLE
bool operator!= (SynapseArrayView const &other) const SYMBOL_VISIBLE
bool operator== (SynapseArrayView const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static bool variadic_input   = false

Private Functions

void check (Rows const &rows, Columns const &columns, Weights const &weights, Labels const &labels) SYMBOL_VISIBLE
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 class cereal::access
friend std::ostream & operator<< (std::ostream &os, SynapseArrayView const &config) SYMBOL_VISIBLE
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::vertex::SynapseArrayViewSparse
#include <synapse_array_view_sparse.h>

A sparse view of synapses connected to a set of synapse drivers.

Public Types

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)

Construct synapse array view.

Parameters

  • synram – Synram location of synapses

  • rows – Coordinates of rows

  • columns – Coordinates of columns

  • synapses – Synapse values

boost::iterator_range< Columns::const_iterator > get_columns () const SYMBOL_VISIBLE

Accessor to synapse column coordinates via a range.

Returns

Range of synapse column coordinates

boost::iterator_range< Rows::const_iterator > get_rows () const SYMBOL_VISIBLE

Accessor to synapse row coordinates via a range.

Returns

Range of synapse row coordinates

boost::iterator_range< Synapses::const_iterator > get_synapses () const SYMBOL_VISIBLE

Accessor to synapse configuration via a range.

Returns

Range of synapse configuration

Synram const  & get_synram () const SYMBOL_VISIBLE
std::vector< Port > inputs () const SYMBOL_VISIBLE
bool operator!= (SynapseArrayViewSparse const &other) const SYMBOL_VISIBLE
bool operator== (SynapseArrayViewSparse const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE
ppu::SynapseArrayViewHandle toSynapseArrayViewHandle () const SYMBOL_VISIBLE

Convert to synapse array view handle for PPU programs.

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static bool variadic_input   = false

Private Functions

void check (Rows const &rows, Columns const &columns, Synapses const &synapses) SYMBOL_VISIBLE
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 class cereal::access
friend std::ostream & operator<< (std::ostream &os, SynapseArrayViewSparse const &config) SYMBOL_VISIBLE
struct grenade::vx::vertex::SynapseDriver
#include <synapse_driver.h>

Synapse driver.

Public Types

typedef halco::hicann_dls::vx::v3::SynapseDriverOnDLS Coordinate

Public Functions

SynapseDriver() = default
SynapseDriver (Coordinate const &coordinate, Config const &config) SYMBOL_VISIBLE

Construct synapse driver at specified location with specified configuration.

Parameters

  • coordinate – Location

  • config – Configuration

Config get_config () const SYMBOL_VISIBLE
Coordinate get_coordinate () const SYMBOL_VISIBLE
inline constexpr std::array<Port, 1> inputs() const
bool operator!= (SynapseDriver const &other) const SYMBOL_VISIBLE
bool operator== (SynapseDriver const &other) const SYMBOL_VISIBLE
inline constexpr Port output() const
bool supports_input_from (PADIBus const &input, std::optional< PortRestriction > const &restriction) const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = false
static constexpr static 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 class cereal::access
friend std::ostream & operator<< (std::ostream &os, SynapseDriver const &config) SYMBOL_VISIBLE
struct grenade::vx::network::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::SynapseDriverOnDLSManager::Allocation Allocation
typedef grenade::vx::network::SynapseDriverOnDLSManager::AllocationPolicy AllocationPolicy
typedef grenade::vx::network::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::SynapseDriverOnDLSManager::Label Label
typedef grenade::vx::network::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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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::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={}) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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::Logger *m_logger
halco::common::typed_array<SynapseDriverOnPADIBusManager, halco::hicann_dls::vx::v3::PADIBusOnDLS> m_synapse_driver_on_padi_bus_manager
struct grenade::vx::network::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::SynapseDriverOnPADIBusManager::Allocation Allocation
typedef grenade::vx::network::SynapseDriverOnPADIBusManager::AllocationPolicy AllocationPolicy
typedef grenade::vx::network::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::SynapseDriverOnPADIBusManager::Label Label
typedef grenade::vx::network::SynapseDriverOnPADIBusManager::Mask Mask
typedef grenade::vx::network::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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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::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={}) SYMBOL_VISIBLE

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()) SYMBOL_VISIBLE

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::TemporaryDirectory
#include <ppu.h>

Create (and automatically delete) temporary directory.

Public Functions

TemporaryDirectory (std::string directory_template) SYMBOL_VISIBLE
~TemporaryDirectory () SYMBOL_VISIBLE
std::filesystem::path get_path () const SYMBOL_VISIBLE

Private Members

std::filesystem::path m_path
template<typename T>
struct grenade::vx::TimedData
#include <event.h>

Public Functions

TimedData() = default
TimedData(haldls::vx::v3::FPGATime const &fpga_time, haldls::vx::v3::ChipTime const &chip_time, T const &data)
bool operator!=(TimedData const &other) const
bool operator==(TimedData const &other) const

Public Members

haldls::vx::v3::ChipTime chip_time
T data
haldls::vx::v3::FPGATime fpga_time
struct grenade::vx::TimedSpike
#include <event.h>

Timed to-chip spike.

Public Types

typedef std::variant<haldls::vx::v3::SpikePack1ToChip, haldls::vx::v3::SpikePack2ToChip, haldls::vx::v3::SpikePack3ToChip> Payload
typedef haldls::vx::v3::Timer::Value Time

Public Functions

TimedSpike() = default
TimedSpike (Time const &time, Payload const &payload) SYMBOL_VISIBLE
bool operator!= (TimedSpike const &other) const SYMBOL_VISIBLE
bool operator== (TimedSpike const &other) const SYMBOL_VISIBLE

Public Members

Payload payload

Spike payload data.

Time time

Time value when to emit spike.

Friends

friend std::ostream & operator<< (std::ostream &os, TimedSpike const &spike) SYMBOL_VISIBLE
class grenade::vx::generator::TimedSpikeSequence
#include <timed_spike_sequence.h>

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

Public Types

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

Public Functions

inline TimedSpikeSequence(grenade::vx::TimedSpikeSequence const &values)

Protected Functions

stadls::vx::v3::PlaybackGeneratorReturn< Result > generate () const SYMBOL_VISIBLE

Private Members

grenade::vx::TimedSpikeSequence const &m_values

Friends

friend auto generate(TimedSpikeSequence const&)
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 SYMBOL_VISIBLE
bool operator== (Timer const &other) const SYMBOL_VISIBLE

Public Members

size_t num_periods
Value period
Value start

Friends

friend std::ostream & operator<< (std::ostream &os, Timer const &timer) SYMBOL_VISIBLE
struct grenade::vx::vertex::PlasticityRule::Timer
#include <plasticity_rule.h>

Timing information for execution of the rule.

Public Functions

bool operator!= (Timer const &other) const SYMBOL_VISIBLE
bool operator== (Timer const &other) const SYMBOL_VISIBLE

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 class cereal::access
friend std::ostream & operator<< (std::ostream &os, Timer const &timer) SYMBOL_VISIBLE
struct grenade::vx::network::RoutingResult::TimingStatistics
#include <routing_result.h>

Public Members

std::chrono::microseconds routing
struct grenade::vx::vertex::Transformation
#include <transformation.h>

Formatted data input from memory.

Public Functions

Transformation() = default
explicit  Transformation (std::unique_ptr< Function > function) SYMBOL_VISIBLE

Construct Transformation with specified function.

Parameters

function – Function to apply on transformation

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

Apply transformation.

Parameters

value – Input value

Returns

Output value

std::vector< Port > inputs () const SYMBOL_VISIBLE
bool operator!= (Transformation const &other) const SYMBOL_VISIBLE
bool operator== (Transformation const &other) const SYMBOL_VISIBLE
Port output () const SYMBOL_VISIBLE

Public Static Attributes

static constexpr static bool can_connect_different_execution_instances   = true
static constexpr static 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 class cereal::access
friend std::ostream & operator<< (std::ostream &os, Transformation const &config) SYMBOL_VISIBLE
struct grenade::vx::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)
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::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::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)
template<typename Vertex>
struct grenade::vx::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::detail::CheckVertexConcept< std::variant< Vertex… > >

Public Static Attributes

template<typename V> static constexpr static bool has_can_connect_different_execution_instances_v   =     has_can_connect_different_execution_instances<V>::value
template<typename V> static constexpr static bool has_inputs_v   = has_inputs<V>::value
template<typename V> static constexpr static bool has_output_v   = has_output<V>::value
template<typename V> static constexpr static bool has_variadic_input_v   = has_variadic_input<V>::value
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 SYMBOL_VISIBLE
UnsignedWeight toInhibitory () const SYMBOL_VISIBLE
namespace cereal
namespace grenade
namespace grenade::vx

Typedefs

template<typename T>
using TimedDataSequence = std::vector<TimedData<T>>
typedef std::vector<haldls::vx::v3::MADCSampleFromChip> TimedMADCSampleFromChipSequence

Sequence of time-annotated from-chip MADC events.

typedef std::vector<haldls::vx::v3::SpikeFromChip> TimedSpikeFromChipSequence

Sequence of time-annotated from-chip spike events.

typedef std::vector<TimedSpike> TimedSpikeSequence

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::Subtraction, vertex::PlasticityRule, vertex::BackgroundSpikeSource, vertex::ArgMax, vertex::CrossbarL2Input, vertex::CrossbarL2Output, vertex::CrossbarNode, vertex::PADIBus, vertex::SynapseDriver, vertex::SynapseArrayViewSparse, vertex::SynapseArrayView, vertex::ConvertingReLU, vertex::ReLU, vertex::Addition, vertex::ExternalInput, vertex::DataInput, vertex::DataOutput, vertex::Transformation, vertex::NeuronView, vertex::NeuronEventOutputView, vertex::MADCReadoutView, vertex::CADCMembraneReadoutView> Vertex

Vertex configuration as variant over possible types.

Enums

enum 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 TimedSpikeSequence
enumerator TimedSpikeFromChipSequence
enumerator TimedMADCSampleFromChipSequence
enumerator DataTimedSpikeSequence
enumerator DataTimedSpikeFromChipSequence
enumerator DataTimedMADCSampleFromChipSequence
enumerator DataInt8
enumerator DataUInt5
enumerator DataUInt32
enumerator CrossbarInputLabel
enumerator CrossbarOutputLabel
enumerator SynapseDriverInputLabel

Functions

halco::common::typed_array< int8_t, halco::hicann_dls::vx::v3::NeuronColumnOnDLS > from_vector_unit_row (haldls::vx::v3::PPUMemoryBlock const &values) SYMBOL_VISIBLE

Convert PPUMemoryBlock to column byte values.

std::string get_include_paths () SYMBOL_VISIBLE

Get include paths.

std::string get_libnux_runtime (std::string const &name) SYMBOL_VISIBLE

Get full path to libnux runtime.

Parameters

name – Name to search for

std::string get_library_paths () SYMBOL_VISIBLE

Get library paths.

std::string get_linker_file (std::string const &name) SYMBOL_VISIBLE

Get full path to linker file.

Parameters

name – Name to search for

std::string get_program_base_source () SYMBOL_VISIBLE

Get full path to PPU program source.

std::ostream & operator<< (std::ostream &os, ConnectionType const &type) SYMBOL_VISIBLE
std::ostream & operator<< (std::ostream &os, Projection::ReceptorType const &receptor_type) SYMBOL_VISIBLE
IODataList run (JITGraphExecutor &executor, Graph const &graph, IODataList const &input, JITGraphExecutor::ChipConfigs const &initial_config, bool only_unconnected_output=true) SYMBOL_VISIBLE

Run the specified graph with specified inputs on the supplied executor.

Parameters

  • executor – Executor to use

  • graph – Graph to execute

  • input – List of input values to use

  • initial_config – Map of initial configuration

  • only_unconnected_output – Whether to return only values to output vertices without out edges

IODataList run (JITGraphExecutor &executor, Graph const &graph, IODataList const &input, JITGraphExecutor::ChipConfigs const &initial_config, JITGraphExecutor::PlaybackHooks &playback_hooks, bool only_unconnected_output=true) SYMBOL_VISIBLE

Run the specified graph with specified inputs on the supplied executor.

Parameters

  • executor – Executor to use

  • graph – Graph to execute

  • input – List of input values to use

  • initial_config – Map of initial configuration

  • playback_hooks – List of playback sequence collections to be inserted at specified execution instances

  • only_unconnected_output – Whether to return only values to output vertices without out edges

IODataMap run (JITGraphExecutor &executor, Graph const &graph, IODataMap const &input, JITGraphExecutor::ChipConfigs const &initial_config) SYMBOL_VISIBLE

Run the specified graph with specified inputs on the supplied executor.

Parameters

  • executor – Executor to use

  • graph – Graph to execute

  • input – List of input values to use

  • initial_config – Map of initial configuration

IODataMap run (JITGraphExecutor &executor, Graph const &graph, IODataMap const &input, JITGraphExecutor::ChipConfigs const &initial_config, JITGraphExecutor::PlaybackHooks &playback_hooks) SYMBOL_VISIBLE

Run the specified graph with specified inputs on the supplied executor.

Parameters

  • executor – Executor to use

  • graph – Graph to execute

  • input – List of input values to use

  • initial_config – Map of initial configuration

  • playback_hooks – Map of playback sequence collections to be inserted at specified execution instances

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

haldls::vx::v3::PPUMemoryBlock to_vector_unit_row (halco::common::typed_array< int8_t, halco::hicann_dls::vx::v3::NeuronColumnOnDLS > const &values) SYMBOL_VISIBLE

Convert column byte values to PPUMemoryBlock.

Variables

constexpr auto can_connect_different_execution_instances = std::array{ConnectionType::DataUInt5, ConnectionType::DataInt8, ConnectionType::DataTimedSpikeSequence, ConnectionType::DataTimedSpikeFromChipSequence, ConnectionType::DataUInt32, ConnectionType::DataTimedMADCSampleFromChipSequence}

Only memory operations are allowed to connect between different execution instances.

namespace grenade::vx::backend

Functions

stadls::vx::RunTimeInfo run (Connection &connection, stadls::vx::v3::PlaybackProgram &&program) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE

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 compute
namespace grenade::vx::coordinate

Functions

size_t hash_value (ExecutionInstance const &e) SYMBOL_VISIBLE
namespace grenade::vx::detail

Typedefs

typedef graph_type::edge_descriptor edge_descriptor
typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::bidirectionalS, boost::no_property, boost::no_property> graph_type

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_type::vertex_descriptor vertex_descriptor
namespace generator
namespace grenade::vx::network

Typedefs

typedef std::vector<ConnectumConnection> Connectum

Functions

cls def(pybind11::init< ::grenade::vx::network::SynapseDriverOnDLSManager::AllocationPolicyGreedy >(), pybind11::arg("value")=::grenade::vx::network::SynapseDriverOnDLSManager::AllocationPolicyGreedy()) .def(pybind11 parent attr ("RoutingOptions").attr("AllocationPolicy")
NetworkGraph build_network_graph (std::shared_ptr< Network > const  &network, RoutingResult const  &routing_result) SYMBOL_VISIBLE

Build a hardware graph representation for a given network with the given routing result.

Parameters

  • network – Network for which to build hardware graph representation

  • routing_result – Routing result to use matching the given network

RoutingResult build_routing (std::shared_ptr< Network > const &network, std::optional< RoutingOptions > const &options=std::nullopt) SYMBOL_VISIBLE

Route given network.

Parameters

network – Placed but not routed network to use

Returns

Routing result containing placement and label information for given network

parent def ("extract_cadc_samples", extract_cadc_samples, pybind11::arg("data"), pybind11::arg("network_graph"))
parent def ("extract_madc_samples", extract_madc_samples, pybind11::arg("data"), pybind11::arg("network_graph"))
parent def ("extract_neuron_spikes", extract_neuron_spikes, pybind11::arg("data"), pybind11::arg("network_graph"))
parent def ("run", [](::pyhxcomm::Handle< backend::Connection > &conn, lola::vx::v3::Chip const &config, network::NetworkGraph const &network_graph, IODataMap const &inputs) -> IODataMap { return network::run(conn.get(), config, network_graph, inputs);}, pybind11::arg("connection"), pybind11::arg("config"), pybind11::arg("network_graph"), pybind11::arg("inputs"))
parent def ("run", [](::pyhxcomm::Handle< backend::Connection > &conn, lola::vx::v3::Chip const &config, network::NetworkGraph const &network_graph, IODataMap const &inputs, ExecutionInstancePlaybackHooks &playback_hooks) -> IODataMap { return network::run(conn.get(), config, network_graph, inputs, playback_hooks);}, pybind11::arg("connection"), pybind11::arg("config"), pybind11::arg("network_graph"), pybind11::arg("inputs"), pybind11::arg("playback_hooks"))
parent def ("run", [](::pyhxcomm::Handle< JITGraphExecutor > &conn, lola::vx::v3::Chip const &config, network::NetworkGraph const &network_graph, IODataMap const &inputs) -> IODataMap { return network::run(conn.get(), config, network_graph, inputs);}, pybind11::arg("connection"), pybind11::arg("config"), pybind11::arg("network_graph"), pybind11::arg("inputs"))
parent def ("run", [](::pyhxcomm::Handle< JITGraphExecutor > &conn, lola::vx::v3::Chip const &config, network::NetworkGraph const &network_graph, IODataMap const &inputs, ExecutionInstancePlaybackHooks &playback_hooks) -> IODataMap { return network::run(conn.get(), config, network_graph, inputs, playback_hooks);}, pybind11::arg("connection"), pybind11::arg("config"), pybind11::arg("network_graph"), pybind11::arg("inputs"), pybind11::arg("playback_hooks"))
class grenade::vx::network::InputGenerator done () SYMBOL_VISIBLE
std::vector< std::vector< std::tuple< haldls::vx::v3::ChipTime, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS, Int8 > > > extract_cadc_samples (IODataMap const &data, NetworkGraph const &network_graph) SYMBOL_VISIBLE

Extract CADC samples to be recorded for a network.

Parameters

  • data – Data containing CADC samples

  • network_graph – Network graph to use for vertex descriptor lookup of the CADC samples

Returns

Time-series CADC sample data per batch entry. Samples are sorted by their ChipTime per batch-entry and contain their corresponding AtomicNeuronOnDLS location alongside the ADC value.

std::vector< std::vector< std::pair< haldls::vx::v3::ChipTime, haldls::vx::v3::MADCSampleFromChip::Value > > > extract_madc_samples (IODataMap const &data, NetworkGraph const &network_graph) SYMBOL_VISIBLE

Extract MADC samples to be recorded for a network.

Parameters

  • data – Data containing MADC samples

  • network_graph – Network graph to use for vertex descriptor lookup of the MADC samples

Returns

Time-series MADC sample data per batch entry

std::vector< std::map< halco::hicann_dls::vx::v3::AtomicNeuronOnDLS, std::vector< haldls::vx::v3::ChipTime > > > extract_neuron_spikes (IODataMap const &data, NetworkGraph const &network_graph) SYMBOL_VISIBLE

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 spike labels to neurons

Returns

Time-series neuron spike data per batch entry

NetworkGraphStatistics extract_statistics (NetworkGraph const &network_graph) SYMBOL_VISIBLE

Extract statistics from network graph.

Connectum generate_connectum_from_abstract_network (NetworkGraph const &network_graph) SYMBOL_VISIBLE
Connectum generate_connectum_from_hardware_network (NetworkGraph const &network_graph) SYMBOL_VISIBLE
bool operator!= (Projection const &other) const SYMBOL_VISIBLE
std::ostream & operator<< (std::ostream &os, Projection const &projection) SYMBOL_VISIBLE
std::ostream & operator<< (std::ostream &os, SynapseDriverOnPADIBusManager::AllocationPolicy const &value) SYMBOL_VISIBLE
bool requires_routing (std::shared_ptr< Network > const &current, std::shared_ptr< Network > const &old) SYMBOL_VISIBLE

Get whether the current network requires routing compared to the old network.

Parameters

  • current – Current network

  • old – Old network

Returns

Boolean value

IODataMap run (backend::Connection &connection, lola::vx::v3::Chip const &config, NetworkGraph const &network_graph, IODataMap const &inputs) SYMBOL_VISIBLE

Execute the given network hardware graph and fetch results.

Parameters

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

  • network_graph – Network hardware graph to run

  • config – Static chip configuration to use

  • inputs – Inputs to use

Returns

Run time information

IODataMap run (backend::Connection &connection, lola::vx::v3::Chip const &config, NetworkGraph const &network_graph, IODataMap const &inputs, ExecutionInstancePlaybackHooks &playback_hooks) SYMBOL_VISIBLE

Execute the given network hardware graph and fetch results.

Parameters

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

  • network_graph – Network hardware graph to run

  • config – Static chip configuration to use

  • inputs – Inputs to use

  • playback_hooks – Optional playback sequences to inject

Returns

Run time information

IODataMap run (hxcomm::vx::ConnectionVariant &connection, lola::vx::v3::Chip const &config, NetworkGraph const &network_graph, IODataMap const &inputs) SYMBOL_VISIBLE

Execute the given network hardware graph and fetch results.

Parameters

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

  • network_graph – Network hardware graph to run

  • config – Static chip configuration to use

  • inputs – Inputs to use

Returns

Run time information

IODataMap run (hxcomm::vx::ConnectionVariant &connection, lola::vx::v3::Chip const &config, NetworkGraph const &network_graph, IODataMap const &inputs, ExecutionInstancePlaybackHooks &playback_hooks) SYMBOL_VISIBLE

Execute the given network hardware graph and fetch results.

Parameters

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

  • network_graph – Network hardware graph to run

  • config – Static chip configuration to use

  • inputs – Inputs to use

  • playback_hooks – Optional playback sequences to inject

Returns

Run time information

IODataMap run (JITGraphExecutor &executor, lola::vx::v3::Chip const &config, NetworkGraph const &network_graph, IODataMap const &inputs) SYMBOL_VISIBLE

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

  • inputs – Inputs to use

Returns

Run time information

IODataMap run (JITGraphExecutor &executor, lola::vx::v3::Chip const &config, NetworkGraph const &network_graph, IODataMap const &inputs, ExecutionInstancePlaybackHooks &playback_hooks) SYMBOL_VISIBLE

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

  • inputs – Inputs to use

  • playback_hooks – Optional playback sequences to inject

Returns

Run time information

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

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

Variables

auto const extract_cadc_samples = [convert_ms](                                       grenade::vx::IODataMap const& data,                                       grenade::vx::network::NetworkGraph const& network_graph) { auto const samples = grenade::vx::network::extract_cadc_samples(data, network_graph); std::vector<       std::tuple<pybind11::array_t<float>, pybind11::array_t<int>, pybind11::array_t<int>>>       ret(samples.size()); for (size_t b = 0; b < samples.size(); ++b) { auto const cadc_samples = samples.at(b); if (cadc_samples.empty()) { ret.at(b) = std::make_tuple(         pybind11::array_t<float>(0), pybind11::array_t<int>(0),         pybind11::array_t<int>(0)); continue; } pybind11::array_t<float> times({static_cast<pybind11::ssize_t>(cadc_samples.size())}); pybind11::array_t<int> neurons({static_cast<pybind11::ssize_t>(cadc_samples.size())}); pybind11::array_t<int> values({static_cast<pybind11::ssize_t>(cadc_samples.size())}); for (size_t i = 0; i < cadc_samples.size(); ++i) { auto const& sample = cadc_samples.at(i); times.mutable_at(i) = convert_ms(std::get<0>(sample)); neurons.mutable_at(i) = std::get<1>(sample).toEnum().value(); values.mutable_at(i) = std::get<2>(sample).value(); } ret.at(b) = std::make_tuple(times, neurons, values); } return ret; }
auto const extract_madc_samples = [convert_ms](                                       grenade::vx::IODataMap const& data,                                       grenade::vx::network::NetworkGraph const& network_graph) { auto const samples = grenade::vx::network::extract_madc_samples(data, network_graph); std::vector<std::pair<pybind11::array_t<float>, pybind11::array_t<int>>> ret(       samples.size()); for (size_t b = 0; b < samples.size(); ++b) { auto const madc_samples = samples.at(b); pybind11::array_t<float> times({static_cast<pybind11::ssize_t>(madc_samples.size())}); pybind11::array_t<int> values({static_cast<pybind11::ssize_t>(madc_samples.size())}); for (size_t i = 0; i < madc_samples.size(); ++i) { auto const& sample = madc_samples.at(i); times.mutable_at(i) = convert_ms(sample.first); values.mutable_at(i) = sample.second.toEnum().value(); } ret.at(b) = std::make_pair(times, values); } return ret; }
auto const extract_neuron_spikes = [convert_ms](         grenade::vx::IODataMap const& data,         grenade::vx::network::NetworkGraph const& network_graph) {       auto const spikes = grenade::vx::network::extract_neuron_spikes(data, network_graph);       std::vector<std::map<int, pybind11::array_t<double>>> ret(spikes.size());       for (size_t b = 0; b < spikes.size(); ++b) {        for (auto const& [neuron, times] : spikes.at(b)) {         pybind11::array_t<double> pytimes(             {static_cast<pybind11::ssize_t>(times.size())});         for (size_t i = 0; i < times.size(); ++i) {          pytimes.mutable_at(i) = convert_ms(times.at(i));         }         ret.at(b)[neuron.toEnum().value()] = pytimes;        }       }       return ret;     }

PyNN’s format expects times in floating-point ms, neurons as integer representation of the AtomicNeuron enum value and MADC sample values as integer values.

Currently, only batch-size one is supported, i.e. one time sequence.

IODataMap m_data = {}
NetworkGraph const &m_network_graph
struct grenade::vx::network::Projection operator   ==(Projection const& other) const SYMBOL_VISIBLE
namespace detail
namespace grenade::vx::ppu

Enums

enum Status

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

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 transformation
namespace vertex
namespace halco
namespace common
namespace detail
namespace hate
namespace log4cxx
namespace lola
namespace vx
namespace v3
namespace std

STL namespace.

file cerealization.h
#include “haldls/cerealization.tcc”

Defines

EXPLICIT_INSTANTIATE_CEREAL_LOAD_SAVE(CLASS_NAME)
file connection.h
#include “hate/visibility.h”#include “hxcomm/common/connection_time_info.h”#include “hxcomm/vx/connection_variant.h”#include “stadls/vx/run_time_info.h”#include “stadls/vx/v3/init_generator.h”#include “stadls/vx/v3/playback_program.h”#include “stadls/vx/v3/reinit_stack_entry.h”#include <optional>#include <string>#include <variant>
file run.h
#include “grenade/vx/backend/connection.h”#include “hate/visibility.h”#include “stadls/vx/run_time_info.h”#include “stadls/vx/v3/playback_program.h”
file run.h
#include “grenade/vx/backend/connection.h”#include “grenade/vx/execution_instance_playback_hooks.h”#include “grenade/vx/genpybind.h”#include “grenade/vx/io_data_map.h”#include “grenade/vx/jit_graph_executor.h”#include “grenade/vx/network/network_graph.h”#include “hate/visibility.h”#include “hxcomm/vx/connection_variant.h”
file addition.h
#include <vector>#include “grenade/vx/graph.h”#include “grenade/vx/types.h”
file addition.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>
file argmax.h
#include <vector>#include “grenade/vx/graph.h”#include “grenade/vx/types.h”
file argmax.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>
file conv1d.h
#include <vector>#include <gtest/gtest_prod.h>#include “grenade/vx/compute/mac.h”#include “grenade/vx/types.h”#include “haldls/vx/v3/timer.h”#include “grenade/vx/compute/conv1d.tcc”
file converting_relu.h
#include <vector>#include “grenade/vx/graph.h”#include “grenade/vx/types.h”
file converting_relu.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>
file mac.h
#include <vector>#include <gtest/gtest_prod.h>#include “grenade/vx/graph.h”#include “grenade/vx/jit_graph_executor.h”#include “grenade/vx/types.h”#include “grenade/vx/vertex/synapse_array_view.h”#include “halco/common/geometry.h”#include “haldls/vx/v3/event.h”#include “haldls/vx/v3/synapse_driver.h”#include “haldls/vx/v3/timer.h”#include “lola/vx/v3/synapse.h”#include “grenade/vx/compute/mac.tcc”
file relu.h
#include <vector>#include “grenade/vx/graph.h”#include “grenade/vx/types.h”
file relu.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>
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 “grenade/vx/io_data_list.h”#include “hate/visibility.h”#include <list>#include <variant>
file connection_state_storage.h
#include “fisch/vx/word_access/type/omnibus.h”#include “lola/vx/v3/chip.h”#include “stadls/vx/v3/reinit_stack_entry.h”#include <vector>
file connection_type.h
#include “hate/visibility.h”#include <array>#include <iosfwd>
file event.h
#include “grenade/vx/genpybind.h”#include “haldls/vx/event.h”#include “haldls/vx/timer.h”#include “haldls/vx/v3/event.h”#include “haldls/vx/v3/timer.h”#include “hate/visibility.h”#include <iosfwd>#include <variant>#include <vector>#include “grenade/vx/event.tcc”
file execution_instance.h
#include “grenade/vx/genpybind.h”#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/v3/chip.h”#include “hate/visibility.h”#include <iosfwd>#include <stddef.h>
file execution_instance_builder.h
#include <atomic>#include <optional>#include <set>#include <vector>#include “grenade/vx/execution_instance.h”#include “grenade/vx/execution_instance_playback_hooks.h”#include “grenade/vx/generator/neuron_reset_mask.h”#include “grenade/vx/graph.h”#include “grenade/vx/io_data_map.h”#include “grenade/vx/types.h”#include “halco/hicann-dls/vx/v3/chip.h”#include “haldls/vx/v3/ppu.h”#include “haldls/vx/v3/synapse_driver.h”#include “hate/visibility.h”#include “lola/vx/v3/cadc.h”#include “lola/vx/v3/ppu.h”#include “lola/vx/v3/synapse.h”#include “stadls/vx/v3/playback_generator.h”#include “stadls/vx/v3/playback_program.h”#include “stadls/vx/v3/playback_program_builder.h”
file execution_instance_config_visitor.h
#include “grenade/vx/execution_instance.h”#include “grenade/vx/graph.h”#include “grenade/vx/ppu/synapse_array_view_handle.h”#include “grenade/vx/vertex/plasticity_rule.h”#include “halco/hicann-dls/vx/v3/chip.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “halco/hicann-dls/vx/v3/synapse.h”#include “hate/visibility.h”#include “lola/vx/v3/chip.h”#include “stadls/vx/v3/playback_program_builder.h”#include <optional>#include <tuple>#include <vector>
file execution_instance_node.h
#include <mutex>#include <tbb/flow_graph.h>#include “grenade/vx/connection_state_storage.h”#include “grenade/vx/execution_instance_builder.h”#include “grenade/vx/execution_instance_playback_hooks.h”#include “grenade/vx/graph.h”#include “grenade/vx/io_data_map.h”#include “hate/visibility.h”#include “lola/vx/v3/chip.h”
file execution_instance_playback_hooks.h
#include “grenade/vx/genpybind.h”#include “stadls/vx/v3/playback_program_builder.h”
file madc.h
#include “hate/nil.h”#include “hate/visibility.h”#include “stadls/vx/v3/playback_generator.h”
file neuron_reset_mask.h
#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “hate/nil.h”#include “hate/visibility.h”#include “stadls/vx/v3/playback_generator.h”#include “stadls/vx/v3/playback_program_builder.h”
file ppu.h
#include “grenade/vx/ppu/status.h”#include “halco/hicann-dls/vx/v3/ppu.h”#include “hate/nil.h”#include “hate/visibility.h”#include “stadls/vx/v3/playback_generator.h”
file ppu.h
#include “halco/common/typed_array.h”#include “haldls/vx/v3/neuron.h”#include “haldls/vx/v3/ppu.h”#include “hate/visibility.h”#include “lola/vx/v3/ppu.h”#include <cstdint>#include <filesystem>#include <mutex>#include <string>#include <vector>
file timed_spike_sequence.h
#include “grenade/vx/event.h”#include “hate/nil.h”#include “hate/visibility.h”#include “stadls/vx/v3/playback_generator.h”
file genpybind.h
#include <genpybind.h>

Defines

GENPYBIND_TAG_GRENADE_VX
file graph.h
#include “grenade/vx/execution_instance.h”#include “grenade/vx/genpybind.h”#include “grenade/vx/graph_representation.h”#include “grenade/vx/port_restriction.h”#include “grenade/vx/vertex.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/v3/chip.h”#include “hate/visibility.h”#include <cstddef>#include <iosfwd>#include <map>#include <memory>#include <optional>#include <unordered_map>#include <vector>#include <boost/bimap.hpp>#include <boost/bimap/multiset_of.hpp>#include <boost/bimap/set_of.hpp>#include <boost/bimap/unordered_set_of.hpp>#include <boost/graph/adjacency_list.hpp>#include <boost/smart_ptr/local_shared_ptr.hpp>#include “grenade/vx/graph.tcc”
file graph_representation.h
#include <boost/graph/adjacency_list.hpp>
file grenade.h
#include “grenade/vx/event.h”#include “grenade/vx/execution_instance.h”#include “grenade/vx/graph.h”#include “grenade/vx/io_data_map.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/population.h”#include “grenade/vx/network/projection.h”#include “grenade/vx/network/routing_builder.h”#include “grenade/vx/network/routing_options.h”#include “grenade/vx/network/routing_result.h”#include “grenade/vx/network/run.h”
file input.h
#include “grenade/vx/graph.h”#include “grenade/vx/port_restriction.h”#include “hate/visibility.h”#include <iosfwd>#include <optional>
file io_data_list.h
#include “grenade/vx/event.h”#include “grenade/vx/io_data_map.h”#include “grenade/vx/types.h”#include “hate/visibility.h”#include <list>#include <vector>
file io_data_map.h
#include “grenade/vx/event.h”#include “grenade/vx/execution_instance.h”#include “grenade/vx/genpybind.h”#include “grenade/vx/graph_representation.h”#include “grenade/vx/port.h”#include “grenade/vx/types.h”#include “haldls/vx/v3/timer.h”#include “hate/visibility.h”#include <map>#include <memory>#include <mutex>#include <unordered_map>#include <variant>
file jit_graph_executor.h
#include <map>#include <unordered_map>#include “grenade/vx/backend/connection.h”#include “grenade/vx/connection_state_storage.h”#include “grenade/vx/execution_instance.h”#include “grenade/vx/execution_instance_playback_hooks.h”#include “halco/hicann-dls/vx/v3/chip.h”#include “hate/visibility.h”#include “lola/vx/v3/chip.h”
file cadc_recording.h
#include “grenade/vx/genpybind.h”#include “grenade/vx/network/population.h”#include “hate/visibility.h”#include “lola/vx/v3/neuron.h”
file connectum.h
#include “grenade/vx/graph.h”#include “grenade/vx/network/population.h”#include “grenade/vx/network/projection.h”#include “haldls/vx/v3/event.h”#include “hate/visibility.h”#include <iosfwd>#include <variant>#include <vector>
file source_on_padi_bus_manager.h
#include “grenade/vx/network/source_on_padi_bus_manager.h”#include “grenade/vx/network/synapse_driver_on_dls_manager.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “halco/hicann-dls/vx/v3/padi.h”#include “hate/visibility.h”#include <optional>#include <set>#include <vector>
file source_on_padi_bus_manager.h
#include “grenade/vx/network/population.h”#include “grenade/vx/network/projection.h”#include “grenade/vx/network/synapse_driver_on_dls_manager.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “halco/hicann-dls/vx/v3/padi.h”#include “halco/hicann-dls/vx/v3/synapse_driver.h”#include “haldls/vx/v3/synapse_driver.h”#include “hate/visibility.h”#include <optional>#include <set>#include <vector>
file synapse_driver_on_dls_manager.h
#include “grenade/vx/network/synapse_driver_on_dls_manager.h”#include “grenade/vx/network/synapse_driver_on_padi_bus_manager.h”#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/v3/padi.h”#include “halco/hicann-dls/vx/v3/synapse_driver.h”#include “haldls/vx/v3/synapse_driver.h”#include “hate/visibility.h”#include <set>#include <vector>
file synapse_driver_on_dls_manager.h
#include “grenade/vx/network/synapse_driver_on_padi_bus_manager.h”#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/v3/padi.h”#include “halco/hicann-dls/vx/v3/synapse_driver.h”#include “haldls/vx/v3/synapse_driver.h”#include “hate/visibility.h”#include <chrono>#include <optional>#include <set>#include <vector>
file synapse_driver_on_padi_bus_manager.h
#include “grenade/vx/network/synapse_driver_on_padi_bus_manager.h”#include “hate/visibility.h”#include <map>#include <set>#include <vector>
file synapse_driver_on_padi_bus_manager.h
#include “halco/hicann-dls/vx/v3/synapse_driver.h”#include “haldls/vx/v3/padi.h”#include “haldls/vx/v3/synapse_driver.h”#include “hate/visibility.h”#include <chrono>#include <iosfwd>#include <map>#include <optional>#include <set>#include <variant>#include <vector>
file exception.h
#include “hate/visibility.h”#include <exception>#include <string>
file extract_output.h
#include “grenade/vx/genpybind.h”#include “grenade/vx/io_data_map.h”#include “grenade/vx/network/network.h”#include “grenade/vx/network/network_graph.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “haldls/vx/v3/systime.h”
file generate_input.h
#include “grenade/vx/event.h”#include “grenade/vx/genpybind.h”#include “grenade/vx/io_data_map.h”#include “grenade/vx/network/network_graph.h”

Functions

void add (std::vector< std::vector< std::vector< TimedSpike::Time >>> const &times, PopulationDescriptor population) SYMBOL_VISIBLE
void add (std::vector< std::vector< TimedSpike::Time >> const &times, PopulationDescriptor population) SYMBOL_VISIBLE
void add (std::vector< TimedSpike::Time > const &times, PopulationDescriptor population) SYMBOL_VISIBLE
parent def ("add", [convert_ms](GENPYBIND_PARENT_TYPE &self, std::vector< float > const &times, grenade::vx::network::PopulationDescriptor const population) { std::vector< grenade::vx::TimedSpike::Time > gtimes;gtimes.reserve(times.size());std::transform(times.begin(), times.end(), std::back_inserter(gtimes), convert_ms);self.add(gtimes, population);}, parent->py::arg("times"), parent->py::arg("population"))
parent def ("add", [convert_ms](GENPYBIND_PARENT_TYPE &self, std::vector< std::vector< float >> const &times, grenade::vx::network::PopulationDescriptor const population) { std::vector< std::vector< grenade::vx::TimedSpike::Time >> gtimes;gtimes.resize(times.size());for(size_t i=0;auto &gt :gtimes) { gt.reserve(times.at(i).size());i++;} for(size_t i=0;auto &t :times) { std::transform(t.begin(), t.end(), std::back_inserter(gtimes.at(i)), convert_ms);i++;} self.add(gtimes, population);}, parent->py::arg("times"), parent->py::arg("population"))
parent def ("add", [convert_ms](GENPYBIND_PARENT_TYPE &self, std::vector< std::vector< std::vector< float >>> const &times, grenade::vx::network::PopulationDescriptor const population) { std::vector< std::vector< std::vector< grenade::vx::TimedSpike::Time >>> gtimes;gtimes.resize(times.size());for(size_t b=0;auto &gt_b :gtimes) { gt_b.resize(times.at(b).size());for(size_t i=0;auto &gt :gt_b) { gt.reserve(times.at(b).at(i).size());i++;} for(size_t i=0;auto &t :times.at(b)) { std::transform(t.begin(), t.end(), std::back_inserter(gtimes.at(b).at(i)), convert_ms);i++;} b++;} self.add(gtimes, population);}, parent->py::arg("times"), parent->py::arg("population"))
InputGenerator (NetworkGraph const &network_graph, size_t batch_size=1) SYMBOL_VISIBLE
file madc_recording.h
#include “grenade/vx/genpybind.h”#include “grenade/vx/network/population.h”#include “hate/visibility.h”#include “lola/vx/v3/neuron.h”
file network.h
#include “grenade/vx/genpybind.h”#include “grenade/vx/network/cadc_recording.h”#include “grenade/vx/network/madc_recording.h”#include “grenade/vx/network/plasticity_rule.h”#include “grenade/vx/network/population.h”#include “grenade/vx/network/projection.h”#include “hate/visibility.h”#include <chrono>#include <iosfwd>#include <map>#include <memory>#include <variant>
file network_builder.h
#include “grenade/vx/genpybind.h”#include “grenade/vx/network/madc_recording.h”#include “grenade/vx/network/network.h”#include “grenade/vx/network/plasticity_rule.h”#include “grenade/vx/network/population.h”#include “grenade/vx/network/projection.h”#include “hate/visibility.h”#include <chrono>#include <map>#include <memory>#include <variant>
file network_graph.h
#include “grenade/vx/genpybind.h”#include “grenade/vx/graph.h”#include “grenade/vx/network/network.h”#include “grenade/vx/network/population.h”#include “hate/visibility.h”#include <chrono>#include <optional>#include <vector>
file network_graph_builder.h
#include “grenade/vx/genpybind.h”#include “grenade/vx/graph.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.h”#include “grenade/vx/network/projection.h”#include “grenade/vx/network/routing_result.h”#include “halco/hicann-dls/vx/v3/background.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “halco/hicann-dls/vx/v3/padi.h”#include “halco/hicann-dls/vx/v3/synapse.h”#include “halco/hicann-dls/vx/v3/synapse_driver.h”#include “hate/visibility.h”#include <map>#include <memory>#include <optional>#include <vector>
file network_graph_statistics.h
#include “grenade/vx/genpybind.h”#include “hate/visibility.h”#include <chrono>#include <cstddef>#include <iosfwd>
file plasticity_rule.h
#include “grenade/vx/genpybind.h”#include “grenade/vx/network/projection.h”#include “halco/common/geometry.h”#include “hate/visibility.h”#include <string>#include <vector>
file plasticity_rule.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “halco/common/geometry.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <iosfwd>#include <optional>#include <vector>
file population.h
#include “grenade/vx/genpybind.h”#include “halco/hicann-dls/vx/v3/background.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “haldls/vx/v3/background.h”#include “hate/visibility.h”#include “lola/vx/v3/neuron.h”#include <cstddef>#include <iosfwd>#include <vector>
file projection.h
#include “grenade/vx/genpybind.h”#include “grenade/vx/graph.h”#include “grenade/vx/network/population.h”#include “halco/common/geometry.h”#include “hate/visibility.h”#include “lola/vx/v3/synapse.h”#include <vector>
file routing_builder.h
#include “grenade/vx/genpybind.h”#include “grenade/vx/network/network.h”#include “grenade/vx/network/population.h”#include “grenade/vx/network/projection.h”#include “grenade/vx/network/routing_constraints.h”#include “grenade/vx/network/routing_options.h”#include “grenade/vx/network/routing_result.h”#include “grenade/vx/network/source_on_padi_bus_manager.h”#include “grenade/vx/network/synapse_driver_on_dls_manager.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “halco/hicann-dls/vx/v3/padi.h”#include “halco/hicann-dls/vx/v3/synapse.h”#include “halco/hicann-dls/vx/v3/synapse_driver.h”#include “haldls/vx/v3/event.h”#include “haldls/vx/v3/neuron.h”#include “haldls/vx/v3/synapse_driver.h”#include “hate/visibility.h”#include “lola/vx/v3/synapse.h”#include <deque>#include <map>#include <memory>#include <optional>#include <unordered_set>#include <variant>#include <vector>
file routing_constraints.h
#include “grenade/vx/network/population.h”#include “grenade/vx/network/projection.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “halco/hicann-dls/vx/v3/padi.h”#include “hate/visibility.h”#include <map>#include <set>#include <utility>#include <vector>
file routing_options.h
#include “grenade/vx/genpybind.h”#include “grenade/vx/network/synapse_driver_on_dls_manager.h”#include “lola/vx/v3/synapse.h”#include <chrono>#include <iosfwd>#include <optional>
file routing_result.h
#include “grenade/vx/genpybind.h”#include “grenade/vx/network/population.h”#include “grenade/vx/network/projection.h”#include “halco/hicann-dls/vx/v3/synapse.h”#include “halco/hicann-dls/vx/v3/synapse_driver.h”#include “haldls/vx/v3/event.h”#include “haldls/vx/v3/neuron.h”#include “haldls/vx/v3/synapse_driver.h”#include “hate/visibility.h”#include “lola/vx/v3/synapse.h”#include <chrono>#include <iosfwd>#include <map>#include <vector>
file port.h
#include <cstddef>#include <iosfwd>#include “grenade/vx/connection_type.h”#include “hate/visibility.h”
file port_restriction.h
#include “hate/visibility.h”#include <cstddef>#include <cstdint>#include <iosfwd>#include <optional>
file extmem.h
#include <cstddef>
file status.h
#include <cstdint>
file synapse_array_view_handle.h
#include “hate/bitset.h”
file ppu_program_generator.h
#include “grenade/vx/ppu/synapse_array_view_handle.h”#include “grenade/vx/vertex/plasticity_rule.h”#include “halco/hicann-dls/vx/v3/synapse.h”#include “halco/hicann-dls/vx/v3/synram.h”#include “hate/visibility.h”#include <tuple>#include <vector>
file pygrenade.h
#include “grenade/vx/genpybind.h”#include “grenade/vx/grenade.h”
file range_split.h
#include <cstddef>#include <vector>#include “hate/visibility.h”
file single_chip_execution_instance_manager.h
#include “grenade/vx/execution_instance.h”#include “halco/hicann-dls/vx/v3/chip.h”#include “hate/visibility.h”
file supports_input_from.h
#include “hate/type_traits.h”#include <optional>
file concatenation.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/vertex/transformation.h”#include <vector>
file mac_spiketrain_generator.h
#include “grenade/vx/port.h”#include “grenade/vx/vertex/transformation.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/v3/chip.h”#include “halco/hicann-dls/vx/v3/synapse_driver.h”#include “haldls/vx/v3/event.h”#include “haldls/vx/v3/timer.h”#include <vector>#include <gtest/gtest_prod.h>
file types.h
#include “halco/common/geometry.h”#include “haldls/vx/v3/padi.h”
file vertex.h
#include <variant>#include “grenade/vx/vertex/addition.h”#include “grenade/vx/vertex/argmax.h”#include “grenade/vx/vertex/background_spike_source.h”#include “grenade/vx/vertex/cadc_membrane_readout_view.h”#include “grenade/vx/vertex/converting_relu.h”#include “grenade/vx/vertex/crossbar_l2_input.h”#include “grenade/vx/vertex/crossbar_l2_output.h”#include “grenade/vx/vertex/crossbar_node.h”#include “grenade/vx/vertex/data_input.h”#include “grenade/vx/vertex/data_output.h”#include “grenade/vx/vertex/external_input.h”#include “grenade/vx/vertex/madc_readout.h”#include “grenade/vx/vertex/neuron_event_output_view.h”#include “grenade/vx/vertex/neuron_view.h”#include “grenade/vx/vertex/padi_bus.h”#include “grenade/vx/vertex/plasticity_rule.h”#include “grenade/vx/vertex/relu.h”#include “grenade/vx/vertex/subtraction.h”#include “grenade/vx/vertex/synapse_array_view.h”#include “grenade/vx/vertex/synapse_array_view_sparse.h”#include “grenade/vx/vertex/synapse_driver.h”#include “grenade/vx/vertex/transformation.h”#include “grenade/vx/vertex_concept.h”
file background_spike_source.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “halco/hicann-dls/vx/v3/background.h”#include “haldls/vx/background.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>
file cadc_membrane_readout_view.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “halco/hicann-dls/vx/v3/cadc.h”#include “halco/hicann-dls/vx/v3/synapse.h”#include “halco/hicann-dls/vx/v3/synram.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>#include <optional>#include <vector>#include “grenade/vx/vertex/cadc_membrane_readout_view.tcc”
file crossbar_l2_input.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>
file crossbar_l2_output.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>#include <optional>
file crossbar_node.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “grenade/vx/port_restriction.h”#include “halco/hicann-dls/vx/v3/routing_crossbar.h”#include “haldls/vx/v3/routing_crossbar.h”#include “hate/visibility.h”#include <cstddef>#include <cstdint>#include <iosfwd>#include <optional>
file data_input.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>
file data_output.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>#include <optional>
file external_input.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “halco/common/geometry.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>#include <vector>
file madc_readout.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “hate/visibility.h”#include “lola/vx/v3/neuron.h”#include <array>#include <cstddef>#include <iosfwd>#include <optional>
file neuron_event_output_view.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “hate/visibility.h”#include <array>#include <iosfwd>#include <optional>
file neuron_view.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “hate/visibility.h”#include “lola/vx/v3/neuron.h”#include <array>#include <cstddef>#include <iosfwd>#include <optional>#include <vector>#include “grenade/vx/vertex/neuron_view.tcc”
file padi_bus.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “halco/hicann-dls/vx/v3/padi.h”#include “hate/visibility.h”#include <array>#include <iosfwd>#include <optional>
file subtraction.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>
file synapse_array_view.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “halco/hicann-dls/vx/v3/synapse.h”#include “halco/hicann-dls/vx/v3/synram.h”#include “hate/visibility.h”#include “lola/vx/v3/synapse.h”#include <array>#include <cstddef>#include <iosfwd>#include <vector>#include <boost/range/iterator_range.hpp>#include “grenade/vx/vertex/synapse_array_view.tcc”
file synapse_array_view_sparse.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “halco/hicann-dls/vx/v3/synapse.h”#include “halco/hicann-dls/vx/v3/synram.h”#include “hate/visibility.h”#include “lola/vx/v3/synapse.h”#include <array>#include <cstddef>#include <iosfwd>#include <vector>#include <boost/range/iterator_range.hpp>#include “grenade/vx/vertex/synapse_array_view_sparse.tcc”
file synapse_driver.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/port.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/v3/synapse.h”#include “halco/hicann-dls/vx/v3/synapse_driver.h”#include “haldls/vx/v3/synapse_driver.h”#include “hate/visibility.h”#include <iosfwd>
file transformation.h
#include “grenade/vx/connection_type.h”#include “grenade/vx/io_data_map.h”#include “grenade/vx/port.h”#include “hate/visibility.h”#include <memory>#include <ostream>#include <stddef.h>#include <variant>#include <vector>
file vertex_concept.h
#include <array>#include <type_traits>#include <utility>#include <variant>#include <vector>
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/grenade/include/grenade/vx/backend
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/grenade/include/grenade/vx/compute
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/grenade/include/grenade/vx/network/detail
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/grenade/include/grenade/vx/generator
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/grenade
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/grenade/include/grenade
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/grenade/include
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/grenade/include/grenade/vx/network
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/grenade/include/grenade/vx/ppu
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/grenade/include/grenade/vx/transformation
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/grenade/include/grenade/vx/vertex
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/grenade/include/grenade/vx