API Reference: grenade

class grenade::vx::compute::Addition

#include <addition.h>

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

Public Functions

Addition() = default

Addition (std::vector< signal_flow::Int8 > const &other) 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< signal_flow::Int8 > > run (std::vector< std::vector< signal_flow::Int8 > > const &inputs, lola::vx::v3::Chip const &config, execution::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

signal_flow::Graph m_graph = {}

signal_flow::Graph::vertex_descriptor m_input_vertex = {}

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

signal_flow::Graph::vertex_descriptor m_other_vertex = {}

signal_flow::Graph::vertex_descriptor m_output_vertex = {}

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::vertex::Addition

#include <addition.h>

Addition of multiple inputs of signal_flow::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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = true

Private Functions

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

Private Members

size_t m_size = {}

Friends

friend struct cereal::access

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

struct grenade::vx::network::routing::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::routing::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::routing::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::routing::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::routing::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::routing::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< signal_flow::UInt32 > > run (std::vector< std::vector< signal_flow::Int8 > > const &inputs, lola::vx::v3::Chip const &config, execution::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

signal_flow::Graph m_graph

signal_flow::Graph::vertex_descriptor m_input_vertex = {}

signal_flow::Graph::vertex_descriptor m_output_vertex = {}

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

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

Private Members

size_t m_size = {}

ConnectionType m_type = {}

Friends

friend struct cereal::access

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

struct grenade::vx::network::AtomicNeuronOnNetwork

#include <atomic_neuron_on_network.h>

Public Functions

AtomicNeuronOnNetwork() = default

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

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

bool operator< (AtomicNeuronOnNetwork const &other) const SYMBOL_VISIBLE

bool operator<= (AtomicNeuronOnNetwork const &other) const SYMBOL_VISIBLE

bool operator== (AtomicNeuronOnNetwork const &other) const SYMBOL_VISIBLE

bool operator> (AtomicNeuronOnNetwork const &other) const SYMBOL_VISIBLE

bool operator>= (AtomicNeuronOnNetwork const &other) const SYMBOL_VISIBLE

Public Members

size_t atomic_neuron_on_compartment = {0}

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

size_t neuron_on_population = {0}

PopulationDescriptor population = {}

Friends

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

struct grenade::vx::network::routing::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.

Receptor::Type receptor_type

Receptor type of connection.

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

Source circuit.

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

Target neuron.

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

#include <source_on_padi_bus_manager.h>

Properties of a background source.

Public Members

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

Number of required synapses per atomic neuron.

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

PADI-bus which carries outgoing events of source.

struct grenade::vx::network::BackgroundSourcePopulation

#include <background_source_population.h>

Background 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

BackgroundSourcePopulation() = default

BackgroundSourcePopulation (size_t size, Coordinate const &coordinate, Config const &config) SYMBOL_VISIBLE

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

bool operator== (BackgroundSourcePopulation const &other) const SYMBOL_VISIBLE

Public Members

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

Coordinate coordinate

size_t size = {0}

Number of individual sources.

Friends

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

struct grenade::vx::signal_flow::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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

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

Private Members

Config m_config

Coordinate m_coordinate

Friends

friend struct cereal::access

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

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

Public Types

typedef std::optional<stadls::vx::v3::ContainerTicket> event_guard_ticket_type

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

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

Public Members

ticket_extmem_type m_extmem_result

std::map<signal_flow::Graph::vertex_descriptor, ticket_extmem_type> m_plasticity_rule_recorded_scratchpad_memory

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::execution::detail::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::detail::Status const status)

Construct blocking PPU command.

Parameters

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

• status – Command to place

Protected Functions

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

Private Members

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

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

Program 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", "-lhalco_common_ppu_vx", "-lhalco_hicann_dls_ppu_vx", "-lhalco_hicann_dls_ppu_vx_v3", "-lfisch_ppu_vx", "-lhaldls_ppu_vx_v3", "-lnux_vx_v3", "-Wl,--whole-archive", get_libnux_runtime("nux_runtime_vx_v3.o"), "-Wl,--no-whole-archive", "-lc", "-lgcc", "-Bdynamic",}

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

Public Static Attributes

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

Private Static Functions

static ProgramCache &get_program_cache()

struct grenade::vx::signal_flow::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 std::vector<std::vector<lola::vx::v3::AtomicNeuron::Readout::Source>> Sources

typedef halco::hicann_dls::vx::v3::SynramOnDLS Synram

Public Functions

CADCMembraneReadoutView() = default

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

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

Sources const & get_sources () 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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

void check (Columns const &columns, Sources const &sources) SYMBOL_VISIBLE

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

Private Members

Columns m_columns = {}

Mode m_mode = {}

Sources m_sources = {}

Synram m_synram = {}

Friends

friend struct cereal::access

friend std::ostream & operator<< (std::ostream &os, CADCMembraneReadoutView const &config) 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::signal_flow::detail::CheckVertexConcept<std::variant<Vertex...>> : public grenade::vx::signal_flow::detail::VertexConcept<Vertex>

#include <vertex_concept.h>

Public Static Attributes

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

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

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

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

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

#include <population.h>

Compartment properties.

Public Types

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

Receptors per atomic neuron on compartment.

Public Functions

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

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

bool operator== (Compartment const &other) const SYMBOL_VISIBLE

Public Members

Receptors receptors

std::optional<SpikeMaster> spike_master

Friends

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

struct grenade::vx::Compiler

#include <ppu.h>

Compiler for PPU programs.

Subclassed by grenade::vx::CachingCompiler

Public Functions

Compiler () SYMBOL_VISIBLE

Program 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", "-lhalco_common_ppu_vx", "-lhalco_hicann_dls_ppu_vx", "-lhalco_hicann_dls_ppu_vx_v3", "-lfisch_ppu_vx", "-lhaldls_ppu_vx_v3", "-lnux_vx_v3", "-Wl,--whole-archive", get_libnux_runtime("nux_runtime_vx_v3.o"), "-Wl,--no-whole-archive", "-lc", "-lgcc", "-Bdynamic",}

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

Public Static Attributes

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

struct grenade::vx::signal_flow::vertex::transformation::Concatenation : public grenade::vx::signal_flow::vertex::Transformation::Function

#include <concatenation.h>

Public Types

typedef signal_flow::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 () SYMBOL_VISIBLE

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(Transformation::Function const &other) const

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

Provided input ports provided.

Returns

Port

virtual Port output() const

Single output port provided.

Returns

Port

Private Functions

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

Private Members

std::vector<size_t> m_sizes = {}

ConnectionType m_type = {}

Friends

friend struct cereal::access

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

#include <background_source_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::signal_flow::vertex::NeuronView::Config

#include <neuron_view.h>

Public Types

typedef lola::vx::v3::AtomicNeuron::EventRouting::Address Label

Public Functions

bool operator!= (Config const &other) const 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 struct cereal::access

struct grenade::vx::signal_flow::vertex::SynapseDriver::Config

#include <synapse_driver.h>

Public Types

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

typedef halco::common::typed_array<haldls::vx::v3::SynapseDriverConfig::RowMode, halco::hicann_dls::vx::v3::SynapseRowOnSynapseDriver> RowModes

Public Functions

bool operator!= (Config const &other) const 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 struct cereal::access

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

#include <connection.h>

Connection to hardware/simulation ensuring proper initialization.

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

Public Types

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

Accepted initialization generators.

Public Functions

Connection () SYMBOL_VISIBLE

Construct connection from environment and initialize with default constructed ExperimentInit.

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

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

Ownership of the hxcomm connection is transferred to this object.

Parameters

connection – Connection from hxcomm to use

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

Construct connection from hxcomm connection and initialization generator.

Ownership of the hxcomm connection is transferred to this object.

Parameters

• connection – Connection from hxcomm to use

• init – Initialization to use

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

Create entry on reinit stack.

Returns

Created reinit stack entry

std::string get_bitfile_info () const SYMBOL_VISIBLE

Get bitfile information.

Returns

Bitfile info

std::string get_remote_repo_state () const SYMBOL_VISIBLE

Get server-side remote repository state information.

Only non-empty for hxcomm connection being QuiggeldyConnection.

Returns

Repository state

hxcomm::ConnectionTimeInfo get_time_info () const SYMBOL_VISIBLE

Get time information of execution(s).

Returns

Time information

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

Get unique identifier from hwdb.

Parameters

hwdb_path – Optional path to hwdb

Returns

Unique identifier

bool is_quiggeldy () const SYMBOL_VISIBLE

Get whether owned hxcomm connection is QuiggeldyConnection.

Returns

Boolean value

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

Release ownership of hxcomm connection.

Returns

Previously owned hxcomm connection

Public Static Attributes

static constexpr char name[] = "Connection"

Name of connection used in Python wrapping.

Private Members

hxcomm::vx::ConnectionVariant m_connection

size_t m_expected_link_notification_count

Expected highspeed link notification count in run().

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

stadls::vx::v3::ReinitStackEntry m_init

Reinit stack entry of initialization for reapplication.

Friends

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

Execute given playback program using the given connection.

Parameters

• connection – Connection to run on

• program – Program to execute

Returns

Run time information of execution

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

Execute given playback program using the given connection.

Parameters

• connection – Connection to run on

• program – Program to execute

Returns

Run time information of execution

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

#include <projection.h>

Single neuron connection.

Public Types

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

Public Functions

Connection() = default

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

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

bool operator== (Connection const &other) const SYMBOL_VISIBLE

Public Members

Index index_post

Index of neuron in post-synaptic population.

Index index_pre

Index of neuron in pre-synaptic population.

Weight weight

Weight of connection.

Friends

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

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

#include <connection_state_storage.h>

Public Functions

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

Construct connection state storage with differential mode flag and connection.

The connection is used to construct the reinit stack entries.

Parameters

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

• connection – Connection to construct reinit stack entries from

Public Members

lola::vx::v3::Chip current_config

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

bool enable_differential_config

std::mutex mutex

stadls::vx::v3::ReinitStackEntry reinit_base

stadls::vx::v3::ReinitStackEntry reinit_capmem_settling_wait

stadls::vx::v3::ReinitStackEntry reinit_differential

stadls::vx::v3::ReinitStackEntry reinit_schedule_out_replacement

stadls::vx::v3::ReinitStackEntry reinit_trigger

struct grenade::vx::network::ConnectionToHardwareRoutes

#include <connection_routing_result.h>

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

Public Functions

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

bool operator== (ConnectionToHardwareRoutes const &other) const SYMBOL_VISIBLE

Public Members

std::vector<size_t> atomic_neurons_on_target_compartment

Indices of atomic neurons in target compartment.

Friends

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

struct grenade::vx::network::ConnectumConnection

#include <connectum.h>

Public Types

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

Public Functions

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

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

Public Members

Receptor::Type receptor_type

Source source

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

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

Friends

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

struct grenade::vx::signal_flow::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<signal_flow::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::vector<std::unordered_map<signal_flow::ExecutionInstance, common::Time>> 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<signal_flow::UInt5>> Activations

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

typedef MAC::Weight Weight

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

Weights of shape (out_channels, in_channels, size)

Public Functions

Conv1d() = default

template<typename WeightsT>
Conv1d(WeightsT &&weights, size_t input_size, size_t stride, size_t num_sends = 1, common::Time wait_between_events = 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< signal_flow::Int8 > > run (Activations const &inputs, lola::vx::v3::Chip const &config, execution::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}

signal_flow::Graph m_graph = {}

size_t m_in_channels = {}

size_t m_input_size = {}

size_t m_kernel_size = {}

MAC m_mac = {}

size_t m_num_sends = {}

size_t m_out_channels = {}

size_t m_stride = {}

common::Time m_wait_between_events = {}

Friends

friend struct cereal::access

class grenade::vx::compute::ConvertingReLU

#include <converting_relu.h>

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

Public Functions

ConvertingReLU() = default

ConvertingReLU (size_t size, uint32_t shift) 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 signal_flow::UInt5 value range

size_t input_size () const SYMBOL_VISIBLE

size_t output_size () const SYMBOL_VISIBLE

std::vector< std::vector< signal_flow::UInt5 > > run (std::vector< std::vector< signal_flow::Int8 > > const &inputs, lola::vx::v3::Chip const &config, execution::JITGraphExecutor &executor) const 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

signal_flow::Graph m_graph = {}

signal_flow::Graph::vertex_descriptor m_input_vertex = {}

signal_flow::Graph::vertex_descriptor m_output_vertex = {}

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::vertex::ConvertingReLU

#include <converting_relu.h>

ConvertingReLU of multiple inputs from signal_flow::Int8 to signal_flow::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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

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

Private Members

uint32_t m_shift = {}

size_t m_size = {}

Friends

friend struct cereal::access

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

struct grenade::vx::signal_flow::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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

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

Friends

friend struct cereal::access

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

struct grenade::vx::signal_flow::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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = true

Private Functions

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

Friends

friend struct cereal::access

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

struct grenade::vx::signal_flow::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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

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

Private Members

Config m_config = {}

Coordinate m_coordinate = {}

Friends

friend struct cereal::access

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

struct grenade::vx::signal_flow::vertex::DataInput

#include <data_input.h>

Formatted data input from memory.

Public Functions

DataInput() = default

explicit  DataInput (ConnectionType output_type, size_t size) 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 bool can_connect_different_execution_instances = true

static constexpr bool variadic_input = false

Private Functions

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

Private Members

ConnectionType m_output_type = {}

size_t m_size = {}

Friends

friend struct cereal::access

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

struct grenade::vx::signal_flow::vertex::DataOutput

#include <data_output.h>

Formatted data output to memory.

Public Functions

DataOutput() = default

explicit  DataOutput (ConnectionType input_type, size_t size) 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 bool can_connect_different_execution_instances = true

static constexpr bool variadic_input = false

Private Functions

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

Private Members

ConnectionType m_input_type = {}

size_t m_size = {}

Friends

friend struct cereal::access

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

struct grenade::vx::network::routing::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::signal_flow::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.

Public Functions

inline explicit constexpr ExecutionIndex(value_type const value = 0)

struct grenade::vx::signal_flow::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 struct 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::execution::detail::ExecutionInstanceBuilder

#include <execution_instance_builder.h>

Builder for a single ExecutionInstance.

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

Public Functions

ExecutionInstanceBuilder (signal_flow::Graph const &graph, signal_flow::ExecutionInstance const &execution_instance, signal_flow::IODataMap const &input_list, signal_flow::IODataMap const &data_output, std::optional< lola::vx::v3::PPUElfFile::symbols_type > const &ppu_symbols, signal_flow::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

signal_flow::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

signal_flow::IODataMap of locally computed results

void post_process (signal_flow::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 (signal_flow::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(signal_flow::Graph::vertex_descriptor const vertex, Vertex const &data)

Process single vertex.

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

Parameters

• vertex – Vertex descriptor

• data – Data associated with vertex

Private Members

std::vector<BatchEntry> m_batch_entries

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

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

signal_flow::IODataMap const &m_data_output

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

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

signal_flow::ExecutionInstance m_execution_instance

signal_flow::Graph const &m_graph

bool m_has_plasticity_rule = {false}

signal_flow::IODataMap const &m_input_list

signal_flow::IODataMap m_local_data

signal_flow::IODataMap m_local_data_output

signal_flow::ConstantReferenceIODataMap m_local_external_data

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

generator::NeuronResetMask m_neuron_resets

signal_flow::ExecutionInstancePlaybackHooks &m_playback_hooks

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

bool m_postprocessing

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

ticket_request_type m_ticket_requests

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

#include <execution_instance_config_visitor.h>

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

The result is applied to a given configuration object.

Public Functions

ExecutionInstanceConfigVisitor (signal_flow::Graph const &graph, signal_flow::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(signal_flow::Graph::vertex_descriptor const vertex, Vertex const &data)

Process single vertex.

This function is called in preprocess.

Parameters

• vertex – Vertex descriptor

• data – Data associated with vertex

Private Members

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

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

signal_flow::ExecutionInstance m_execution_instance

signal_flow::Graph const &m_graph

bool m_has_periodic_cadc_readout

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

bool m_requires_ppu

bool m_used_madc

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

#include <execution_instance_node.h>

Content of a execution node.

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

Public Functions

ExecutionInstanceNode (signal_flow::IODataMap &data_map, signal_flow::IODataMap const &input_data_map, signal_flow::Graph const &graph, signal_flow::ExecutionInstance const &execution_instance, lola::vx::v3::Chip const &initial_config, backend::Connection &connection, ConnectionStateStorage &connection_state_storage, signal_flow::ExecutionInstancePlaybackHooks &playback_hooks) SYMBOL_VISIBLE

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

Private Members

backend::Connection &connection

ConnectionStateStorage &connection_state_storage

signal_flow::IODataMap &data_map

signal_flow::ExecutionInstance execution_instance

signal_flow::Graph const &graph

lola::vx::v3::Chip const &initial_config

signal_flow::IODataMap const &input_data_map

log4cxx::LoggerPtr logger

signal_flow::ExecutionInstancePlaybackHooks &playback_hooks

struct grenade::vx::signal_flow::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 &inside_realtime_begin, stadls::vx::v3::PlaybackProgramBuilder &inside_realtime_end, stadls::vx::v3::PlaybackProgramBuilder &post_realtime) SYMBOL_VISIBLE

ExecutionInstancePlaybackHooks &operator=(ExecutionInstancePlaybackHooks&&) = default

ExecutionInstancePlaybackHooks &operator=(ExecutionInstancePlaybackHooks const&) = delete

Public Members

stadls::vx::v3::PlaybackProgramBuilder inside_realtime_begin

stadls::vx::v3::PlaybackProgramBuilder inside_realtime_end

stadls::vx::v3::PlaybackProgramBuilder post_realtime

stadls::vx::v3::PlaybackProgramBuilder pre_realtime

stadls::vx::v3::PlaybackProgramBuilder pre_static_config

struct grenade::vx::signal_flow::ExecutionTimeInfo

#include <execution_time_info.h>

Public Functions

void merge (ExecutionTimeInfo &&other) SYMBOL_VISIBLE

Merge other execution time info.

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

Parameters

other – Other execution time info to merge

void merge (ExecutionTimeInfo &other) SYMBOL_VISIBLE

Merge other execution time info.

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

Parameters

other – Other execution time info to merge

Public Members

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

Total duration of execution.

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

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

Time spent in execution on hardware.

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

std::unordered_map<signal_flow::ExecutionInstance, std::chrono::nanoseconds> realtime_duration_per_execution_instance = {}

Time spent in realtime section on hardware.

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

Friends

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

struct grenade::vx::network::routing::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.

Receptor::Type receptor_type

Receptor type of connection.

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

Target neuron.

struct grenade::vx::signal_flow::vertex::ExternalInput

#include <external_input.h>

External input data source.

Public Functions

ExternalInput() = default

explicit  ExternalInput (ConnectionType output_type, size_t size) 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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

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

Private Members

ConnectionType m_output_type = {}

size_t m_size = {}

Friends

friend struct cereal::access

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

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

#include <source_on_padi_bus_manager.h>

Properties of an external source.

Public Members

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

Number of required synapses per atomic neuron.

struct grenade::vx::network::ExternalSourcePopulation

#include <external_source_population.h>

External source population.

Public Functions

ExternalSourcePopulation() = default

ExternalSourcePopulation (size_t size) SYMBOL_VISIBLE

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

bool operator== (ExternalSourcePopulation const &other) const SYMBOL_VISIBLE

Public Members

size_t size = {0}

Number of individual sources.

Friends

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

struct grenade::vx::signal_flow::vertex::Transformation::Function

#include <transformation.h>

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

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

Public Types

typedef signal_flow::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::signal_flow::Graph

#include <graph.h>

Placed computation graph.

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

Vertices are physically and temporally placed on a specific ExecutionInstance. Data flow between different execution instances is restricted to off-chip data. Access to execution instance subgraphs and mapping between execution instance dependency graph and the complete data-flow graph is provided.

The dependence graph of execution instances has to be acyclic in order to be executable, while a subgraph tied to a execution instance can partly be cyclic, e.g. via recurrent routing of on-chip events. This is enforced by checks on addition of vertices/edges.

Public Types

typedef detail::edge_descriptor edge_descriptor

typedef std::unordered_map<edge_descriptor, std::optional<PortRestriction>> edge_property_map_type

Edge properties indexed by edge descriptor.

typedef boost::bimap<vertex_descriptor, boost::bimaps::unordered_set_of<ExecutionInstance>> execution_instance_map_type

Map between execution instance graph vertex descriptor and execution instance.

typedef detail::Graph graph_type

typedef detail::vertex_descriptor vertex_descriptor

typedef boost::bimap<boost::bimaps::set_of<vertex_descriptor>, boost::bimaps::multiset_of<vertex_descriptor>> vertex_descriptor_map_type

Map between descriptors of vertices and descriptor of execution instance graph vertex.

An execution instance graph vertex might relate to multiple vertices.

typedef std::vector<std::shared_ptr<Vertex>> vertex_property_map_type

Vertex properties indexed by vertex descriptor.

Public Functions

Graph (bool enable_acyclicity_check=true) 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, 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: 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, 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: 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, ExecutionInstance const &execution_instance, std::vector< Input > const &inputs) SYMBOL_VISIBLE

void add_log (vertex_descriptor descriptor, 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, ExecutionInstance const &vertex_execution_instance, ExecutionInstance const &input_vertex_execution_instance)

void check_inputs (Vertex const &vertex, 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::LoggerPtr m_logger

vertex_descriptor_map_type m_vertex_descriptor_map

vertex_property_map_type m_vertex_property_map

Private Static Functions

template<typename VertexPort, typename InputVertexPort>
static void check_input_port(VertexPort const &vertex_port, InputVertexPort const &input_vertex_port, std::optional<PortRestriction> const &input_vertex_port_restriction)

template<bool VariadicInput>
static void check_inputs_size(size_t vertex_inputs_size, size_t inputs_size)

template<typename Vertex, typename InputVertex>
static void check_supports_input_from(Vertex const &vertex, InputVertex const &input_vertex, std::optional<PortRestriction> const &input_port_restriction)

Friends

friend struct cereal::access

friend std::ostream & operator<< (std::ostream &os, Graph const &graph) SYMBOL_VISIBLE

Ostream operator of graph.

Prints graph topology in graphviz’ dot format. Vertices are in the format Type(descriptor), which allows identification of referenced vertices.

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

#include <network_graph.h>

Translation between unrouted and routed graph representation.

Public Types

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

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

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

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

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

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

Public Members

Populations populations

Projections projections

struct grenade::vx::network::routing::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::signal_flow::detail::VertexConcept::has_can_connect_different_execution_instances<V, std::void_t<decltype(&V::can_connect_different_execution_instances)>>

#include <vertex_concept.h>

Public Static Attributes

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

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

#include <vertex_concept.h>

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

#include <vertex_concept.h>

Public Static Attributes

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

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

#include <vertex_concept.h>

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

#include <vertex_concept.h>

Public Static Attributes

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

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

#include <vertex_concept.h>

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

#include <vertex_concept.h>

Public Static Attributes

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

template<>
struct std::hash<grenade::vx::network::Receptor>

#include <receptor.h>

Public Functions

inline size_t operator()(grenade::vx::network::Receptor const &t) const

template<>
struct std::hash<grenade::vx::signal_flow::detail::Graph::edge_descriptor>

#include <graph.h>

Public Functions

inline size_t operator()(grenade::vx::signal_flow::detail::Graph::edge_descriptor const &e) const

template<>
struct std::hash<grenade::vx::signal_flow::ExecutionInstance>

#include <execution_instance.h>

Public Functions

size_t operator() (grenade::vx::signal_flow::ExecutionInstance const &t) const SYMBOL_VISIBLE

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

#include <receptor.h>

ID of receptor.

Public Functions

inline explicit constexpr ID(value_type const value = 0)

struct grenade::vx::signal_flow::Input

#include <input.h>

Input to a vertex in the data-flow graph comprised of a descriptor and an optional port restriction.

Public Types

typedef Graph::vertex_descriptor descriptor_type

Public Functions

inline Input(descriptor_type const &descriptor)

inline Input(descriptor_type const &descriptor, PortRestriction const &port_restriction)

bool operator!= (Input const &other) const 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< common::Time > const &times, PopulationDescriptor population) SYMBOL_VISIBLE

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

void add (std::vector< std::vector< std::vector< common::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::common::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::common::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::common::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::signal_flow::vertex::PlasticityRule::TimedRecording::ObservableArray::Type::Int16 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<int16_t, Int16>

#include <plasticity_rule.h>

Public Types

typedef int16_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "int16_t"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerNeuron::Type::Int16 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<int16_t, Int16>

#include <plasticity_rule.h>

Public Types

typedef int16_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowFracSat16"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerSynapse::Type::Int16 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<int16_t, Int16>

#include <plasticity_rule.h>

Public Types

typedef int16_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowFracSat16"

struct grenade::vx::signal_flow::Int8 : public halco::common::detail::BaseType<Int8, int8_t>

#include <types.h>

8 bit wide signed integer value of e.g.

CADC membrane readouts.

In haldls we use unsigned values for the CADC readouts, this shall be a typesafe wrapper around int8_t, which we don’t currently have, since it relies on the interpretation of having the CADC baseline in the middle of the value range.

Public Functions

inline explicit constexpr Int8(value_type const value = 0)

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservableArray::Type::Int8 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<int8_t, Int8>

#include <plasticity_rule.h>

Public Types

typedef int8_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "int8_t"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerNeuron::Type::Int8 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<int8_t, Int8>

#include <plasticity_rule.h>

Public Types

typedef int8_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowFracSat8"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerSynapse::Type::Int8 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<int8_t, Int8>

#include <plasticity_rule.h>

Public Types

typedef int8_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowFracSat8"

struct grenade::vx::network::routing::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.

Receptor::Type receptor_type

Receptor type of connection.

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

Source neuron.

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

Target neuron.

struct grenade::vx::network::routing::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<Receptor::Type, 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::signal_flow::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, signal_flow::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, signal_flow::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 (signal_flow::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 (signal_flow::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::signal_flow::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<common::TimedDataSequence<std::vector<UInt32>>>, std::vector<common::TimedDataSequence<std::vector<UInt5>>>, std::vector<common::TimedDataSequence<std::vector<Int8>>>, std::vector<TimedSpikeToChipSequence>, std::vector<TimedSpikeFromChipSequence>, std::vector<TimedMADCSampleFromChipSequence>> Entry

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<signal_flow::detail::vertex_descriptor, Entry> data

Data is connected to specified vertex descriptors.

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

std::optional<ExecutionTimeInfo> execution_time_info

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

std::vector<std::unordered_map<signal_flow::ExecutionInstance, common::Time>> runtime

Runtime time-interval data.

The runtime start time coincides with the spike events’ and MADC recording start time. Event data is only recorded during the runtime. If the runtime data is empty it is ignored.

Public Static Functions

static bool is_match (Entry const &entry, signal_flow::Port const &port) 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::execution::JITGraphExecutor

#include <jit_graph_executor.h>

Just-in-time graph executor.

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

Public Types

typedef std::unordered_map<signal_flow::ExecutionInstance, lola::vx::v3::Chip> ChipConfigs

typedef std::tuple<bool> init_parameters_type

typedef std::unordered_map<signal_flow::ExecutionInstance, signal_flow::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, std::string > get_remote_repo_state () 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(signal_flow::Graph const &graph)

Check that graph can be executed.

This function combines is_executable_on and has_dangling_inputs.

Parameters

graph – Graph to check

bool is_executable_on(signal_flow::Graph const &graph)

Check whether the given graph can be executed.

Parameters

graph – Graph instance

Private Members

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

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

bool m_enable_differential_config

Friends

friend signal_flow::IODataMap run(JITGraphExecutor &executor, signal_flow::Graph const &graph, signal_flow::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<signal_flow::UInt5>> Activations

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

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

Public Functions

MAC() = default

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

Create single MAC compute graph wrapper.

Parameters

• weights – Weight matrix.

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

• wait_between_events – Wait time between input events in FPGA cycles

• enable_loopback – Enable loopback of events with statistic analysis

• madc_recording_neuron – Neuron ID to record via MADC

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

size_t input_size () const SYMBOL_VISIBLE

size_t output_size () const SYMBOL_VISIBLE

std::vector< std::vector< signal_flow::Int8 > > run (Activations const &inputs, lola::vx::v3::Chip const &config, execution::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}

signal_flow::Graph m_graph = {}

signal_flow::Graph::vertex_descriptor m_input_vertex = {}

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

std::string m_madc_recording_path

std::unordered_map<signal_flow::ExecutionInstance, signal_flow::Graph::vertex_descriptor> m_madc_recording_vertices

size_t m_num_sends = {}

signal_flow::Graph::vertex_descriptor m_output_vertex = {}

common::Time m_wait_between_events = {}

Weights m_weights = {}

Private Static Functions

static std::pair< signal_flow::Graph::vertex_descriptor, std::optional< signal_flow::Graph::vertex_descriptor > > insert_synram (signal_flow::Graph &graph, Weights &&weights, signal_flow::ExecutionInstance const &instance, halco::hicann_dls::vx::v3::HemisphereOnDLS const &hemisphere, std::optional< halco::hicann_dls::vx::v3::AtomicNeuronOnDLS > const &madc_recording_neuron, signal_flow::Graph::vertex_descriptor crossbar_input_vertex) 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

• madc_recording_neuron – Optional location of neuron to record via MADC

• crossbar_input_vertex – Incoming crossbar input vertex to use

Returns

Data output vertex to measured membrane potential values

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::vertex::transformation::MACSpikeTrainGenerator : public grenade::vx::signal_flow::vertex::Transformation::Function

#include <mac_spiketrain_generator.h>

Public Types

typedef signal_flow::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, common::Time 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 (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 = {}

common::Time m_wait_between_events = {}

Private Static Functions

static std::optional< halco::hicann_dls::vx::v3::SpikeLabel > get_spike_label (halco::hicann_dls::vx::v3::SynapseDriverOnDLS const &driver, signal_flow::UInt5 const value) 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 struct cereal::access

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

#include <madc.h>

Generator for a playback program snippet from arming the MADC.

Public Types

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

typedef hate::Nil Result

Protected Functions

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

Friends

friend auto generate(MADCArm const&)

struct grenade::vx::signal_flow::vertex::MADCReadoutView

#include <madc_readout.h>

Readout of neuron voltages via the MADC.

Public Functions

MADCReadoutView() = default

explicit  MADCReadoutView (Source const &first_source, std::optional< Source > const &second_source, SourceSelection const &source_selection) SYMBOL_VISIBLE

Construct MADCReadoutView.

Parameters

• first_source – Neuron source and location to read out

• second_source – Optional second neuron source and location to read out

• source_selection – Source selection config

Source const & get_first_source () const SYMBOL_VISIBLE

std::optional< Source > const & get_second_source () const SYMBOL_VISIBLE

SourceSelection const & get_source_selection () const SYMBOL_VISIBLE

std::vector< Port > 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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

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

Private Members

Source m_first_source = {}

std::optional<Source> m_second_source = {}

SourceSelection m_source_selection = {}

Friends

friend struct cereal::access

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

struct grenade::vx::network::MADCRecording

#include <madc_recording.h>

MADC recording of a single neuron.

Public Functions

MADCRecording() = default

MADCRecording (std::vector< Neuron > const &neurons) SYMBOL_VISIBLE

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

bool operator== (MADCRecording const &other) const SYMBOL_VISIBLE

Public Members

std::vector<Neuron> neurons = {}

struct grenade::vx::signal_flow::MADCSampleFromChip

#include <event.h>

From-chip MADC sample.

Public Types

typedef haldls::vx::v3::MADCSampleFromChip::Channel Channel

typedef haldls::vx::v3::MADCSampleFromChip::Value Value

Public Functions

MADCSampleFromChip() = default

inline MADCSampleFromChip(Value const value, Channel const channel)

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

bool operator== (MADCSampleFromChip const &other) const SYMBOL_VISIBLE

Public Members

Channel channel = {}

Value value = {}

Friends

friend std::ostream & operator<< (std::ostream &os, MADCSampleFromChip const &sample) SYMBOL_VISIBLE

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

#include <madc.h>

Generator for a playback program snippet from starting the MADC.

Public Types

typedef stadls::vx::v3::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::execution::detail::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

Public Members

bool enable_power_down_after_sampling = {false}

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, ExternalSourcePopulation, BackgroundSourcePopulation>> 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 (BackgroundSourcePopulation 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 (ExternalSourcePopulation 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::LoggerPtr m_logger

std::optional<MADCRecording> m_madc_recording = {std::nullopt}

std::map<PlasticityRuleDescriptor, PlasticityRule> m_plasticity_rules = {}

std::map<PopulationDescriptor, std::variant<Population, ExternalSourcePopulation, BackgroundSourcePopulation>> m_populations = {}

std::map<ProjectionDescriptor, Projection> m_projections = {}

struct grenade::vx::network::NetworkGraph

#include <network_graph.h>

Logical network representation.

Public Types

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

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

Spike labels corresponding to each neuron in a population.

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

Public Functions

NetworkGraph() = default

std::vector< signal_flow::Graph::vertex_descriptor > const & get_cadc_sample_output_vertex () const SYMBOL_VISIBLE

Vertex descriptor from which to extract recorded cadc sample data.

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

Vertex descriptor at which to insert external spike data.

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

Vertex descriptor from which to extract recorded spike data.

signal_flow::Graph const & get_graph () const SYMBOL_VISIBLE

Graph representing the network.

GraphTranslation const & get_graph_translation () const SYMBOL_VISIBLE

Translation between unrouted and routed graph representation.

std::optional< signal_flow::Graph::vertex_descriptor > const & 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.

std::map< PopulationDescriptor, std::map< halco::hicann_dls::vx::HemisphereOnDLS, signal_flow::Graph::vertex_descriptor > > const & get_neuron_vertices () const SYMBOL_VISIBLE

Vertex descriptors of neuron views.

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

PlacedConnections get_placed_connections (ProjectionDescriptor descriptor) const SYMBOL_VISIBLE

std::map< PlasticityRuleDescriptor, signal_flow::Graph::vertex_descriptor > const & get_plasticity_rule_output_vertices () const SYMBOL_VISIBLE

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

std::map< PlasticityRuleDescriptor, signal_flow::Graph::vertex_descriptor > const & get_plasticity_rule_vertices () const SYMBOL_VISIBLE

Vertex descriptor of plasticity rules.

SpikeLabels const & get_spike_labels () const SYMBOL_VISIBLE

std::map< ProjectionDescriptor, std::map< halco::hicann_dls::vx::HemisphereOnDLS, signal_flow::Graph::vertex_descriptor > > const & get_synapse_vertices () const SYMBOL_VISIBLE

Vertex descriptors of synapse views.

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, signal_flow::Graph::vertex_descriptor>> m_background_spike_source_vertices

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

std::chrono::microseconds m_construction_duration

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

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

signal_flow::Graph m_graph

GraphTranslation m_graph_translation

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

std::shared_ptr<Network> m_network

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

std::map<PlasticityRuleDescriptor, signal_flow::Graph::vertex_descriptor> m_plasticity_rule_output_vertices

std::map<PlasticityRuleDescriptor, signal_flow::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, signal_flow::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, signal_flow::ExecutionInstance const &execution_instance)

Build a hardware network representation for a given network.

Parameters

• network – Network for which to build hardware network representation

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

• execution_instance – Execution instance to build the hardware graph into

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(signal_flow::Graph &graph, Resources &resources, signal_flow::ExecutionInstance const &instance, RoutingResult const &routing_result) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void add_synapse_array_view_sparse(signal_flow::Graph &graph, Resources &resources, ProjectionDescriptor descriptor, RoutingResult const &connection_result, signal_flow::ExecutionInstance const &instance) const

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

NetworkGraph::SpikeLabels get_spike_labels(RoutingResult const &connection_result)

Public Static Functions

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

Private Members

log4cxx::LoggerPtr m_logger

Network const &m_network

struct grenade::vx::network::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 neuron_on_population, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron compartment_on_neuron, size_t atomic_neuron_on_compartment, Source source) SYMBOL_VISIBLE

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

bool operator== (Neuron const &other) const SYMBOL_VISIBLE

Public Members

size_t atomic_neuron_on_compartment = {0}

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

size_t neuron_on_population = {0}

PopulationDescriptor population = {}

Source source = {Source::membrane}

struct grenade::vx::network::MADCRecording::Neuron

#include <madc_recording.h>

Public Types

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

Public Functions

Neuron() = default

Neuron (AtomicNeuronOnNetwork const &coordinate, Source source) SYMBOL_VISIBLE

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

bool operator== (Neuron const &other) const SYMBOL_VISIBLE

Public Members

AtomicNeuronOnNetwork coordinate = {}

Source source = {Source::membrane}

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

#include <population.h>

On-chip neuron.

Public Types

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

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

Location and shape.

Public Functions

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

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

bool operator== (Neuron const &other) const SYMBOL_VISIBLE

bool valid () const SYMBOL_VISIBLE

Check validity of neuron config.

Public Members

Compartments compartments

Coordinate coordinate

Friends

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

struct grenade::vx::signal_flow::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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

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

Private Members

Neurons m_neurons = {}

Friends

friend struct cereal::access

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

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

#include <neuron_reset_mask.h>

Generator for neuron resets.

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

Public Types

typedef stadls::vx::v3::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::signal_flow::vertex::NeuronView

#include <neuron_view.h>

A view of neuron circuits.

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

ppu::NeuronViewHandle toNeuronViewHandle () const SYMBOL_VISIBLE

Convert to neuron view handle for PPU programs.

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = true

Private Functions

void check (Columns const &columns, Configs const &configs) 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 struct cereal::access

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

struct grenade::vx::ppu::NeuronViewHandle

#include <neuron_view_handle.h>

Public Members

hate::bitset<256, uint32_t> columns

Columns in neuron view.

TODO: replace numbers by halco constants

struct grenade::vx::signal_flow::vertex::PlasticityRule::NeuronViewShape

#include <plasticity_rule.h>

Shape of a single neuron view to be altered.

Public Types

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

Public Functions

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

bool operator== (NeuronViewShape const &other) const SYMBOL_VISIBLE

Public Members

NeuronView::Columns columns

Location of columns.

This information is needed for extraction of timed recording observables and measurement settings.

std::vector<std::optional<NeuronReadoutSource>> neuron_readout_sources

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

NeuronView::Row row

Row of neurons.

This information is required for extraction of timed recording observables and measurement settings.

Private Functions

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

Friends

friend struct cereal::access

friend std::ostream & operator<< (std::ostream &os, NeuronViewShape const &recording) SYMBOL_VISIBLE

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservableArray

#include <plasticity_rule.h>

Observable with array of values of configurable size.

Used for e.g. neuron firing rates.

Public Types

typedef std::variant<Type::Int8, Type::UInt8, Type::Int16, Type::UInt16> TypeVariant

Public Functions

ObservableArray() = default

ObservableArray (TypeVariant const &type, size_t size) SYMBOL_VISIBLE

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

bool operator== (ObservableArray const &other) const SYMBOL_VISIBLE

Public Members

size_t size = 0

TypeVariant type = Type::int8

Private Functions

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

Friends

friend struct cereal::access

friend std::ostream & operator<< (std::ostream &os, ObservableArray const &observable) SYMBOL_VISIBLE

template<typename ElementT, typename Derived>
struct grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType

#include <observable_data_type.h>

Public Types

typedef ElementT ElementType

Private Functions

template<typename Archive>
inline void serialize(Archive&)

Friends

friend struct cereal::access

inline friend constexpr bool operator!=(Derived const&, Derived const&)

inline friend std::ostream &operator<<(std::ostream &os, Derived const&)

inline friend constexpr bool operator==(Derived const&, Derived const&)

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerNeuron

#include <plasticity_rule.h>

Observable with a single data entry per neuron.

Used for e.g. membrane potential measurements

Public Types

enum Layout

Values:

enumerator complete_row

enumerator packed_active_columns

Record complete row of values.

This is fast, but inefficient memory-wise, since independent of the number of active columns in the neuron view the complete row is stored. The memory provided per row is of type libnux::vx::VectorRow{Mod,FracSat}{8,16} for type {u,}{int_}{8,16}. Record only active columns of neuron view. This is efficient memory-wise, but slow, since the values are stored sequentially per neuron. The memory provided per row is of type std::array<{u,}{int_}{8,16}_t, num_columns> for type {u,}{int_}{8,16}.

typedef std::variant<Type::Int8, Type::UInt8, Type::Int16, Type::UInt16> TypeVariant

Public Functions

ObservablePerNeuron() = default

ObservablePerNeuron (TypeVariant const &type, Layout const &layout_per_row) SYMBOL_VISIBLE

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

bool operator== (ObservablePerNeuron const &other) const SYMBOL_VISIBLE

Public Members

enum grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerNeuron::Layout layout = Layout::complete_row

TypeVariant type = Type::int8

Private Functions

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

Friends

friend struct cereal::access

friend std::ostream & operator<< (std::ostream &os, ObservablePerNeuron const &observable) SYMBOL_VISIBLE

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerSynapse

#include <plasticity_rule.h>

Observable with a single data entry per synapse.

Used for e.g. weights and correlation measurements

Public Types

enum LayoutPerRow

Values:

enumerator complete_rows

enumerator packed_active_columns

Record complete rows of values.

This is fast, but inefficient memory-wise, since independent of the number of active columns in the synapse view the complete row is stored. The memory provided per row is of type libnux::vx::VectorRow{Mod,FracSat}{8,16} for type {u,}{int_}{8,16}. Record only active columns of synapse view. This is efficient memory-wise, but slow, since the values are stored sequentially per synapse. The memory provided per row is of type std::array<{u,}{int_}{8,16}_t, num_columns> for type {u,}{int_}{8,16}.

typedef std::variant<Type::Int8, Type::UInt8, Type::Int16, Type::UInt16> TypeVariant

Public Functions

ObservablePerSynapse() = default

ObservablePerSynapse (TypeVariant const &type, LayoutPerRow const &layout_per_row) SYMBOL_VISIBLE

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

bool operator== (ObservablePerSynapse const &other) const SYMBOL_VISIBLE

Public Members

enum grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerSynapse::LayoutPerRow layout_per_row = LayoutPerRow::complete_rows

TypeVariant type = Type::int8

Private Functions

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

Friends

friend struct cereal::access

friend std::ostream & operator<< (std::ostream &os, ObservablePerSynapse const &observable) SYMBOL_VISIBLE

struct grenade::vx::network::OnlyRecordingPlasticityRuleGenerator

#include <plasticity_rule_generator.h>

Public Types

enum Observable

Observables, which can be recorded.

Values:

enumerator weights

enumerator correlation_causal

enumerator correlation_acausal

Public Functions

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

PlasticityRule generate () const SYMBOL_VISIBLE

Generate plasticity rule which only executes given recording.

Timing and projection information is left default/empty.

Private Members

std::set<Observable> m_observables

struct grenade::vx::signal_flow::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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = true

Private Functions

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

Private Members

Coordinate m_coordinate = {}

Friends

friend struct cereal::access

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

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

#include <routing_constraints.h>

Collection of constraints for a single PADI-bus.

Public Members

std::vector<BackgroundConnection> background_connections

Background connections.

std::vector<InternalConnection> internal_connections

Internal connections.

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

Neuron sources.

size_t num_background_spike_sources

Background spike source number.

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

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

struct grenade::vx::network::routing::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::routing::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 label

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

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

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

Friends

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

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

#include <network_graph_builder.h>

Public Members

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

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

#include <network_graph_builder.h>

Public Members

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

struct grenade::vx::network::PlasticityRule

#include <plasticity_rule.h>

Plasticity rule.

Public Types

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

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

Recording data corresponding to a raw recording.

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

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

typedef std::variant<RawRecordingData, TimedRecordingData> RecordingData

Recorded data.

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

Recording information for execution of the rule.

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

Public Functions

PlasticityRule() = default

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

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

Public Members

bool enable_requires_one_source_per_row_in_order = {false}

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

std::string kernel = {}

Plasticity rule kernel to be compiled into the PPU program.

std::vector<PopulationHandle> populations

std::vector<ProjectionDescriptor> projections = {}

Descriptor to projections this rule has access to.

All projections are required to be dense and in order.

std::optional<Recording> recording

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

Friends

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

struct grenade::vx::signal_flow::vertex::PlasticityRule

#include <plasticity_rule.h>

A plasticity rule to operate on synapse array views.

Public Types

typedef std::variant<RawRecording, TimedRecording> Recording

Recording information for execution of the rule.

typedef std::variant<RawRecordingData, TimedRecordingData> RecordingData

Public Functions

PlasticityRule() = default

PlasticityRule (std::string kernel, Timer const &timer, std::vector< SynapseViewShape > const &synapse_view_shapes, std::vector< NeuronViewShape > const &neuron_view_shapes, std::optional< Recording > const &recording) SYMBOL_VISIBLE

Construct PlasticityRule with specified kernel, timer and synapse information.

Parameters

• kernel – Kernel to apply

• timer – Timer to use

• synapse_view_shapes – Shapes of synapse views to alter

• neuron_view_shapes – Shapes of neuron views to alter

• recording – Optional recording providing memory for the plasticity rule to store information during execution.

RecordingData extract_recording_data (std::vector< common::TimedDataSequence< std::vector< signal_flow::Int8 > > > const &data) const SYMBOL_VISIBLE

Extract data corresponding to performed recording.

For RawRecording return the raw data, for TimedRecording extract observables of timed recording from raw data. This method is to be used after successful execution of aa graph incorporating this vertex instance.

Throws

std::runtime_error – On data not matching expectation

Parameters

data – Raw data to extract recording from

std::string const & get_kernel () const SYMBOL_VISIBLE

std::vector< NeuronViewShape > const & get_neuron_view_shapes () const SYMBOL_VISIBLE

std::pair< size_t, size_t > get_recorded_memory_data_interval () const SYMBOL_VISIBLE

Get interval in memory layout of data within recording.

std::string get_recorded_memory_definition () const SYMBOL_VISIBLE

Get C++ definition of recorded memory structure.

This structure is instantiated and made available to the plasticity rule kernel.

std::map< std::string, std::pair< size_t, size_t > > get_recorded_memory_timed_data_intervals () const SYMBOL_VISIBLE

Get interval in memory layout of data within recorded events.

Data intervals are given per observable.

Throws

std::runtime_error – On no or raw recording type

size_t get_recorded_scratchpad_memory_alignment () const SYMBOL_VISIBLE

Alignment (in bytes) of recorded scratchpad memory.

size_t get_recorded_scratchpad_memory_size () const SYMBOL_VISIBLE

Size (in bytes) of recorded scratchpad memory, which is stored after execution and provided as output of this vertex.

When the recording is TimedRecording, the shapes of the synapse views are used to calculate the space requirement for the observables per synapse.

std::optional< Recording > get_recording () const SYMBOL_VISIBLE

std::vector< SynapseViewShape > const & get_synapse_view_shapes () 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 (NeuronView const &input, std::optional< PortRestriction > const &restriction) const SYMBOL_VISIBLE

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

Public Static Attributes

static constexpr bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

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

Private Members

std::string m_kernel

std::vector<NeuronViewShape> m_neuron_view_shapes

std::optional<Recording> m_recording

std::vector<SynapseViewShape> m_synapse_view_shapes

Timer m_timer

Friends

friend struct cereal::access

friend std::ostream & operator<< (std::ostream &os, PlasticityRule const &config) 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::execution::detail::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<Neuron> Neurons

List of on-chip neurons.

Public Functions

Population() = default

Population (Neurons const &neurons) SYMBOL_VISIBLE

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

size_t get_atomic_neurons_size () const SYMBOL_VISIBLE

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

bool operator== (Population const &other) const SYMBOL_VISIBLE

bool valid () const SYMBOL_VISIBLE

Check validity of projection config.

Public Members

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_descriptor.h>

Descriptor to be used to identify a population.

Public Functions

inline explicit constexpr PopulationDescriptor(value_type const value = 0)

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

#include <plasticity_rule.h>

Population handle parameters.

Public Types

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

Public Functions

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

bool operator== (PopulationHandle const &other) const SYMBOL_VISIBLE

Public Members

PopulationDescriptor descriptor

Descriptor of population.

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

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

Friends

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

struct grenade::vx::signal_flow::Port

#include <port.h>

Description of a single data port of a vertex.

A port is described by the type of data to be transfered and a size of parallel transfered elements.

Public Functions

inline explicit constexpr Port(size_t const size, ConnectionType const type)

inline constexpr bool operator!=(Port const &other) const

inline constexpr bool operator==(Port const &other) const

Public Members

size_t size

Number of entries.

ConnectionType type

Connection type.

Friends

friend std::ostream & operator<< (std::ostream &os, Port const &port) SYMBOL_VISIBLE

struct grenade::vx::signal_flow::PortRestriction

#include <port_restriction.h>

Interval restriction of a port.

This allows connecting a subset of a vertex’s output to another vertex’s input.

Public Functions

PortRestriction() = default

PortRestriction (size_t min, size_t max) 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 struct cereal::access

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

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

#include <ppu_program_generator.h>

Public Functions

PPUProgramGenerator() = default

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

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

Public Members

bool has_periodic_cadc_readout = false

Private Members

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

struct grenade::vx::Compiler::Program

#include <ppu.h>

PPU program result of compilation.

Public Members

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

Program memory image.

std::optional<std::string> objdump

Optional objdump -d output of program.

Generation is performed for loglevel trace.

std::optional<std::string> readelf

Optional readelf -a output of program.

Generation is performed for loglevel debug.

std::optional<std::string> stack_sizes

Optional stack size output of functions of program.

Generation is performed for loglevel debug.

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

Program symbols.

struct grenade::vx::CachingCompiler::ProgramCache

#include <ppu.h>

Cache for compiled PPU programs.

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

Public Members

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

std::mutex data_mutex

struct grenade::vx::network::Projection

#include <projection.h>

Projection between populations.

Public Types

typedef std::vector<Connection> Connections

Point-to-point neuron connections type.

Public Functions

Projection() = default

Projection (Receptor const &receptor, Connections &&connections, PopulationDescriptor population_pre, PopulationDescriptor population_post) SYMBOL_VISIBLE

Projection (Receptor const &receptor, 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) !=5)

self connections resize (shape.at(0))

Public Members

Connections connections = {}

Point-to-point neuron connections.

auto const data = pyconnections.unchecked<2>()

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

Receptor receptor

Receptor type.

self receptor = receptor

struct 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::compute::detail::RangeSplit

#include <range_split.h>

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

Public Functions

explicit  RangeSplit (size_t split_size) 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

struct grenade::vx::signal_flow::vertex::PlasticityRule::RawRecording

#include <plasticity_rule.h>

Recording information for execution of the rule.

Raw recording of one scratchpad memory region for all timed invocations of the rule. No automated recording of time is performed.

Public Functions

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

bool operator== (RawRecording const &other) const SYMBOL_VISIBLE

Public Members

size_t scratchpad_memory_size

Size (in bytes) of recorded scratchpad memory, which is stored after execution and provided as output of this vertex.

Private Functions

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

Friends

friend struct cereal::access

friend std::ostream & operator<< (std::ostream &os, RawRecording const &recording) SYMBOL_VISIBLE

struct grenade::vx::signal_flow::vertex::PlasticityRule::RawRecordingData

#include <plasticity_rule.h>

Recording data corresponding to a raw recording.

Public Members

std::vector<std::vector<signal_flow::Int8>> data

Data with outer dimension being batch entries and inner dimension being the data per batch entry.

Friends

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

struct grenade::vx::network::Receptor

#include <receptor.h>

Receptor description of a neuron (compartment).

Public Types

enum Type

Receptor type.

Values:

enumerator excitatory

enumerator inhibitory

Public Functions

Receptor() = default

Receptor (ID id, Type type) SYMBOL_VISIBLE

size_t hash () const SYMBOL_VISIBLE

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

bool operator== (Receptor const &other) const SYMBOL_VISIBLE

Public Members

ID id

Type type

Friends

friend size_t hash_value (Receptor const &receptor) SYMBOL_VISIBLE

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

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< signal_flow::Int8 > > run (std::vector< std::vector< signal_flow::Int8 > > const &inputs, lola::vx::v3::Chip const &config, execution::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

signal_flow::Graph m_graph = {}

signal_flow::Graph::vertex_descriptor m_input_vertex = {}

signal_flow::Graph::vertex_descriptor m_output_vertex = {}

Friends

friend struct cereal::access

struct grenade::vx::signal_flow::vertex::ReLU

#include <relu.h>

ReLU of multiple inputs of signal_flow::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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

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

Private Members

size_t m_size = {}

Friends

friend struct 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, signal_flow::Graph::vertex_descriptor>> background_spike_sources

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

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

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

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

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

NetworkGraph::GraphTranslation graph_translation

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

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

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

std::map<PlasticityRuleDescriptor, signal_flow::Graph::vertex_descriptor> plasticity_rules

std::map<PlasticityRuleDescriptor, signal_flow::Graph::vertex_descriptor> plasticity_rules_output

std::map<PopulationDescriptor, PlacedPopulation> populations

std::map<ProjectionDescriptor, PlacedProjection> projections

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

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

Public Members

std::pair<ProjectionDescriptor, size_t> descriptor

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

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

#include <routing_builder.h>

Public Types

typedef RoutingResult Result

Public Functions

RoutingBuilder () SYMBOL_VISIBLE

Result route (Network const &network, ConnectionRoutingResult const &connection_routing_result, 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>, std::vector<PlacedConnection>> const &placed_connections, std::map<std::tuple<PopulationDescriptor, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>, halco::hicann_dls::vx::v3::SpikeLabel> const &internal_labels, std::map<std::tuple<PopulationDescriptor, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>, std::map<halco::hicann_dls::vx::v3::HemisphereOnDLS, halco::hicann_dls::vx::v3::SpikeLabel>> const &background_labels, std::map<std::tuple<PopulationDescriptor, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron>, std::map<halco::hicann_dls::vx::v3::PADIBusOnDLS, halco::hicann_dls::vx::v3::SpikeLabel>> const &external_labels, Network const &network, Result &result) const

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

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

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

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

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

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

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

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

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

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

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

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

Private Members

log4cxx::LoggerPtr m_logger

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

#include <routing_constraints.h>

Accessors for routing constraints for a given abstract network.

Public Functions

RoutingConstraints (Network const &network, ConnectionRoutingResult const &connection_routing_result) SYMBOL_VISIBLE

Construct constraints from and for an abstract network.

Parameters

• network – Abstract network

• connection_routing_result – Result of connection routing

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< Receptor::Type, 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< Receptor::Type, 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< Receptor::Type, 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< Receptor::Type, size_t >, halco::hicann_dls::vx::v3::PADIBusOnPADIBusBlock >, halco::hicann_dls::vx::v3::AtomicNeuronOnDLS > get_neuron_in_degree_per_receptor_type_per_padi_bus () const 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< Receptor::Type, 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

ConnectionRoutingResult const &m_connection_routing_result

Network const &m_network

struct grenade::vx::network::RoutingOptions

#include <routing_options.h>

Options to be passed to routing algorithm.

Public Types

typedef routing::SynapseDriverOnDLSManager::AllocationPolicy AllocationPolicy

Policy to be used in synapse driver allocation.

typedef routing::SynapseDriverOnDLSManager::AllocationPolicyBacktracking AllocationPolicyBacktracking

typedef routing::SynapseDriverOnDLSManager::AllocationPolicyGreedy AllocationPolicyGreedy

Public Functions

RoutingOptions () SYMBOL_VISIBLE

Public Members

AllocationPolicy synapse_driver_allocation_policy

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

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

Friends

friend std::ostream & operator<< (std::ostream &os, 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<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<halco::hicann_dls::vx::v3::SpikeLabel>>> ExternalSpikeLabels

Spike label corresponding to each neuron in a external population.

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

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

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

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

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

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

Synapse row mode resulting from routing to be applied.

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

Public Functions

RoutingResult() = default

Public Members

BackgroundSpikeSourceLabels background_spike_source_labels

ConnectionRoutingResult connection_routing_result

Connections connections

CrossbarNodes crossbar_nodes

ExternalSpikeLabels external_spike_labels

InternalNeuronLabels internal_neuron_labels

SynapseDriverRowAddressCompareMasks synapse_driver_compare_masks

SynapseRowModes synapse_row_modes

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<signal_flow::UInt5>>, std::vector<std::vector<signal_flow::Int8>>, std::vector<std::vector<signal_flow::UInt32>>> IOData

Vectorized number data for input and output without timing information.

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

Public Functions

Sequence() = default

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

Public Members

std::list<Entry> data

Private Functions

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

Friends

friend struct cereal::access

struct grenade::vx::network::routing::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::compute::detail::SingleChipExecutionInstanceManager

#include <single_chip_execution_instance_manager.h>

Manager for execution instances of a single chip.

Execution indices are allocated linearly and hemispheres are used alternatingly.

Public Functions

SingleChipExecutionInstanceManager() = default

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

Get current hemisphere.

signal_flow::ExecutionInstance next () SYMBOL_VISIBLE

Get next execution instance.

signal_flow::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

signal_flow::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::signal_flow::vertex::MADCReadoutView::Source

#include <madc_readout.h>

Public Types

typedef halco::hicann_dls::vx::v3::AtomicNeuronOnDLS Coord

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

Public Functions

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

bool operator== (Source const &other) const SYMBOL_VISIBLE

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

Public Members

Coord coord = {}

Type type = {}

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

#include <source_on_padi_bus_manager.h>

Public Types

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

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

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

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

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

typedef grenade::vx::network::routing::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::routing::SourceOnPADIBusManager

#include <source_on_padi_bus_manager.h>

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

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

Public Types

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

typedef SynapseDriverOnDLSManager::Label Label

Label to identify events at synapse driver(s).

typedef SynapseDriverOnDLSManager::SynapseDriver SynapseDriver

Synapse driver location.

Public Functions

SourceOnPADIBusManager (DisabledInternalRoutes const &disabled_internal_routes={}) SYMBOL_VISIBLE

Construct manager.

Parameters

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

std::optional< Partition > solve (std::vector< InternalSource > const &internal_sources, std::vector< BackgroundSource > const &background_sources, std::vector< ExternalSource > const &external_sources) const 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

DisabledInternalRoutes m_disabled_internal_routes

log4cxx::LoggerPtr m_logger

struct grenade::vx::signal_flow::vertex::MADCReadoutView::SourceSelection

#include <madc_readout.h>

Configuration of (timed) selection between the two MADC channels.

Public Types

typedef halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection Initial

Initially selected channel.

typedef haldls::vx::v3::MADCConfig::ActiveMuxInputSelectLength Period

Period with which to switch between channels.

Public Functions

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

bool operator== (SourceSelection const &other) const SYMBOL_VISIBLE

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

Public Members

Initial initial = {}

Period period = {}

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

#include <population.h>

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

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

Public Functions

SpikeMaster (size_t neuron_on_compartment, bool enable_record_spikes) SYMBOL_VISIBLE

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

bool operator== (SpikeMaster const &other) const SYMBOL_VISIBLE

Public Members

bool enable_record_spikes

Enable spike recording.

size_t neuron_on_compartment

Index of neuron on compartment.

Friends

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

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

#include <range_split.h>

Sub-range consisting of local size and offset.

Public Members

size_t offset

size_t size

struct grenade::vx::signal_flow::vertex::Subtraction

#include <subtraction.h>

Subtraction of multiple inputs of signal_flow::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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = true

Private Functions

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

Private Members

size_t m_size = {}

Friends

friend struct cereal::access

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

struct grenade::vx::signal_flow::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 struct cereal::access

struct grenade::vx::signal_flow::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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

void check (Rows const &rows, Columns const &columns, Weights const &weights, Labels const &labels) 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 struct 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::signal_flow::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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

void check (Rows const &rows, Columns const &columns, Synapses const &synapses) 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 struct cereal::access

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

struct grenade::vx::signal_flow::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 bool can_connect_different_execution_instances = false

static constexpr bool variadic_input = false

Private Functions

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

Private Members

Config m_config = {}

Coordinate m_coordinate = {}

Friends

friend struct cereal::access

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

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

#include <synapse_driver_on_dls_manager.h>

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

Public Types

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

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

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

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

Allocation requests ordered by PADI-bus.

Template Parameters

• Key – PADI-bus location

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

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

typedef grenade::vx::network::routing::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::routing::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::LoggerPtr m_logger

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

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

#include <synapse_driver_on_padi_bus_manager.h>

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

Public Types

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

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

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

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

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

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

Template Parameters

• Key – Synapse driver location

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

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

Mask values which isolate a given requested allocation.

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

Template Parameters

• Key – Index in the requested allocations

• Value – Collection of masks

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

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

typedef grenade::vx::network::routing::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::routing::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::signal_flow::vertex::PlasticityRule::SynapseViewShape

#include <plasticity_rule.h>

Shape of a single synapse view to be altered.

Public Functions

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

bool operator== (SynapseViewShape const &other) const SYMBOL_VISIBLE

Public Members

std::vector<halco::hicann_dls::vx::v3::SynapseOnSynapseRow> columns

Location of columns.

This information is needed for extraction of timed recording observables.

halco::hicann_dls::vx::v3::HemisphereOnDLS hemisphere

Hemisphere of synapses.

This information is required for extraction of timed recording observables.

size_t num_rows

Number of rows.

Private Functions

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

Friends

friend struct cereal::access

friend std::ostream & operator<< (std::ostream &os, SynapseViewShape const &recording) SYMBOL_VISIBLE

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

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

#include <time.h>

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

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

Public Functions

inline explicit constexpr Time(value_type const value = 0)

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

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

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

Public Static Attributes

static const Time fpga_clock_cycles_per_us SYMBOL_VISIBLE

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

#include <timed_data.h>

Public Types

typedef T Data

Public Functions

TimedData() = default

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

bool operator!=(TimedData const &other) const

bool operator==(TimedData const &other) const

Public Members

T data

Time time

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording

#include <plasticity_rule.h>

Recording information for execution of the rule.

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

Public Types

typedef std::variant<ObservablePerSynapse, ObservablePerNeuron, ObservableArray> Observable

Observable type specification.

Public Functions

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

bool operator== (TimedRecording const &other) const SYMBOL_VISIBLE

Public Members

std::map<std::string, Observable> observables

Map of named observables with type information.

The plasticity rule kernel is given memory to record the observables generated with the same names as used in this map.

Private Functions

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

Friends

friend struct cereal::access

friend std::ostream & operator<< (std::ostream &os, TimedRecording const &recording) SYMBOL_VISIBLE

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

#include <plasticity_rule.h>

Extracted recorded data of observables corresponding to timed recording.

Public Types

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

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

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

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

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

Public Members

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

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

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

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecordingData

#include <plasticity_rule.h>

Extracted recorded data of observables corresponding to timed recording.

Public Types

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

Public Members

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

std::map<std::string, std::vector<Entry>> data_per_neuron

std::map<std::string, std::vector<Entry>> data_per_synapse

Friends

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

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

#include <timed_spike_to_chip_sequence.h>

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

Public Types

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

typedef hate::Nil Result

Public Functions

inline TimedSpikeToChipSequence(signal_flow::TimedSpikeToChipSequence const &values)

Protected Functions

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

Private Members

signal_flow::TimedSpikeToChipSequence const &m_values

Friends

friend auto generate(TimedSpikeToChipSequence 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::signal_flow::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 struct 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::signal_flow::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 bool can_connect_different_execution_instances = true

static constexpr bool variadic_input = false

Private Functions

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

Private Members

std::unique_ptr<Function> m_function = {}

Friends

friend struct cereal::access

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

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservableArray::Type

#include <plasticity_rule.h>

Public Static Attributes

static constexpr Int16 int16 = {}

static constexpr Int8 int8 = {}

static constexpr UInt16 uint16 = {}

static constexpr UInt8 uint8 = {}

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerNeuron::Type

#include <plasticity_rule.h>

Public Static Attributes

static constexpr Int16 int16 = {}

static constexpr Int8 int8 = {}

static constexpr UInt16 uint16 = {}

static constexpr UInt8 uint8 = {}

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerSynapse::Type

#include <plasticity_rule.h>

Public Static Attributes

static constexpr Int16 int16 = {}

static constexpr Int8 int8 = {}

static constexpr UInt16 uint16 = {}

static constexpr UInt8 uint8 = {}

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservableArray::Type::UInt16 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<uint16_t, UInt16>

#include <plasticity_rule.h>

Public Types

typedef uint16_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "uint16_t"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerNeuron::Type::UInt16 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<uint16_t, UInt16>

#include <plasticity_rule.h>

Public Types

typedef uint16_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowMod16"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerSynapse::Type::UInt16 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<uint16_t, UInt16>

#include <plasticity_rule.h>

Public Types

typedef uint16_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowMod16"

struct grenade::vx::signal_flow::UInt32 : public halco::common::detail::BaseType<UInt32, uint32_t>

#include <types.h>

32 bit wide unsigned integer value of e.g.

indices.

Public Functions

inline explicit constexpr UInt32(value_type const value = 0)

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservableArray::Type::UInt8 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<uint8_t, UInt8>

#include <plasticity_rule.h>

Public Types

typedef uint8_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "uint8_t"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerNeuron::Type::UInt8 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<uint8_t, UInt8>

#include <plasticity_rule.h>

Public Types

typedef uint8_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowMod8"

struct grenade::vx::signal_flow::vertex::PlasticityRule::TimedRecording::ObservablePerSynapse::Type::UInt8 : public grenade::vx::signal_flow::vertex::plasticity_rule::ObservableDataType<uint8_t, UInt8>

#include <plasticity_rule.h>

Public Types

typedef uint8_t ElementType

Public Static Attributes

static constexpr char on_ppu_type[] = "libnux::vx::VectorRowMod8"

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::signal_flow::vertex::PlasticityRule::Timer::Value : public halco::common::detail::RantWrapper<Value, uintmax_t, 0xffffffff, 0>

#include <plasticity_rule.h>

PPU clock cycles.

Public Functions

inline explicit constexpr Value(uintmax_t const value = 0)

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

#include <vertex_concept.h>

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

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

Public Static Attributes

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

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

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

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

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

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

#include <projection.h>

Public Functions

inline explicit constexpr Weight(value_type const value = 0)

namespace cereal

namespace grenade

namespace grenade::vx

Functions

halco::common::typed_array< int8_t, halco::hicann_dls::vx::v3::NeuronColumnOnDLS > from_vector_unit_row (haldls::vx::v3::PPUMemoryBlock const &values) 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.

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

static constexpr size_t num_cadc_samples_in_extmem = 100

static constexpr size_t ppu_vector_alignment = 128

namespace grenade::vx::common

Typedefs

template<typename T>
using TimedDataSequence = std::vector<TimedData<T>>

namespace compute

namespace detail

namespace grenade::vx::execution

Functions

signal_flow::IODataList run (JITGraphExecutor &executor, signal_flow::Graph const &graph, signal_flow::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

signal_flow::IODataList run (JITGraphExecutor &executor, signal_flow::Graph const &graph, signal_flow::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

signal_flow::IODataMap run (JITGraphExecutor &executor, signal_flow::Graph const &graph, signal_flow::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

signal_flow::IODataMap run (JITGraphExecutor &executor, signal_flow::Graph const &graph, signal_flow::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

namespace grenade::vx::execution::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 detail

namespace generator

namespace grenade::vx::network

Typedefs

typedef common::TimedData<std::vector<int16_t>> _ArrayEntryInt16

typedef common::TimedData<std::vector<int8_t>> _ArrayEntryInt8

typedef common::TimedData<std::vector<uint16_t>> _ArrayEntryUInt16

typedef common::TimedData<std::vector<uint8_t>> _ArrayEntryUInt8

typedef common::TimedData<std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<int16_t>>>> _SingleEntryPerNeuronInt16

typedef common::TimedData<std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<int8_t>>>> _SingleEntryPerNeuronInt8

typedef common::TimedData<std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<uint16_t>>>> _SingleEntryPerNeuronUInt16

typedef common::TimedData<std::vector<std::map<halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, std::vector<uint8_t>>>> _SingleEntryPerNeuronUInt8

typedef common::TimedData<std::vector<std::vector<int16_t>>> _SingleEntryPerSynapseInt16

typedef common::TimedData<std::vector<std::vector<int8_t>>> _SingleEntryPerSynapseInt8

typedef common::TimedData<std::vector<std::vector<uint16_t>>> _SingleEntryPerSynapseUInt16

typedef common::TimedData<std::vector<std::vector<uint8_t>>> _SingleEntryPerSynapseUInt8

typedef std::map<ProjectionDescriptor, std::vector<ConnectionToHardwareRoutes>> ConnectionRoutingResult

Translation between synapses between logical neuron compartments and synapses between atomic neurons within compartments.

Contains a translation for each connection of each projection. The order of the translations matches the order of the connections in the projection.

typedef std::vector<ConnectumConnection> Connectum

Functions

cls def(pybind11::init<::grenade::vx::network::routing::SynapseDriverOnDLSManager::AllocationPolicyGreedy >(), pybind11::arg("value")=::grenade::vx::network::routing::SynapseDriverOnDLSManager::AllocationPolicyGreedy()) .def(pybind11 parent attr ("RoutingOptions").attr("AllocationPolicy")

ConnectionRoutingResult build_connection_routing (std::shared_ptr< Network > const &network) SYMBOL_VISIBLE

Build a connection routing for a given network.

This is the first step in two-stage routing towards a hardware data-flow graph representation.

Parameters

network – Network for which to build connection routing

std::vector< lola::vx::v3::SynapseMatrix::Weight > build_connection_weight_split (Projection::Connection::Weight const &weight, size_t num) SYMBOL_VISIBLE

Split weight of connection into single hardware synapse circuit weight values.

This function splits like 123 -> 63 + 60 + 0.

Parameters

• weight – Weight to split

• num – Number of synapses to split weight onto

NetworkGraph build_network_graph (std::shared_ptr< Network > const &network, RoutingResult const &routing_result, signal_flow::ExecutionInstance const &execution_instance=signal_flow::ExecutionInstance()) SYMBOL_VISIBLE

Build a hardware network representation for a given network.

Parameters

• network – Network for which to build hardware network representation

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

• execution_instance – Execution instance to build the hardware graph into

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< execution::backend::Connection > &conn, lola::vx::v3::Chip const &config, network::NetworkGraph const &network_graph, signal_flow::IODataMap const &inputs) -> signal_flow::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< execution::backend::Connection > &conn, lola::vx::v3::Chip const &config, network::NetworkGraph const &network_graph, signal_flow::IODataMap const &inputs, signal_flow::ExecutionInstancePlaybackHooks &playback_hooks) -> signal_flow::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< execution::JITGraphExecutor > &conn, lola::vx::v3::Chip const &config, network::NetworkGraph const &network_graph, signal_flow::IODataMap const &inputs) -> signal_flow::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< execution::JITGraphExecutor > &conn, lola::vx::v3::Chip const &config, network::NetworkGraph const &network_graph, signal_flow::IODataMap const &inputs, signal_flow::ExecutionInstancePlaybackHooks &playback_hooks) -> signal_flow::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< common::Time, PopulationDescriptor, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron, size_t, signal_flow::Int8 > > > extract_cadc_samples (signal_flow::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 matching of logical to hardware neurons

• hardware_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 location alongside the ADC value.

std::vector< std::vector< std::tuple< common::Time, AtomicNeuronOnNetwork, haldls::vx::v3::MADCSampleFromChip::Value > > > extract_madc_samples (signal_flow::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 matching of logical to hardware neurons

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

Returns

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

std::vector< std::map< std::tuple< PopulationDescriptor, size_t, halco::hicann_dls::vx::v3::CompartmentOnLogicalNeuron >, std::vector< common::Time > > > extract_neuron_spikes (signal_flow::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 logical to hardware neurons

• hardware_network_graph – Network graph to use for matching of spike labels to neurons

Returns

Time-series neuron spike data per batch entry

PlasticityRule::RecordingData extract_plasticity_rule_recording_data (signal_flow::IODataMap const &data, NetworkGraph const &network_graph, PlasticityRuleDescriptor descriptor) SYMBOL_VISIBLE

Extract to be recorded observable data of a plasticity rule.

Parameters

• data – Data containing observables

• network_graph – Network graph to use for hardware to logical network translation

• descriptor – Descriptor to plasticity rule to extract observable data for

Returns

Observable data per batch entry

NetworkGraphStatistics extract_statistics (NetworkGraph const &network_graph) 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

size_t hash_value (Receptor const &receptor) 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, Receptor::Type const &receptor_type) SYMBOL_VISIBLE

bool requires_routing (std::shared_ptr< Network > const &current, NetworkGraph const &old_graph) SYMBOL_VISIBLE

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

Parameters

• current – Current network

• old_graph – Old routed network

Returns

Boolean value

signal_flow::IODataMap run (execution::backend::Connection &connection, lola::vx::v3::Chip const &config, NetworkGraph const &network_graph, signal_flow::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

signal_flow::IODataMap run (execution::backend::Connection &connection, lola::vx::v3::Chip const &config, NetworkGraph const &network_graph, signal_flow::IODataMap const &inputs, signal_flow::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

signal_flow::IODataMap run (execution::JITGraphExecutor &executor, lola::vx::v3::Chip const &config, NetworkGraph const &network_graph, signal_flow::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

signal_flow::IODataMap run (execution::JITGraphExecutor &executor, lola::vx::v3::Chip const &config, NetworkGraph const &network_graph, signal_flow::IODataMap const &inputs, signal_flow::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

signal_flow::IODataMap run (hxcomm::vx::ConnectionVariant &connection, lola::vx::v3::Chip const &config, NetworkGraph const &network_graph, signal_flow::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

signal_flow::IODataMap run (hxcomm::vx::ConnectionVariant &connection, lola::vx::v3::Chip const &config, NetworkGraph const &network_graph, signal_flow::IODataMap const &inputs, signal_flow::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

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::signal_flow::IODataMap const& data,                                       grenade::vx::network::NetworkGraph const& network_graph) { hate::Timer timer; auto logger = log4cxx::Logger::getLogger("pygrenade.network.extract_cadc_samples"); 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>,       pybind11::array_t<int>, 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), pybind11::array_t<int>(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> descriptor(static_cast<pybind11::ssize_t>(cadc_samples.size())); pybind11::array_t<int> nrn_on_pop(static_cast<pybind11::ssize_t>(cadc_samples.size())); pybind11::array_t<int> comp_on_nrn(static_cast<pybind11::ssize_t>(cadc_samples.size())); pybind11::array_t<int> an_on_comp(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)); descriptor.mutable_at(i) = std::get<1>(sample).value(); nrn_on_pop.mutable_at(i) = std::get<2>(sample); comp_on_nrn.mutable_at(i) = std::get<3>(sample).value(); an_on_comp.mutable_at(i) = std::get<4>(sample); values.mutable_at(i) = std::get<5>(sample).value(); } ret.at(b) =        std::make_tuple(times, descriptor, nrn_on_pop, comp_on_nrn, an_on_comp, values); } LOG4CXX_TRACE(logger, "Execution duration: " << timer.print() << "."); return ret; }

auto const extract_madc_samples = [convert_ms](                                       grenade::vx::signal_flow::IODataMap const& data,                                       grenade::vx::network::NetworkGraph const& network_graph) { hate::Timer timer; auto logger = log4cxx::Logger::getLogger("pygrenade.network.extract_madc_samples"); auto const samples = grenade::vx::network::extract_madc_samples(data, network_graph); std::vector<std::tuple<       pybind11::array_t<float>, pybind11::array_t<int>, pybind11::array_t<int>,       pybind11::array_t<int>, pybind11::array_t<int>, pybind11::array_t<int>>>       ret(samples.size()); for (size_t b = 0; b < samples.size(); ++b) { auto const madc_samples = samples.at(b); if (madc_samples.empty()) { ret.at(b) = std::make_tuple(         pybind11::array_t<float>(0), pybind11::array_t<int>(0),         pybind11::array_t<int>(0), pybind11::array_t<int>(0), pybind11::array_t<int>(0),         pybind11::array_t<int>(0)); continue; } pybind11::array_t<float> times(static_cast<pybind11::ssize_t>(madc_samples.size())); pybind11::array_t<int> descriptor(static_cast<pybind11::ssize_t>(madc_samples.size())); pybind11::array_t<int> nrn_on_pop(static_cast<pybind11::ssize_t>(madc_samples.size())); pybind11::array_t<int> comp_on_nrn(static_cast<pybind11::ssize_t>(madc_samples.size())); pybind11::array_t<int> an_on_comp(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(std::get<0>(sample)); descriptor.mutable_at(i) = std::get<1>(sample).population.value(); nrn_on_pop.mutable_at(i) = std::get<1>(sample).neuron_on_population; comp_on_nrn.mutable_at(i) = std::get<1>(sample).compartment_on_neuron.value(); an_on_comp.mutable_at(i) = std::get<1>(sample).atomic_neuron_on_compartment; values.mutable_at(i) = std::get<2>(sample).value(); } ret.at(b) =        std::make_tuple(times, descriptor, nrn_on_pop, comp_on_nrn, an_on_comp, values); } LOG4CXX_TRACE(logger, "Execution duration: " << timer.print() << "."); return ret; }

auto const extract_neuron_spikes = [convert_ms](         grenade::vx::signal_flow::IODataMap const& data,         grenade::vx::network::NetworkGraph const& network_graph) {       hate::Timer timer;       auto logger = log4cxx::Logger::getLogger("pygrenade.network.extract_neuron_spikes");       auto const spikes = grenade::vx::network::extract_neuron_spikes(data, network_graph);       std::vector<std::map<std::tuple<int, int, 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));         }         auto const& [descriptor, nrn_on_pop, comp_on_nrn] = neuron;         ret.at(b)[std::tuple<int, int, int>(descriptor, nrn_on_pop, comp_on_nrn)] =             pytimes;        }       }       LOG4CXX_TRACE(logger, "Execution duration: " << timer.print() << ".");       return ret;     }

PyNN’s format expects times in floating-point ms, neuron (compartment)s as integer representation of the enum values and sample values as integer values.

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

signal_flow::IODataMap m_data = {}

NetworkGraph const &m_network_graph

struct grenade::vx::network::Projection operator   ==(Projection const& other) const SYMBOL_VISIBLE

namespace grenade::vx::network::routing

Functions

std::ostream & operator<< (std::ostream &os, SynapseDriverOnPADIBusManager::AllocationPolicy const &value) SYMBOL_VISIBLE

namespace detail

namespace grenade::vx::ppu

Functions

template<typename T, typename HandleI, typename HandleO>
libnux::vx::VectorRow<T> translate_columns(libnux::vx::VectorRow<T> const &input, HandleI const &input_handle, HandleO const &output_handle)

Translate vector row values from columns of input handle to columns of output handle.

Translates sequentially, if there are less active columns in input than in output broadcasts last value, if there are more active columns in input than in output drops the additional values.

Parameters

• input – Input values

• input_handle – Input handle for active column lookup

• output_handle – Output handle for active column lookup

namespace grenade::vx::ppu::detail

Enums

enum 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

enum Stopped

Values:

enumerator no

enumerator yes

Variables

constexpr size_t cadc_recording_storage_base_bottom = 65536

constexpr size_t cadc_recording_storage_base_top = 0

constexpr size_t cadc_recording_storage_size = 65536

namespace grenade::vx::signal_flow

Typedefs

typedef halco::hicann_dls::vx::v3::SpikeLabel SpikeFromChip

From-chip spike.

typedef std::variant<haldls::vx::v3::SpikePack1ToChip, haldls::vx::v3::SpikePack2ToChip, haldls::vx::v3::SpikePack3ToChip> SpikeToChip

To-chip spike.

typedef common::TimedData<MADCSampleFromChip> TimedMADCSampleFromChip

Time-annotated from-chip MADC sample.

typedef std::vector<TimedMADCSampleFromChip> TimedMADCSampleFromChipSequence

Sequence of time-annotated from-chip MADC events.

typedef common::TimedData<SpikeFromChip> TimedSpikeFromChip

Time-annotated from-chip spike.

typedef std::vector<TimedSpikeFromChip> TimedSpikeFromChipSequence

Sequence of time-annotated from-chip spike events.

typedef common::TimedData<SpikeToChip> TimedSpikeToChip

Time-annotated to-chip spike.

typedef std::vector<TimedSpikeToChip> TimedSpikeToChipSequence

Sequence of timed to-chip spike events.

typedef haldls::vx::v3::PADIEvent::HagenActivation UInt5

5 bit wide unsigned activation value type.

typedef std::variant<vertex::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 TimedSpikeToChipSequence

enumerator TimedSpikeFromChipSequence

enumerator TimedMADCSampleFromChipSequence

enumerator DataTimedSpikeToChipSequence

enumerator DataTimedSpikeFromChipSequence

enumerator DataTimedMADCSampleFromChipSequence

enumerator DataInt8

enumerator DataUInt5

enumerator DataUInt32

enumerator CrossbarInputLabel

enumerator CrossbarOutputLabel

enumerator SynapseDriverInputLabel

Functions

size_t hash_value (ExecutionInstance const &e) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, ConnectionType const &type) SYMBOL_VISIBLE

template<typename Vertex, typename InputVertex>
bool supports_input_from(Vertex const &vertex, InputVertex const &input, std::optional<PortRestriction> const &port_restriction)

Get whether given vertex supports input from given input vertex with optional port restriction.

Default assumption is that the connection is supported. Restrictions can be defined by a member function of signature: supports_input_from(OtherVertex const&, std::optional<PortRestriction> const&).

Template Parameters

• Vertex – Type of vertex

• InputVertex – Type of input vertex

Parameters

• vertex – Vertex to check

• input_vertex – Input vertex to check

• port_restriction – Optional port restriction to apply to check

Variables

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

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

namespace grenade::vx::signal_flow::detail

Typedefs

typedef Graph::edge_descriptor edge_descriptor

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

Bidirectional graph.

template<typename Vertex, typename InputVertex>
using has_supports_input_from = decltype(std::declval<Vertex>().supports_input_from(std::declval<InputVertex>(), std::declval<std::optional<PortRestriction>>()))

typedef Graph::vertex_descriptor vertex_descriptor

namespace grenade::vx::signal_flow::vertex

Functions

std::ostream & operator<< (std::ostream &os, PlasticityRule::TimedRecording::ObservablePerNeuron::Layout const &layout) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, PlasticityRule::TimedRecording::ObservablePerSynapse::LayoutPerRow const &layout) SYMBOL_VISIBLE

namespace plasticity_rule

namespace transformation

namespace halco

namespace common

namespace detail

namespace hate

namespace log4cxx

Typedefs

typedef std::shared_ptr<Logger> LoggerPtr

namespace lola

namespace vx

namespace v3

namespace stadls

namespace vx

namespace stadls::vx::v3

Typedefs

using PlaybackProgram = stadls::vx::PlaybackProgram

namespace std

STL namespace.

file cerealization.h

#include “cereal/types/haldls/cereal.tcc”

Defines

EXPLICIT_INSTANTIATE_CEREAL_LOAD_SAVE(CLASS_NAME)

file time.h

#include “grenade/vx/genpybind.h”#include “halco/common/geometry.h”#include “haldls/vx/v3/event.h”#include “haldls/vx/v3/timer.h”#include “hate/visibility.h”

file timed_data.h

#include “grenade/vx/common/time.h”#include “grenade/vx/genpybind.h”#include <vector>#include “grenade/vx/common/timed_data.tcc”

file addition.h

#include <vector>#include “grenade/vx/signal_flow/graph.h”#include “grenade/vx/signal_flow/types.h”

file addition.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>

file argmax.h

#include <vector>#include “grenade/vx/signal_flow/graph.h”#include “grenade/vx/signal_flow/types.h”

file argmax.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/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/common/time.h”#include “grenade/vx/compute/mac.h”#include “grenade/vx/signal_flow/types.h”#include “grenade/vx/compute/conv1d.tcc”

file converting_relu.h

#include <vector>#include “grenade/vx/signal_flow/graph.h”#include “grenade/vx/signal_flow/types.h”

file converting_relu.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>

file range_split.h

#include “hate/visibility.h”#include <cstddef>#include <vector>

file single_chip_execution_instance_manager.h

#include “grenade/vx/signal_flow/execution_instance.h”#include “halco/hicann-dls/vx/v3/chip.h”#include “hate/visibility.h”

file mac.h

#include <vector>#include <gtest/gtest_prod.h>#include “grenade/vx/common/time.h”#include “grenade/vx/execution/jit_graph_executor.h”#include “grenade/vx/signal_flow/graph.h”#include “grenade/vx/signal_flow/types.h”#include “grenade/vx/signal_flow/vertex/synapse_array_view.h”#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “haldls/vx/v3/event.h”#include “haldls/vx/v3/synapse_driver.h”#include “lola/vx/v3/synapse.h”#include <string>#include “grenade/vx/compute/mac.tcc”

file relu.h

#include <vector>#include “grenade/vx/signal_flow/graph.h”#include “grenade/vx/signal_flow/types.h”

file relu.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/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/signal_flow/io_data_list.h”#include “hate/visibility.h”#include <list>#include <variant>

file connection.h

#include “grenade/vx/genpybind.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 “hate/visibility.h”#include “stadls/vx/run_time_info.h”

file run.h

#include “grenade/vx/execution/jit_graph_executor.h”#include “hate/visibility.h”

file run.h

#include “grenade/vx/execution/backend/connection.h”#include “grenade/vx/execution/jit_graph_executor.h”#include “grenade/vx/genpybind.h”#include “grenade/vx/network/network_graph.h”#include “grenade/vx/signal_flow/execution_instance_playback_hooks.h”#include “grenade/vx/signal_flow/io_data_map.h”#include “hate/visibility.h”#include “hxcomm/vx/connection_variant.h”

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 <mutex>#include <vector>

file execution_instance_builder.h

#include <atomic>#include <optional>#include <set>#include <vector>#include “grenade/vx/execution/detail/generator/neuron_reset_mask.h”#include “grenade/vx/signal_flow/execution_instance.h”#include “grenade/vx/signal_flow/execution_instance_playback_hooks.h”#include “grenade/vx/signal_flow/graph.h”#include “grenade/vx/signal_flow/io_data_map.h”#include “grenade/vx/signal_flow/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/container_ticket.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/ppu/neuron_view_handle.h”#include “grenade/vx/ppu/synapse_array_view_handle.h”#include “grenade/vx/signal_flow/execution_instance.h”#include “grenade/vx/signal_flow/graph.h”#include “grenade/vx/signal_flow/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 <memory>#include <tbb/flow_graph.h>#include “grenade/vx/execution/detail/connection_state_storage.h”#include “grenade/vx/execution/detail/execution_instance_builder.h”#include “grenade/vx/signal_flow/execution_instance_playback_hooks.h”#include “grenade/vx/signal_flow/graph.h”#include “grenade/vx/signal_flow/io_data_map.h”#include “hate/visibility.h”#include “lola/vx/v3/chip.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/detail/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 <map>#include <mutex>#include <optional>#include <string>#include <vector>

file timed_spike_to_chip_sequence.h

#include “grenade/vx/signal_flow/event.h”#include “hate/nil.h”#include “hate/visibility.h”#include “stadls/vx/v3/playback_generator.h”

file ppu_program_generator.h

#include “grenade/vx/ppu/neuron_view_handle.h”#include “grenade/vx/ppu/synapse_array_view_handle.h”#include “grenade/vx/signal_flow/graph.h”#include “grenade/vx/signal_flow/vertex/plasticity_rule.h”#include “halco/hicann-dls/vx/v3/synapse.h”#include “halco/hicann-dls/vx/v3/synram.h”#include “hate/visibility.h”#include <tuple>#include <vector>

file jit_graph_executor.h

#include <map>#include <unordered_map>#include “grenade/vx/execution/backend/connection.h”#include “grenade/vx/execution/detail/connection_state_storage.h”#include “grenade/vx/signal_flow/execution_instance.h”#include “grenade/vx/signal_flow/execution_instance_playback_hooks.h”#include “halco/hicann-dls/vx/v3/chip.h”#include “hate/visibility.h”#include “lola/vx/v3/chip.h”

file python_bindings.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/common/time.h”

file python_bindings.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/execution/backend/connection.h”#include “grenade/vx/execution/jit_graph_executor.h”

file python_bindings.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/network/background_source_population.h”#include “grenade/vx/network/build_routing.h”#include “grenade/vx/network/connection_routing_result.h”#include “grenade/vx/network/external_source_population.h”#include “grenade/vx/network/extract_output.h”#include “grenade/vx/network/generate_input.h”#include “grenade/vx/network/network.h”#include “grenade/vx/network/network_builder.h”#include “grenade/vx/network/network_graph.h”#include “grenade/vx/network/network_graph_builder.h”#include “grenade/vx/network/network_graph_statistics.h”#include “grenade/vx/network/plasticity_rule.h”#include “grenade/vx/network/plasticity_rule_generator.h”#include “grenade/vx/network/population.h”#include “grenade/vx/network/projection.h”#include “grenade/vx/network/requires_routing.h”#include “grenade/vx/network/run.h”

file python_bindings.h

#include “grenade/vx/genpybind.h”

file python_bindings.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/signal_flow/event.h”#include “grenade/vx/signal_flow/execution_instance.h”#include “grenade/vx/signal_flow/execution_instance_playback_hooks.h”#include “grenade/vx/signal_flow/execution_time_info.h”#include “grenade/vx/signal_flow/graph.h”#include “grenade/vx/signal_flow/io_data_map.h”#include “grenade/vx/signal_flow/types.h”

file genpybind.h

#include <genpybind.h>

Defines

GENPYBIND_MODULE

GENPYBIND_TAG_GRENADE_VX

GENPYBIND_TAG_GRENADE_VX_COMMON

GENPYBIND_TAG_GRENADE_VX_EXECUTION

GENPYBIND_TAG_GRENADE_VX_NETWORK

GENPYBIND_TAG_GRENADE_VX_SIGNAL_FLOW

file atomic_neuron_on_network.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/network/population_descriptor.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “hate/visibility.h”#include <cstddef>#include <iosfwd>

file background_source_population.h

#include “grenade/vx/genpybind.h”#include “halco/hicann-dls/vx/v3/chip.h”#include “halco/hicann-dls/vx/v3/padi.h”#include “haldls/vx/v3/background.h”#include “hate/visibility.h”#include <iosfwd>#include <map>

file build_connection_routing.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/network/connection_routing_result.h”#include “grenade/vx/network/network.h”#include “hate/visibility.h”#include <memory>

file build_connection_weight_split.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/network/projection.h”#include “lola/vx/v3/synapse.h”#include <vector>

file build_routing.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/network/routing_options.h”#include “grenade/vx/network/routing_result.h”#include “hate/visibility.h”#include <memory>#include <optional>

file cadc_recording.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/network/population_descriptor.h”#include “hate/visibility.h”#include “lola/vx/v3/neuron.h”

file connection_routing_result.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/network/projection.h”#include “hate/visibility.h”#include <cstddef>#include <iosfwd>#include <map>#include <vector>

file connectum.h

#include “grenade/vx/network/population_descriptor.h”#include “grenade/vx/network/projection.h”#include “grenade/vx/signal_flow/graph.h”#include “haldls/vx/v3/event.h”#include “hate/visibility.h”#include <iosfwd>#include <variant>#include <vector>

file exception.h

#include “hate/visibility.h”#include <exception>#include <string>

file external_source_population.h

#include “grenade/vx/genpybind.h”#include “hate/visibility.h”#include <cstddef>#include <iosfwd>

file extract_output.h

#include “grenade/vx/common/time.h”#include “grenade/vx/genpybind.h”#include “grenade/vx/network/atomic_neuron_on_network.h”#include “grenade/vx/network/network_graph.h”#include “grenade/vx/signal_flow/io_data_map.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include <map>#include <tuple>#include <vector>

file generate_input.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/network/network_graph.h”#include “grenade/vx/signal_flow/event.h”#include “grenade/vx/signal_flow/io_data_map.h”

Functions

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

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

void add (std::vector< std::vector< std::vector< common::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::common::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::common::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::common::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/atomic_neuron_on_network.h”#include “hate/visibility.h”#include “lola/vx/v3/neuron.h”

file network.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/network/background_source_population.h”#include “grenade/vx/network/cadc_recording.h”#include “grenade/vx/network/external_source_population.h”#include “grenade/vx/network/madc_recording.h”#include “grenade/vx/network/plasticity_rule.h”#include “grenade/vx/network/population.h”#include “grenade/vx/network/population_descriptor.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/cadc_recording.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/network/network.h”#include “grenade/vx/network/network_graph_statistics.h”#include “grenade/vx/network/population_descriptor.h”#include “grenade/vx/signal_flow/graph.h”#include “hate/visibility.h”#include <map>#include <optional>

file network_graph_builder.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/network/cadc_recording.h”#include “grenade/vx/network/madc_recording.h”#include “grenade/vx/network/network.h”#include “grenade/vx/network/network_graph.h”#include “grenade/vx/network/plasticity_rule.h”#include “grenade/vx/network/population_descriptor.h”#include “grenade/vx/network/projection.h”#include “grenade/vx/network/routing_result.h”#include “grenade/vx/signal_flow/execution_instance.h”#include “grenade/vx/signal_flow/graph.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 “grenade/vx/signal_flow/vertex/plasticity_rule.h”#include “halco/common/geometry.h”#include “hate/visibility.h”#include <map>#include <optional>#include <string>#include <vector>

file plasticity_rule.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/event.h”#include “grenade/vx/signal_flow/port.h”#include “grenade/vx/signal_flow/vertex/neuron_view.h”#include “grenade/vx/signal_flow/vertex/plasticity_rule/observable_data_type.h”#include “halco/common/geometry.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/v3/chip.h”#include “halco/hicann-dls/vx/v3/synapse.h”#include “haldls/vx/v3/neuron.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <iosfwd>#include <map>#include <optional>#include <string>#include <vector>

file plasticity_rule_generator.h

#include “grenade/vx/network/plasticity_rule.h”#include “hate/visibility.h”#include <set>

file population.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/network/receptor.h”#include “halco/common/geometry.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 <iosfwd>#include <map>#include <optional>#include <set>#include <unordered_set>#include <vector>

file population_descriptor.h

#include “grenade/vx/genpybind.h”#include “halco/common/geometry.h”

file projection.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/network/population_descriptor.h”#include “grenade/vx/network/receptor.h”#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “hate/visibility.h”#include <vector>

Functions

std::ostream & operator<< (std::ostream &os, Projection::Connection::Index const &index) SYMBOL_VISIBLE

file README.md

file receptor.h

#include “grenade/vx/genpybind.h”#include “halco/common/geometry.h”#include “hate/visibility.h”#include <iosfwd>

file requires_routing.h

#include “grenade/vx/genpybind.h”#include “hate/visibility.h”#include <memory>

file synapse_driver_on_dls_manager.h

#include “grenade/vx/network/routing/synapse_driver_on_dls_manager.h”#include “grenade/vx/network/routing/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/routing/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 <memory>#include <optional>#include <set>#include <vector>

file synapse_driver_on_padi_bus_manager.h

#include “grenade/vx/network/routing/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 routing_builder.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/network/connection_routing_result.h”#include “grenade/vx/network/network.h”#include “grenade/vx/network/population_descriptor.h”#include “grenade/vx/network/projection.h”#include “grenade/vx/network/routing/routing_constraints.h”#include “grenade/vx/network/routing/source_on_padi_bus_manager.h”#include “grenade/vx/network/routing/synapse_driver_on_dls_manager.h”#include “grenade/vx/network/routing_options.h”#include “grenade/vx/network/routing_result.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/v3/event.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/connection_routing_result.h”#include “grenade/vx/network/population_descriptor.h”#include “grenade/vx/network/projection.h”#include “grenade/vx/network/receptor.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/v3/background.h”#include “halco/hicann-dls/vx/v3/chip.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 source_on_padi_bus_manager.h

#include “grenade/vx/network/routing/source_on_padi_bus_manager.h”#include “grenade/vx/network/routing/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/receptor.h”#include “grenade/vx/network/routing/synapse_driver_on_dls_manager.h”#include “halco/hicann-dls/vx/v3/chip.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 <memory>#include <optional>#include <set>#include <vector>

file routing_options.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/network/routing/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/connection_routing_result.h”#include “halco/hicann-dls/vx/v3/event.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/routing_crossbar.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 extmem.h

#include <cstddef>

file status.h

#include <cstdint>

file stopped.h

#include <cstdint>

file neuron_view_handle.h

#include “hate/bitset.h”#include “grenade/vx/ppu/neuron_view_handle.tcc”

file synapse_array_view_handle.h

#include “hate/bitset.h”#include “grenade/vx/ppu/synapse_array_view_handle.tcc”

file translate_columns.h

#include “libnux/vx/vector_row.h”

file connection_type.h

#include “hate/visibility.h”#include <array>#include <iosfwd>

file graph.h

#include <boost/graph/adjacency_list.hpp>

file graph.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/signal_flow/detail/graph.h”#include “grenade/vx/signal_flow/execution_instance.h”#include “grenade/vx/signal_flow/port_restriction.h”#include “grenade/vx/signal_flow/vertex.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 “grenade/vx/signal_flow/graph.tcc”

file vertex_concept.h

#include <array>#include <cstddef>#include <type_traits>#include <utility>#include <variant>#include <vector>

file event.h

#include “grenade/vx/common/timed_data.h”#include “halco/hicann-dls/vx/v3/event.h”#include “haldls/vx/v3/event.h”#include “hate/visibility.h”#include <iosfwd>#include <variant>#include <vector>

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_playback_hooks.h

#include “grenade/vx/genpybind.h”#include “stadls/vx/v3/playback_program_builder.h”

file execution_time_info.h

#include “grenade/vx/genpybind.h”#include “grenade/vx/signal_flow/execution_instance.h”#include “halco/hicann-dls/vx/v3/chip.h”#include “hate/visibility.h”#include <chrono>#include <iosfwd>#include <map>#include <unordered_map>

file input.h

#include “grenade/vx/signal_flow/graph.h”#include “grenade/vx/signal_flow/port_restriction.h”#include “hate/visibility.h”#include <iosfwd>#include <optional>

file io_data_list.h

#include “grenade/vx/signal_flow/event.h”#include “grenade/vx/signal_flow/io_data_map.h”#include “grenade/vx/signal_flow/types.h”#include “hate/visibility.h”#include <list>#include <vector>

file io_data_map.h

#include “grenade/vx/common/time.h”#include “grenade/vx/common/timed_data.h”#include “grenade/vx/genpybind.h”#include “grenade/vx/signal_flow/detail/graph.h”#include “grenade/vx/signal_flow/event.h”#include “grenade/vx/signal_flow/execution_instance.h”#include “grenade/vx/signal_flow/execution_time_info.h”#include “grenade/vx/signal_flow/port.h”#include “grenade/vx/signal_flow/types.h”#include “haldls/vx/v3/timer.h”#include “hate/visibility.h”#include <map>#include <memory>#include <mutex>#include <optional>#include <unordered_map>#include <variant>

file port.h

#include <cstddef>#include <iosfwd>#include “grenade/vx/signal_flow/connection_type.h”#include “hate/visibility.h”

file port_restriction.h

#include “hate/visibility.h”#include <cstddef>#include <cstdint>#include <iosfwd>#include <optional>

file supports_input_from.h

#include “hate/type_traits.h”#include <optional>

file types.h

#include “grenade/vx/genpybind.h”#include “halco/common/geometry.h”#include “haldls/vx/v3/padi.h”

file vertex.h

#include “grenade/vx/signal_flow/detail/vertex_concept.h”#include “grenade/vx/signal_flow/vertex/addition.h”#include “grenade/vx/signal_flow/vertex/argmax.h”#include “grenade/vx/signal_flow/vertex/background_spike_source.h”#include “grenade/vx/signal_flow/vertex/cadc_membrane_readout_view.h”#include “grenade/vx/signal_flow/vertex/converting_relu.h”#include “grenade/vx/signal_flow/vertex/crossbar_l2_input.h”#include “grenade/vx/signal_flow/vertex/crossbar_l2_output.h”#include “grenade/vx/signal_flow/vertex/crossbar_node.h”#include “grenade/vx/signal_flow/vertex/data_input.h”#include “grenade/vx/signal_flow/vertex/data_output.h”#include “grenade/vx/signal_flow/vertex/external_input.h”#include “grenade/vx/signal_flow/vertex/madc_readout.h”#include “grenade/vx/signal_flow/vertex/neuron_event_output_view.h”#include “grenade/vx/signal_flow/vertex/neuron_view.h”#include “grenade/vx/signal_flow/vertex/padi_bus.h”#include “grenade/vx/signal_flow/vertex/plasticity_rule.h”#include “grenade/vx/signal_flow/vertex/relu.h”#include “grenade/vx/signal_flow/vertex/subtraction.h”#include “grenade/vx/signal_flow/vertex/synapse_array_view.h”#include “grenade/vx/signal_flow/vertex/synapse_array_view_sparse.h”#include “grenade/vx/signal_flow/vertex/synapse_driver.h”#include “grenade/vx/signal_flow/vertex/transformation.h”#include <variant>

file background_spike_source.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/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/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/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 “lola/vx/v3/neuron.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>#include <optional>#include <vector>#include “grenade/vx/signal_flow/vertex/cadc_membrane_readout_view.tcc”

file crossbar_l2_input.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>

file crossbar_l2_output.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>#include <optional>

file crossbar_node.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/port.h”#include “grenade/vx/signal_flow/port_restriction.h”#include “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/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>

file data_output.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>#include <optional>

file external_input.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/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/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/port.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “haldls/vx/v3/event.h”#include “haldls/vx/v3/madc.h”#include “hate/visibility.h”#include “lola/vx/v3/neuron.h”#include <cstddef>#include <iosfwd>#include <optional>#include <tuple>#include <vector>

file neuron_event_output_view.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/port.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “hate/visibility.h”#include <array>#include <iosfwd>#include <map>#include <optional>

file neuron_view.h

#include “grenade/vx/ppu/neuron_view_handle.h”#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/port.h”#include “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/signal_flow/vertex/neuron_view.tcc”

file padi_bus.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/port.h”#include “halco/hicann-dls/vx/v3/padi.h”#include “hate/visibility.h”#include <array>#include <iosfwd>#include <optional>

file observable_data_type.h

#include “grenade/vx/genpybind.h”#include “hate/type_index.h”#include <cctype>#include <ostream>

file subtraction.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/port.h”#include “hate/visibility.h”#include <array>#include <cstddef>#include <cstdint>#include <iosfwd>

file synapse_array_view.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/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/signal_flow/vertex/synapse_array_view.tcc”

file synapse_array_view_sparse.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/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/signal_flow/vertex/synapse_array_view_sparse.tcc”

file synapse_driver.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/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/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/io_data_map.h”#include “grenade/vx/signal_flow/port.h”#include “hate/visibility.h”#include <memory>#include <ostream>#include <stddef.h>#include <variant>#include <vector>

file concatenation.h

#include “grenade/vx/signal_flow/connection_type.h”#include “grenade/vx/signal_flow/vertex/transformation.h”#include <vector>

file mac_spiketrain_generator.h

#include “grenade/vx/common/time.h”#include “grenade/vx/signal_flow/port.h”#include “grenade/vx/signal_flow/vertex/transformation.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/v3/chip.h”#include “halco/hicann-dls/vx/v3/event.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>

page md__jenkins_jenlib_workspaces_f9_doc_gerrit_documentation_brainscales2_ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM_x_grenade_include_grenade_vx_network_README

The logical_network namespace contains facilities to describe a Network of placed Populations of logical neurons, unplaced and unrouted Projections of connections corresponding to possibly multiple hardware synapse circuits in-between compartments of neurons in these populations, MADCRecording on a single atomic neuron, CADCRecording on a collection of atomic neurons as well as PlasticityRules on projections. In addition, ExternalSourcePopulations allow feeding-in external spike trains and BackgroundSourcePopulations describe the on-chip background generators.

The only difference to the network namespace therefore is the description of logical neurons and projections in-between their neurons’ compartments with possibly multiple hardware synapses per connection.

Given such a Network, an automated routing algorithm called via NetworkGraph build_network_graph(Network) solves the correspondence between logical neurons and atomic neurons as well as abstract synapses and network::Network hardware synapses. It therrefore selects which atomic neurons of the compartments to connect and the distribution of hardware synapses.

The NetworkGraph then contains the original Network as well as the routed network::Network. This can then be used further as described in the network namespace.

Spike-trains to the ExternalSourcePopulations in the network are supplied to an InputGenerator builder-pattern, which transforms the supplied spike-trains to the raw signal_flow::IODataMap format required by run().

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/execution/backend

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/common

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/compute

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/compute/detail

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/execution/detail

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/network/routing/detail

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/ppu/detail

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/signal_flow/detail

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/execution

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/execution/detail/generator

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/network

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/signal_flow/vertex/plasticity_rule

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/ppu

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/network/routing

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/signal_flow

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/signal_flow/vertex/transformation

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx/signal_flow/vertex

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/grenade/include/grenade/vx