spinnman package

Subpackages

Submodules

spinnman.board_test_configuration module

class spinnman.board_test_configuration.BoardTestConfiguration[source]

Bases: object

set_up_local_virtual_board()[source]
set_up_nonexistent_board()[source]
set_up_remote_board()[source]

spinnman.config_setup module

spinnman.config_setup.add_spinnman_cfg()[source]

Add the local configuration and all dependent configuration files.

spinnman.config_setup.unittest_setup()[source]

Resets the configurations so only the local default configuration is included.

Note

This file should only be called from SpiNNMan/unittests.

spinnman.constants module

spinnman.constants.BMP_ADC_MAX = 4096

The range of values the BMP’s 12-bit ADCs can measure.

spinnman.constants.BMP_MISSING_FAN = -1

Fan speed value returned when a fan is absent.

spinnman.constants.BMP_MISSING_TEMP = -32768

Temperature value returned when a probe is not connected.

spinnman.constants.BMP_POST_POWER_ON_SLEEP_TIME = 5.0

Time to sleep after powering on boards

spinnman.constants.BMP_POWER_ON_TIMEOUT = 10.0

Timeout for BMP power-on commands to reply.

spinnman.constants.BMP_TEMP_SCALE = 0.00390625

Multiplier to convert from temperature probe values to degrees Celsius.

spinnman.constants.BMP_TIMEOUT = 0.5

Timeout for other BMP commands to reply

spinnman.constants.BMP_V_SCALE_12 = 0.003662109375

Multiplier to convert from ADC value to volts for 12 V lines.

spinnman.constants.BMP_V_SCALE_2_5 = 0.0006103515625

Multiplier to convert from ADC value to volts for lines less than 2.5 V.

spinnman.constants.BMP_V_SCALE_3_3 = 0.00091552734375

Multiplier to convert from ADC value to volts for 3.3 V lines.

spinnman.constants.BOOT_RETRIES = 3

This is the number of retries during boot - this is different because otherwise boot takes too long (retrying on a non-booted machine will never work)

spinnman.constants.CPU_INFO_BYTES = 128

How many bytes the CPU info data takes up

spinnman.constants.CPU_INFO_OFFSET = 3842011136

The address of the start of the VCPU structure (copied from sark.h)

spinnman.constants.CPU_IOBUF_ADDRESS_OFFSET = 88

The address at which the iobuf address starts

spinnman.constants.CPU_USER_START_ADDRESS = 112

The address at which user0 register starts

class spinnman.constants.EIEIO_COMMAND_IDS(*args, **kwds)[source]

Bases: enum.Enum

A listing of what SpiNNaker specific EIEIO commands there are.

DATABASE = 1

Database handshake with external program; not routed via SpiNNaker

EVENT_PADDING = 2

Fill in buffer area with padding

EVENT_STOP = 3

End of all buffers, stop execution

HOST_DATA_READ = 9

Host confirming data being read form SpiNNaker memory

HOST_DATA_READ_ACK = 12

Host confirming request to read data received

HOST_SEND_SEQUENCED_DATA = 7

Buffers being sent from host to SpiNNaker

SPINNAKER_REQUEST_BUFFERS = 6

Spinnaker requesting new buffers for spike source population

SPINNAKER_REQUEST_READ_DATA = 8

Buffers available to be read from a buffered out vertex

START_RESUME_NOTIFICATION = 11

Command for notifying the external devices that the simulation has started

START_SENDING_REQUESTS = 5

Start complaining that there is SDRAM free space for buffers

STOP_PAUSE_NOTIFICATION = 10

Command for notifying the external devices that the simulation has stopped

STOP_SENDING_REQUESTS = 4

Stop complaining that there is SDRAM free space for buffers

class spinnman.constants.IPTAG_TIME_OUT_WAIT_TIMES(*args, **kwds)[source]

Bases: enum.Enum

The values used by the SCP IP tag time outs. These control how long to wait for any message request which requires a response, before raising an error.

The value is calculated via the following formula:

10ms * 2^(tag_timeout_value - 1)

TIMEOUT_10_ms = 1
TIMEOUT_1280_ms = 8
TIMEOUT_160_ms = 5
TIMEOUT_20_ms = 2
TIMEOUT_2560_ms = 9
TIMEOUT_320_ms = 6
TIMEOUT_40_ms = 3
TIMEOUT_640_ms = 7
TIMEOUT_80_ms = 4
spinnman.constants.MAX_TAG_ID = 7

