These pages document the python code for the SpiNNakerGraphFrontEnd module which is part of the SpiNNaker Project.

This code depends on SpiNNUtils, SpiNNMachine, SpiNNMan, PACMAN, SpiNNFrontEndCommon (Combined_documentation).


The API for running SpiNNaker simulations based on a basic (non-neural) graph.

The general usage pattern for this API something like is:

import spinnaker_graph_front_end as gfe

# Uses information from your configuration file
# You might need to specify how many SpiNNaker boards to allocate

# Make the bits that do the computation
for each vertex to add:

# Connect them together so computations are coordinated
for each edge to add:

# Actually plan and run the simulation

# Get the results back; what this means can be complex
for each vertex:
    results += vertex.retrieve_relevant_results()

# Shut everything down
# Only your retrieved results really exist after this

# Analyse/render the results; totally application-specific!

It is possible to use GFE-style vertices in a neural graph (e.g., to simulate the external world). Talk to the SpiNNaker team for more details.

class spinnaker_graph_front_end.ReverseIpTagMultiCastSource(n_keys: int, label: str | None = None, max_atoms_per_core: int = 9223372036854775807, receive_port: int | None = None, receive_sdp_port: int = 1, receive_tag: IPTag | None = None, receive_rate: int = 10, virtual_key: int | None = None, prefix: int | None = None, prefix_type: EIEIOPrefix | None = None, check_keys: bool = False, send_buffer_times: ndarray | List[ndarray] | None = None, send_buffer_partition_id: str | None = None, reserve_reverse_ip_tag: bool = False, injection_partition_id: str | None = None, splitter: AbstractSplitterCommon | None = None)[source]

For full documentation see ReverseIpTagMultiCastSource.

  • n_keys (int) – The number of keys to be sent via this multicast source

  • label (str) – The label of this vertex

  • max_atoms_per_core (int) –

  • board_address (str or None) – The IP address of the board on which to place this vertex if receiving data, either buffered or live (by default, any board is chosen)

  • receive_port (int or None) – The port on the board that will listen for incoming event packets (default is to disable this feature; set a value to enable it)

  • receive_sdp_port (int) – The SDP port to listen on for incoming event packets (defaults to 1)

  • receive_tag (IPTag) – The IP tag to use for receiving live events (uses any by default)

  • receive_rate (float) – The estimated rate of packets that will be sent by this source

  • virtual_key (int) – The base multicast key to send received events with (assigned automatically by default)

  • prefix (int) – The prefix to “or” with generated multicast keys (default is no prefix)

  • prefix_type (EIEIOPrefix) – Whether the prefix should apply to the upper or lower half of the multicast keys (default is upper half)

  • check_keys (bool) – True if the keys of received events should be verified before sending (default False)

  • send_buffer_times (ndarray(ndarray(numpy.int32)) or list(ndarray(int32)) or None) – An array of arrays of times at which keys should be sent (one array for each key, default disabled)

  • send_buffer_partition_id (str or None) – The ID of the partition containing the edges down which the events are to be sent

  • reserve_reverse_ip_tag (bool) – Extra flag for input without a reserved port

  • injection_partition (str) – If not None, will enable injection and specify the partition to send injected keys with

  • splitter (AbstractSplitterCommon or None) – the splitter object needed for this vertex

spinnaker_graph_front_end.add_edge_instance(edge, partition_id)[source]

Add an edge to the unpartitioned graph.

  • edge (ApplicationEdge) – The edge to add.

  • partition_id (str) – The ID of the partition that the edge belongs to.

spinnaker_graph_front_end.add_socket_address(database_ack_port_num, database_notify_host, database_notify_port_num)[source]

Add a socket address for the notification protocol.

  • database_ack_port_num (int) – port number to send acknowledgement to

  • database_notify_host (str) – host IP to send notification to

  • database_notify_port_num (int) – port that the external device will be notified on.


Add an existing application vertex to the unpartitioned graph.


vertex_to_add (ApplicationVertex) – vertex instance to add to the graph


Get the buffer manager being used for loading/extracting buffers.

Return type:



Get the number of cores on this machine that are available to the simulation.

Return type:



Get whether the simulation has already run.

Return type:



Get whether a machine is allocated.

Return type:



Get the model of the attached/allocated machine.

Return type:



Get the placements.

Deprecated since version 7.0: No Longer supported! Use View iterate_placements instead

Instead of:




FecDataView can be imported from


Get information about how messages are routed on the machine.

Return type:


Run a simulation for a number of microseconds.


duration (int) – the number of microseconds the application code should run for

spinnaker_graph_front_end.setup(model_binary_module=None, model_binary_folder=None, database_socket_addresses=(), n_chips_required=None, n_boards_required=None, time_scale_factor=None, machine_time_step=None)[source]

Set up a graph, ready to have vertices and edges added to it, and the simulator engine that will execute the graph.


This must be called before the other functions in this API.

  • model_binary_module (ModuleType) – the Python module where the binary files (.aplx) can be found for the compiled C code that is being used in this application; mutually exclusive with the model_binary_folder.

  • model_binary_folder (str) – the folder where the binary files can be found for the c code that is being used in this application; mutually exclusive with the model_binary_module.

  • database_socket_addresses (Iterable(SocketAddress)) – set of SocketAddresses to be added for the database notification system. These are over and above the ones used by the LiveEventConnection

  • n_chips_required (int or None) – Deprecated! Use n_boards_required instead. Must be None if n_boards_required specified.

  • n_boards_required (int or None) – if you need to be allocated a machine (for spalloc) before building your graph, then fill this in with a general idea of the number of boards you need so that the spalloc system can allocate you a machine big enough for your needs.


ConfigurationException – if mutually exclusive options are given.


Do any necessary cleaning up before exiting. Unregisters the controller.


Indices and tables