Max user requested tag value

spinnman.constants.NO_ROUTER_DIAGNOSTIC_FILTERS = 16

Number of router diagnostic filters

spinnman.constants.N_RETRIES = 10

This is the default number of retries when using SCP

class spinnman.constants.READ_TYPES(*args, **kwds)[source]

Bases: enum.Enum

The types of read available from SARK. These values are used to tell SARK how to read the data in a time efficient manner.

BYTE = 0
HALF_WORD = 1
WORD = 2
spinnman.constants.ROUTER_DEFAULT_FILTERS_MAX_POSITION = 11

Point where default filters finish and user set-able ones are available

spinnman.constants.ROUTER_DIAGNOSTIC_FILTER_SIZE = 4

Size of a router diagnostic filter control register in bytes

spinnman.constants.ROUTER_FILTER_CONTROLS_OFFSET = 512

Offset for the router filter controls first register (one word each)

spinnman.constants.ROUTER_REGISTER_BASE_ADDRESS = 3774873600

The base address of a routers diagnostic filter controls

spinnman.constants.ROUTER_REGISTER_P2P_ADDRESS = 3774939136

The base address of a routers p2p routing table

class spinnman.constants.ROUTER_REGISTER_REGISTERS(*args, **kwds)[source]

Bases: enum.Enum

The indices to the router registers.

DUMP_FR = 11
DUMP_MC = 8
DUMP_NN = 10
DUMP_PP = 9
EXT_FR = 7
EXT_MC = 1
EXT_NN = 5
EXT_PP = 3
LOC_FR = 6
LOC_MC = 0
LOC_NN = 4
LOC_PP = 2
USER_0 = 12
USER_1 = 13
USER_2 = 14
USER_3 = 15
spinnman.constants.SCP_SCAMP_PORT = 17893

The default port of the connection

spinnman.constants.SCP_TIMEOUT = 1.0

This is the default timeout when using SCP

spinnman.constants.SYSTEM_VARIABLE_BASE_ADDRESS = 4110450432

The base address of the system variable structure in System ram

spinnman.constants.SYSTEM_VARIABLE_BYTES = 256

The size of the system variable structure in bytes

spinnman.constants.UDP_BOOT_CONNECTION_DEFAULT_PORT = 54321

The default port of the connection

spinnman.constants.UDP_MESSAGE_MAX_SIZE = 256

The max size a UDP packet can be, excluding headers

spinnman.constants.address_length_dtype = {(0, 0): <READ_TYPES.WORD: 2>, (0, 1): <READ_TYPES.BYTE: 0>, (0, 2): <READ_TYPES.HALF_WORD: 1>, (0, 3): <READ_TYPES.BYTE: 0>, (1, 0): <READ_TYPES.BYTE: 0>, (1, 1): <READ_TYPES.BYTE: 0>, (1, 2): <READ_TYPES.BYTE: 0>, (1, 3): <READ_TYPES.BYTE: 0>, (2, 0): <READ_TYPES.HALF_WORD: 1>, (2, 1): <READ_TYPES.BYTE: 0>, (2, 2): <READ_TYPES.HALF_WORD: 1>, (2, 3): <READ_TYPES.BYTE: 0>, (3, 0): <READ_TYPES.BYTE: 0>, (3, 1): <READ_TYPES.BYTE: 0>, (3, 2): <READ_TYPES.BYTE: 0>, (3, 3): <READ_TYPES.BYTE: 0>}

This is a mapping between read address in the mapping between word byte position, the number of bytes you wish to read, and the type of time efficient way to read said amount of bytes via SARK

spinnman.exceptions module

exception spinnman.exceptions.SpallocException[source]

Bases: spinnman.exceptions.SpinnmanException

Raised when there is a problem with the Spalloc session or job.

exception spinnman.exceptions.SpiNNManCoresNotInStateException(timeout, expected_states, failed_core_states)[source]

Bases: spinnman.exceptions.SpinnmanTimeoutException

Cores failed to reach a given state within a timeout.

Parameters:
failed_core_states()[source]
Return type:CPUInfos
exception spinnman.exceptions.SpinnmanEIEIOPacketParsingException(parsing_format, packet)[source]

Bases: spinnman.exceptions.SpinnmanException

Unable to complete the parsing of the EIEIO packet received. The routine used is invalid or the content of the packet is invalid.

Parameters:
  • parsing_format (str) –
  • packet (bytes) –
packet
Return type:bytes
exception spinnman.exceptions.SpinnmanEOFException[source]

Bases: spinnman.exceptions.SpinnmanIOException

An exception that we’re trying to do I/O on a closed socket. That isn’t going to work!

exception spinnman.exceptions.SpinnmanException[source]

Bases: Exception

Superclass of exceptions that occur when dealing with communication with SpiNNaker.

exception spinnman.exceptions.SpinnmanGenericProcessException(exception, tb, x, y, p, phys_p, tb2=None)[source]

Bases: spinnman.exceptions.SpinnmanException

Encapsulates exceptions from processes which communicate with some core/chip.

Parameters:
exception
Return type:Exception
exception spinnman.exceptions.SpinnmanGroupedProcessException(error_requests, exceptions, tracebacks, connections)[source]

Bases: spinnman.exceptions.SpinnmanException

Encapsulates exceptions from processes which communicate with a collection of cores/chips.

exception spinnman.exceptions.SpinnmanIOException(problem)[source]

Bases: spinnman.exceptions.SpinnmanException

An exception that something went wrong with the underlying IO.

Parameters:problem (str) – The problem with the IO
problem

The problem with IO.

Return type:str
exception spinnman.exceptions.SpinnmanInvalidPacketException(packet_type, problem)[source]

Bases: spinnman.exceptions.SpinnmanException

An exception that indicates that a packet was not in the expected format.

Parameters:
  • packet_type (str) – The type of packet expected
  • problem (str) – The problem with the packet
packet_type

The packet type.

Return type:str
problem

The problem with the packet.

Return type:str
exception spinnman.exceptions.SpinnmanInvalidParameterException(parameter, value, problem)[source]

Bases: spinnman.exceptions.SpinnmanException

An exception that indicates that the value of one of the parameters passed was invalid.

Parameters:
  • parameter (str) – The name of the parameter that is invalid
  • value (str) – The value of the parameter that is invalid
  • problem (str) – The problem with the parameter
parameter

The parameter with an invalid value.

Return type:str
problem

The problem with the parameter value.

Return type:str
value

The value that is invalid.

exception spinnman.exceptions.SpinnmanInvalidParameterTypeException(parameter, param_type, problem)[source]

Bases: spinnman.exceptions.SpinnmanException

An exception that indicates that the type of one of the parameters passed was invalid.

Parameters:
  • parameter (str) – The name of the parameter that is invalid
  • param_type (str) – The type of the parameter that is invalid
  • problem (str) – The problem with the parameter
parameter

The parameter with an invalid value.

Return type:str
problem

The problem with the parameter value.

Return type:str
type

The value that is invalid.

exception spinnman.exceptions.SpinnmanTimeoutException(operation, timeout, msg=None)[source]

Bases: spinnman.exceptions.SpinnmanException

An exception that indicates that a timeout occurred before an operation could finish.

Parameters:
  • operation (str) – The operation being performed
  • timeout (float) – The timeout value in seconds
operation

The operation that was performed.

Return type:str
timeout

The timeout value in seconds.

Return type:float
exception spinnman.exceptions.SpinnmanUnexpectedResponseCodeException(operation, command, response)[source]

Bases: spinnman.exceptions.SpinnmanException

Indicate that a response code returned from the board was unexpected for the current operation.

Parameters:
  • operation (str) – The operation being performed
  • command (str) – The command being executed
  • response (str) – The response received in error
command

The command being executed.

operation

The operation being performed.

Return type:str
response

The unexpected response.

Return type:str
exception spinnman.exceptions.SpinnmanUnsupportedOperationException(operation)[source]

Bases: spinnman.exceptions.SpinnmanException

An exception that indicates that the given operation is not supported.

Parameters:operation (str) – The operation being requested
operation

The unsupported operation requested.

Return type:str

spinnman.get_cores_in_run_state module

This is a script used to check the state of a SpiNNaker machine.

spinnman.get_cores_in_run_state.get_cores_in_run_state(txrx, app_id, print_all_chips)[source]
Parameters:
spinnman.get_cores_in_run_state.main(args)[source]

Runs the script.

spinnman.transceiver module

class spinnman.transceiver.Transceiver(version, connections=None)[source]

Bases: spinn_utilities.abstract_context_manager.AbstractContextManager

An encapsulation of various communications with the SpiNNaker board.

The methods of this class are designed to be thread-safe (provided they do not access a BMP, as access to those is never thread-safe); thus you can make multiple calls to the same (or different) methods from multiple threads and expect each call to work as if it had been called sequentially, although the order of returns is not guaranteed.

Note

With multiple connections to the board, using multiple threads in this way may result in an increase in the overall speed of operation, since the multiple calls may be made separately over the set of given connections.

Parameters:
  • version (int) – The version of the board being connected to
  • connections (list(Connection)) – An iterable of connections to the board. If not specified, no communication will be possible until connections are found.
Raises:
add_scamp_connections(connections)[source]

Check connections to the board and store these for future use.

Note

An exception will be thrown if no initial connections can be found to the board.

Parameters:

connections (dict((int,int),str)) – Dict of (x,`y`) to IP address
Raises:
clear_ip_tag(tag, board_address=None)[source]

Clear the setting of an IP tag.

Parameters:
  • tag (int) – The tag ID
  • board_address (str) – Board address where the tag should be cleared. If not specified, all AbstractSCPConnection connections will send the message to clear the tag
Raises:
clear_multicast_routes(x, y)[source]

Remove all the multicast routes on a chip.

Parameters:
  • x (int) – The x-coordinate of the chip on which to clear the routes
  • y (int) – The y-coordinate of the chip on which to clear the routes
Raises:
clear_router_diagnostic_counters(x, y)[source]

Clear router diagnostic information on a chip.

Parameters:
  • x (int) – The x-coordinate of the chip
  • y (int) – The y-coordinate of the chip
Raises:
close()[source]

Close the transceiver and any threads that are running.

control_sync(do_sync)[source]

Control the synchronisation of the chips.

Parameters:do_sync (bool) – Whether to synchronise or not
discover_scamp_connections()[source]

Find connections to the board and store these for future use.

Note

An exception will be thrown if no initial connections can be found to the board.

Raises:
ensure_board_is_ready(n_retries=5, extra_boot_values=None)[source]

Ensure that the board is ready to interact with this version of the transceiver. Boots the board if not already booted and verifies that the version of SCAMP running is compatible with this transceiver.

Parameters:
  • n_retries (int) – The number of times to retry booting
  • extra_boot_values (dict(SystemVariableDefinition,object)) – Any additional or overwrite values to set during boot. This should only be used for values which are not standard based on the board version.
Returns:

The version identifier
Return type:

VersionInfo
Raises:

SpinnmanIOException –

  • If there is a problem booting the board
  • If the version of software on the board is not compatible with this transceiver
execute_flood(core_subsets, executable, app_id, n_bytes=None, wait=False, is_filename=False)[source]

Start an executable running on multiple places on the board. This will be optimised based on the selected cores, but it may still require a number of communications with the board to execute.

Parameters:
  • core_subsets (CoreSubsets) – Which cores on which chips to start the executable
  • executable (RawIOBase or bytes or bytearray or str) –

    The data that is to be executed. Should be one of the following:

    • An instance of RawIOBase
    • A bytearray
    • A filename of an executable (in which case is_filename must be set to True)
  • app_id (int) – The ID of the application with which to associate the executable
  • n_bytes (int) –

    The size of the executable data in bytes. If not specified:

    • If executable is an RawIOBase, an error is raised
    • If executable is a bytearray, the length of the bytearray will be used
    • If executable is an int, 4 will be used
    • If executable is a str, the length of the file will be used
  • wait (bool) – True if the processors should enter a “wait” state on loading
  • is_filename (bool) – True if the data is a filename
Raises:
  • SpinnmanIOException –
    • If there is an error communicating with the board
    • If there is an error reading the executable
  • SpinnmanInvalidPacketException – If a packet is received that is not in the valid format
  • SpinnmanInvalidParameterException –
    • If one of the specified cores is not valid
    • If app_id is an invalid application ID
    • If a packet is received that has invalid parameters
    • If executable is an RawIOBase but n_bytes is not specified
    • If executable is an int and n_bytes is more than 4
    • If n_bytes is less than 0
  • SpinnmanUnexpectedResponseCodeException – If a response indicates an error during the exchange
get_clock_drift(x, y)[source]

Get the clock drift :param int x: The x-coordinate of the chip to get drift for :param int y: The y-coordinate of the chip to get drift for

get_core_state_count(app_id, state)[source]

Get a count of the number of cores which have a given state.

Parameters:
  • app_id (int) – The ID of the application from which to get the count.
  • state (CPUState) – The state count to get
Returns:

A count of the cores with the given status
Return type:

int
Raises:
get_cpu_information_from_core(x, y, p)[source]

Get information about a specific processor on the board.

Parameters:
  • x (int) – The x-coordinate of the chip containing the processor
  • y (int) – The y-coordinate of the chip containing the processor
  • p (int) – The ID of the processor to get the information about
Returns:

The CPU information for the selected core
Return type:

CPUInfo
Raises:
get_cpu_infos(core_subsets=None, states=None, include=True)[source]

Get information about the processors on the board.

Parameters:
  • core_subsets (CoreSubsets) – A set of chips and cores from which to get the information. If not specified, the information from all of the cores on all of the chips on the board are obtained.
  • states (None, CPUState or collection(CPUState)) – The state or states to filter on (if any)
  • include (bool) – If True includes only infos in the requested state(s). If False includes only infos NOT in the requested state(s). Ignored if states is None.
Returns:

The CPU information for the selected cores and States, or all cores/states if core_subsets/states is not specified
Return type:

CPUInfos
Raises:
get_iobuf(core_subsets=None)[source]

Get the contents of the IOBUF buffer for a number of processors.

Parameters:

core_subsets (CoreSubsets) – A set of chips and cores from which to get the buffers. If not specified, the buffers from all of the cores on all of the chips on the board are obtained.
Returns:

An iterable of the buffers, which may not be in the order of core_subsets
Return type:

iterable(IOBuffer)
Raises:
get_machine_details()[source]

Get the details of the machine made up of chips on a board and how they are connected to each other.

Returns:

A machine description
Return type:

Machine
Raises:
get_multicast_routes(x, y, app_id=None)[source]

Get the current multicast routes set up on a chip.

Parameters:
  • x (int) – The x-coordinate of the chip from which to get the routes
  • y (int) – The y-coordinate of the chip from which to get the routes
  • app_id (int) – The ID of the application to filter the routes for. If not specified, will return all routes
Returns:

An iterable of multicast routes
Return type:

list(MulticastRoutingEntry)
Raises:
get_router_diagnostics(x, y)[source]

Get router diagnostic information from a chip.

Parameters:
  • x (int) – The x-coordinate of the chip from which to get the information
  • y (int) – The y-coordinate of the chip from which to get the information
Returns:

The router diagnostic information
Return type:

RouterDiagnostics
Raises:
get_tags(connection=None)[source]

Get the current set of tags that have been set on the board.

Parameters:

connection (AbstractSCPConnection) – Connection from which the tags should be received. If not specified, all AbstractSCPConnection connections will be queried and the response will be combined.
Returns:

An iterable of tags
Return type:

iterable(AbstractTag)
Raises:
load_fixed_route(x, y, fixed_route, app_id)[source]

Loads a fixed route routing table entry onto a chip’s router.

Parameters:
  • x (int) – The x-coordinate of the chip onto which to load the routes
  • y (int) – The y-coordinate of the chip onto which to load the routes
  • fixed_route (FixedRouteEntry) – the route for the fixed route entry on this chip
  • app_id (int) – The ID of the application with which to associate the routes. If not specified, defaults to 0.
Raises:
load_multicast_routes(x, y, routes, app_id)[source]

Load a set of multicast routes on to a chip.

Parameters:
  • x (int) – The x-coordinate of the chip onto which to load the routes
  • y (int) – The y-coordinate of the chip onto which to load the routes
  • routes (iterable(MulticastRoutingEntry)) – An iterable of multicast routes to load
  • app_id (int) – The ID of the application with which to associate the routes. If not specified, defaults to 0.
Raises:
malloc_sdram(x, y, size, app_id, tag=None)[source]

Allocates a chunk of SDRAM on a chip on the machine.

Parameters:
  • x (int) – The x-coordinate of the chip onto which to ask for memory
  • y (int) – The y-coordinate of the chip onto which to ask for memory
  • size (int) – the amount of memory to allocate in bytes
  • app_id (int) – The ID of the application with which to associate the routes. If not specified, defaults to 0.
  • tag (int) – the tag for the SDRAM, a 8-bit (chip-wide) tag that can be looked up by a SpiNNaker application to discover the address of the allocated block. If 0 then no tag is applied.
Returns:

the base address of the allocated memory
Return type:

int
power_off(boards=0)[source]

Power off a set of boards in the machine.

Parameters:boards (int) – The board or boards to power off
power_off_machine()[source]

Power off the whole machine.

:rtype bool :return success or failure to power off the machine

power_on(boards=0)[source]

Power on a set of boards in the machine.

Parameters:boards (int) – The board or boards to power on
read_bmp_version(board)[source]

Read the BMP version.

Parameters:board (int) – which board to request the data from
Returns:the sver from the BMP
read_fixed_route(x, y, app_id)[source]

Reads a fixed route routing table entry from a chip’s router.

Parameters:
  • x (int) – The x-coordinate of the chip onto which to load the routes
  • y (int) – The y-coordinate of the chip onto which to load the routes
  • app_id (int) – The ID of the application with which to associate the routes. If not specified, defaults to 0.
Returns:

the route as a fixed route entry
read_fpga_register(fpga_num, register, board=0)[source]

Read a register on a FPGA of a board. The meaning of the register’s contents will depend on the FPGA’s configuration.

Parameters:
  • fpga_num (int) – FPGA number (0, 1 or 2) to communicate with.
  • register (int) – Register address to read to (will be rounded down to the nearest 32-bit word boundary).
  • board (int) – which board to request the FPGA register from
Returns:

the register data
Return type:

int
read_memory(x, y, base_address, length, cpu=0)[source]

Read some areas of memory (usually SDRAM) from the board.

Parameters:
  • x (int) – The x-coordinate of the chip where the memory is to be read from
  • y (int) – The y-coordinate of the chip where the memory is to be read from
  • base_address (int) – The address in SDRAM where the region of memory to be read starts
  • length (int) – The length of the data to be read in bytes
  • cpu (int) – the core ID used to read the memory of; should usually be 0 when reading from SDRAM, but may be other values when reading from DTCM.
Returns:

A bytearray of data read
Return type:

bytes
Raises:
read_user(x, y, p, user)[source]

Get the contents of the this user register for the given processor.

Note

Conventionally, user_0 usually holds the address of the table of memory regions.

Parameters:
  • x (int) – X coordinate of the chip
  • y (int) – Y coordinate of the chip
  • p (int) – Virtual processor identifier on the chip
  • user (int) – The user number to read data for
Return type:

int
Raises:
read_word(x, y, base_address, cpu=0)[source]

Read a word (usually of SDRAM) from the board.

Parameters:
  • x (int) – The x-coordinate of the chip where the word is to be read from
  • y (int) – The y-coordinate of the chip where the word is to be read from
  • base_address (int) – The address (usually in SDRAM) where the word to be read starts
  • cpu (int) – the core ID used to read the word; should usually be 0 when reading from SDRAM, but may be other values when reading from DTCM.
Returns:

The unsigned integer value at base_address
Return type:

int
Raises:
send_sdp_message(message, connection=None)[source]

Sends an SDP message using one of the connections.

Parameters:
send_signal(app_id, signal)[source]

Send a signal to an application.

Parameters:
  • app_id (int) – The ID of the application to send to
  • signal (Signal) – The signal to send
Raises:
set_ip_tag(ip_tag, use_sender=False)[source]

Set up an IP tag.

Parameters:
  • ip_tag (IPTag) –

    The tag to set up.

    Note

    board_address can be None, in which case, the tag will be assigned to all boards.

  • use_sender (bool) – Optionally use the sender host and port instead of the given host and port in the tag
Raises:
set_reverse_ip_tag(reverse_ip_tag)[source]

Set up a reverse IP tag.

Parameters:

reverse_ip_tag (ReverseIPTag) –

The reverse tag to set up.

Note

The board_address field can be None, in which case, the tag will be assigned to all boards.
Raises:
set_router_diagnostic_filter(x, y, position, diagnostic_filter)[source]

Sets a router diagnostic filter in a router.

Parameters:
  • x (int) – The X address of the router in which this filter is being set.
  • y (int) – The Y address of the router in which this filter is being set.
  • position (int) – The position in the list of filters where this filter is to be added.
  • diagnostic_filter (DiagnosticFilter) –

    The diagnostic filter being set in the placed, between 0 and 15.

    Note

    Positions 0 to 11 are used by the default filters, and setting these positions will result in a warning.
Raises:
stop_application(app_id)[source]

Sends a stop request for an app_id.

Parameters:

app_id (int) – The ID of the application to send to
Raises:
update_provenance_and_exit(x, y, p)[source]

Sends a command to update prevenance and exit

Parameters:
  • x (int) – The x-coordinate of the core
  • y (int) – The y-coordinate of the core
  • p (int) – The processor on the core
wait_for_cores_to_be_in_state(all_core_subsets, app_id, cpu_states, timeout=None, time_between_polls=0.1, error_states=frozenset({<CPUState.RUN_TIME_EXCEPTION: 2>, <CPUState.WATCHDOG: 3>}), counts_between_full_check=100, progress_bar=None)[source]

Waits for the specified cores running the given application to be in some target state or states. Handles failures.

Parameters:
  • all_core_subsets (CoreSubsets) – the cores to check are in a given sync state
  • app_id (int) – the application ID that being used by the simulation
  • cpu_states (set(CPUState)) – The expected states once the applications are ready; success is when each application is in one of these states
  • timeout (float) – The amount of time to wait in seconds for the cores to reach one of the states
  • time_between_polls (float) – Time between checking the state
  • error_states (set(CPUState)) – Set of states that the application can be in that indicate an error, and so should raise an exception
  • counts_between_full_check (int) – The number of times to use the count signal before instead using the full CPU state check
  • progress_bar (ProgressBar or None) – Possible progress bar to update.
Raises:

SpinnmanTimeoutException – If a timeout is specified and exceeded.
write_fpga_register(fpga_num, register, value, board=0)[source]

Write a register on a FPGA of a board. The meaning of setting the register’s contents will depend on the FPGA’s configuration.

Parameters:
  • fpga_num (int) – FPGA number (0, 1 or 2) to communicate with.
  • register (int) – Register address to read to (will be rounded down to the nearest 32-bit word boundary).
  • value (int) – the value to write into the FPGA register
  • board (int) – which board to write the FPGA register to
write_memory(x, y, base_address, data, n_bytes=None, offset=0, cpu=0, is_filename=False, get_sum=False)[source]

Write to the SDRAM on the board.

Parameters:
  • x (int) – The x-coordinate of the chip where the memory is to be written to
  • y (int) – The y-coordinate of the chip where the memory is to be written to
  • base_address (int) – The address in SDRAM where the region of memory is to be written
  • data (RawIOBase or bytes or bytearray or int or str) –

    The data to write. Should be one of the following:

    • An instance of RawIOBase
    • A bytearray/bytes
    • A single integer - will be written in little-endian byte order
    • A filename of a data file (in which case is_filename must be set to True)
  • n_bytes (int) –

    The amount of data to be written in bytes. If not specified:

    • If data is an RawIOBase, an error is raised
    • If data is a bytearray, the length of the bytearray will be used
    • If data is an int, 4 will be used
    • If data is a str, the length of the file will be used
  • offset (int) – The offset from which the valid data begins
  • cpu (int) – The optional CPU to write to
  • is_filename (bool) – True if data is a filename
  • get_sum (bool) – whether to return a checksum or 0
Returns:

The number of bytes written, the checksum (0 if get_sum=False)
Return type:

int, int
Raises:
write_user(x, y, p, user, value)[source]

Write to the this user register for the given processor.

Note

Conventionally, user_0 usually holds the address of the table of memory regions.

Parameters:
  • x (int) – X coordinate of the chip
  • y (int) – Y coordinate of the chip
  • p (int) – Virtual processor identifier on the chip
  • user (int) – The user number of write data for
  • value (int) – The value to write
Raises:
spinnman.transceiver.create_transceiver_from_hostname(hostname, version, bmp_connection_data=None, number_of_boards=None, auto_detect_bmp=False)[source]

Create a Transceiver by creating a UDPConnection to the given hostname on port 17893 (the default SCAMP port), and a BootConnection on port 54321 (the default boot port), optionally discovering any additional links using the UDPConnection, and then returning the transceiver created with the conjunction of the created UDPConnection and the discovered connections.

Parameters:
  • hostname (str or None) – The hostname or IP address of the board or None if only the BMP connections are of interest
  • number_of_boards (int or None) – a number of boards expected to be supported, or None, which defaults to a single board
  • version (int) – the type of SpiNNaker board used within the SpiNNaker machine being used. If a Spinn-5 board, then the version will be 5, Spinn-3 would equal 3 and so on.
  • bmp_connection_data (BMPConnectionData) – the details of the BMP connections used to boot multi-board systems
  • auto_detect_bmp (bool) – True if the BMP of version 4 or 5 boards should be automatically determined from the board IP address
  • scamp_connections – the list of connections used for SCAMP communications
Returns:

The created transceiver
Return type:

Transceiver
Raises:

Module contents

Used to communicate with a SpiNNaker Board. The main part of this package is the Transceiver class. This can be used to send and receive packets in various SpiNNaker formats, depending on what connections are available.

Functional Requirements

  1. Connect to and communicate with a machine using a number of different connections.
  2. Boot a machine with the expected version of the software.
    • If the machine is already booted but the version is not the version expected, an exception will be thrown.
  3. Check the version of the software which the machine is booted with.
  4. Query the state of the machine to determine:
    • What the current state of the machine is in terms of the chips and cores available, the SDRAM available on the chips and which links are available between which chips.
    • What external links to the host exist (and separately add the discovered links to the set of links used to communicate with the machine).
    • What is running on the machine and where, and what the current status of those processes are.
    • How many cores are in a given state.
    • What is in the IOBUF buffers.
    • What the current routing entries for a given router are.
    • What the routing status counter values are.
  5. Load application binaries on to the machine, either to individual cores or via a “flood-fill” mechanism to multiple cores simultaneously (which may be a subset of the cores on a subset of the chips).
  6. Write data to SDRAM, either on an individual chip, or via a “flood-fill” mechanism to multiple chips simultaneously.
  7. Send a signal to an application.
  8. Read data from SDRAM on an individual chip.
  9. Send and receive SpiNNaker packets where the connections allow this.
    • If no connection supports this packet type, an exception is thrown.
    • The user should be able to select which connection is used. Selection of a connection which does not support the traffic type will also result in an exception.
  10. Send and receive SCP and SDP packets where the connections allow this.
    • If no connection supports the packet type, an exception is thrown.
    • The user should be able to select which connection is used. Selection of a connection which does not support the traffic type will also result in an exception.
  11. It should be possible to call any of the functions simultaneously, including the same function more than once.
    • Where possible, multiple connections should be used to overlap calls.
    • The functions should not return until they have confirmed that any messages sent have been received, and any responses have been received.
    • Functions should not respond with the result of a different function.
    • Functions can further sub-divide the call into a number of separate calls that can be divided across the available connections, so long as the other requirements are met.
  12. More than one machine can be connected to the same host.
    • Once the subset of connections has been worked out for each machine, the operation of these machines should be independent.

Use Cases

  • Connecting is done by using create_transceiver_from_hostname().
  • boot_board() and get_scamp_version() are used to ensure that the board is booted correctly before starting a simulation.
  • get_machine_details() is used to get a representation of the current state of the machine, which is used to decide where executables are to be run on the board for a particular simulation, where any external peripherals are connected, and how messages between the executables and/or the external peripherals are to be routed.
  • write_memory() and execute() are used to write parameters and execute executables on the board
  • send_signal() is used to send a signal which starts, stops or pauses a simulation.
  • get_core_state_count() is used to determine if a simulation is complete or has gone into an error state.
  • get_iobuf(), get_cpu_infos() and get_router_diagnostics() are used to diagnose a problem with a simulation.
  • read_memory() is used to read some statistics recorded in SDRAM after a simulation.