spinn_machine package¶
Submodules¶
spinn_machine.exceptions module¶
-
exception
spinn_machine.exceptions.
SpinnMachineAlreadyExistsException
(item, value)[source]¶ Bases:
spinn_machine.exceptions.SpinnMachineException
Indicates that something already exists of which there can only be one
Parameters: - item (str) – The item of which there is already one of
- value (str) – The value of the item
-
item
¶ The item of which there is already one
-
value
¶ The value of the item
-
exception
spinn_machine.exceptions.
SpinnMachineException
[source]¶ Bases:
Exception
A generic exception which all other exceptions extend
-
exception
spinn_machine.exceptions.
SpinnMachineInvalidParameterException
(parameter, value, problem)[source]¶ Bases:
spinn_machine.exceptions.SpinnMachineException
Indicates that there is a problem with a parameter value
Parameters: - parameter (str) – The name of the parameter that has an invalid value
- value (str) – The value of the parameter that is invalid
- problem (str) – The reason for the exception
-
parameter
¶ The name of the parameter
-
problem
¶ The problem with the setting of the parameter
-
value
¶ The value of the parameter
spinn_machine.json_machine module¶
-
spinn_machine.json_machine.
machine_from_json
(j_machine)[source]¶ Parameters: j_machine (dict in format returned by json.load or a str representing a path to the JSON file) – JSON description of the machine Return type: Machine
Module contents¶
An abstraction of a SpiNNaker Machine. The main functionality isprovided by spinn_machine.Machine
.
Functional Requirements¶
Create a machine which represents the current state of a machine, in terms of the available chips, cores on the chips, SDRAM available, routable links between chips and available routing entries.
Create a machine which represents an abstract ideal machine.
- There can only be one chip in the machine with given x, y coordinates
- There can only be one processor in each chip with a given processor ID
- There can only be one link in the router of each chip with a given ID
Add a chip to a given machine to represent an external device.
- A chip with the same x, y coordinates must not already exist in the machine
Add a link to a router of a given chip to represent a connection to an external device.
- A link with the given ID must not already exist in the chip
Create a representation of a multicast routing entry to be shared between modules that deal with routing entries.
Use Cases¶
Machine
is returned as a representation of the current state of a machine.virtual_machine()
is used to make an outline of a machine on which a simulation will be run, e.g., for placement of executables and/or finding routes between placed executables.Machine
is extended to add a virtualChip
on the machine representing an external peripheral connected to the machine directly via a link from a chip, so that routes can be directed to and from the external peripheral.MulticastRoutingEntry
is returned in a list of entries, which indicate the current set of routing entries within a multicast routing table on a chip on the machine.MulticastRoutingEntry
is sent in a list of routing entries to set up routing on a chip on the machine.
-
class
spinn_machine.
Chip
(x, y, n_processors, router, sdram, nearest_ethernet_x, nearest_ethernet_y, ip_address=None, virtual=False, tag_ids=None, down_cores=None)[source]¶ Bases:
object
Represents a SpiNNaker chip with a number of cores, an amount of SDRAM shared between the cores, and a router. The chip is iterable over the processors, yielding (processor_id, processor) where:
- processor_id is the ID of a processor
- processor is the processor with processor_id
Parameters: - x (int) – the x-coordinate of the chip’s position in the two-dimensional grid of chips
- y (int) – the y-coordinate of the chip’s position in the two-dimensional grid of chips
- n_processors (int) – the number of processors including monitor processors.
- router (
Router
) – a router for the chip - sdram (
SDRAM
) – an SDRAM for the chip - ip_address (str) – the IP address of the chip or None if no Ethernet attached
- virtual (bool) – boolean which defines if this chip is a virtual one
- tag_ids (iterable(int) or None) – IDs to identify the chip for SDP can be empty to define no tags or None to allocate tag automatically based on if there is an ip_address
- nearest_ethernet_x (int or None) – the nearest Ethernet x coordinate
- nearest_ethernet_y (int or None) – the nearest Ethernet y coordinate
- down_cores (collection of int) – Ids of cores that are down for this Chip
Raises: spinn_machine.exceptions.SpinnMachineAlreadyExistsException – If processors contains any two processors with the same processor_id
-
get_first_none_monitor_processor
()[source]¶ Get the first processor in the list which is not a monitor core
Returns: a processor, if any non-monitor processors exist Return type: Processor or None
-
get_processor_with_id
(processor_id)[source]¶ Return the processor with the specified ID or None if the processor does not exist.
Parameters: processor_id (int) – the ID of the processor to return Returns: the processor with the specified ID, or None if no such processor Return type: Processor Raises: None – does not raise any known exceptions
-
ip_address
¶ The IP address of the chip
Returns: IP address of the chip, or None if there is no Ethernet connected to the chip Return type: str Raises: None – does not raise any known exceptions
-
is_processor_with_id
(processor_id)[source]¶ Determines if a processor with the given ID exists in the chip. Also implemented as __contains__(processor_id)
Parameters: processor_id (int) – the processor ID to check for Returns: Whether the processor with the given ID exists Return type: bool Raises: None – does not raise any known exceptions
-
n_processors
¶ The total number of processors
Return type: int
-
n_user_processors
¶ The total number of processors that are not monitors
Return type: int
-
nearest_ethernet_x
¶ The x coordinate of the nearest Ethernet chip
Returns: the x coordinate of the nearest Ethernet chip Return type: int Raises: None – does not raise any known exceptions
-
nearest_ethernet_y
¶ The y coordinate of the nearest Ethernet chip
Returns: the y coordinate of the nearest Ethernet chip Return type: int Raises: None – does not raise any known exceptions
-
processors
¶ An iterable of available processors
Return type: iterable(Processor) Raises: None – does not raise any known exceptions
-
router
¶ The router object associated with the chip
Returns: router associated with the chip Return type: Router Raises: None – does not raise any known exceptions
-
sdram
¶ The SDRAM associated with the chip
Returns: SDRAM associated with the chip Return type: SDRAM Raises: None – does not raise any known exceptions
-
tag_ids
¶ The tag IDs supported by this chip
Returns: the set of IDs. Return type: iterable(int) Raises: None – this method does not raise any exception
-
virtual
¶ Boolean which defines if the chip is virtual or not
Returns: if the chip is virtual Return type: boolean Raises: None – this method does not raise any known exceptions
-
x
¶ The x-coordinate of the chip in the two-dimensional grid of chips
Returns: the x-coordinate of the chip Return type: int Raises: None – does not raise any known exceptions
-
y
¶ The y-coordinate of the chip in the two-dimensional grid of chips
Returns: the y-coordinate of the chip Return type: int Raises: None – does not raise any known exceptions
-
class
spinn_machine.
CoreSubset
(x, y, processor_ids)[source]¶ Bases:
object
Represents a subset of the cores on a SpiNNaker chip.
Parameters: - x (int) – The x-coordinate of the chip
- y (int) – The y-coordinate of the chip
- processor_ids (iterable(int)) – The processor IDs on the chip
-
add_processor
(processor_id)[source]¶ Adds a processor ID to this subset
Parameters: processor_id (int) – A processor ID Returns: Nothing is returned Return type: None
-
intersect
(other)[source]¶ Returns a new CoreSubset which is an intersect of this and the other.
Parameters: other (CoreSubset) – A second CoreSubset with possibly overlapping cores Returns: A new CoreSubset with any overlap Return type: CoreSubset
-
processor_ids
¶ The subset of processor IDs on the chip
Returns: An iterable of processor IDs Return type: iterable(int)
-
x
¶ The x-coordinate of the chip
Returns: The x-coordinate Return type: int
-
y
¶ The y-coordinate of the chip
Returns: The y-coordinate Return type: int
-
class
spinn_machine.
CoreSubsets
(core_subsets=None)[source]¶ Bases:
object
Represents a group of CoreSubsets, with a maximum of one per SpiNNaker chip.
Parameters: core_subsets (iterable(CoreSubset)) – The cores for each desired chip -
add_core_subset
(core_subset)[source]¶ Add a core subset to the set
Parameters: core_subset (CoreSubset) – The core subset to add Return type: None
-
add_core_subsets
(core_subsets)[source]¶ Merges a core subsets into this one.
Parameters: core_subsets – the core subsets to add Return type: None
-
add_processor
(x, y, processor_id)[source]¶ Add a processor on a given chip to the set.
Parameters: - x (int) – The x-coordinate of the chip
- y (int) – The y-coordinate of the chip
- processor_id (int) – A processor ID
Return type: None
-
core_subsets
¶ The one-per-chip subsets.
Returns: Iterable of core subsets Return type: iterable(CoreSubset)
-
get_core_subset_for_chip
(x, y)[source]¶ Get the core subset for a chip.
Parameters: - x (int) – The x-coordinate of a chip
- y (int) – The y-coordinate of a chip
Returns: The core subset of a chip, which will be empty if not added
Return type:
-
intersect
(other)[source]¶ Returns a new CoreSubsets which is an intersect of this and the other.
Parameters: other (CoreSubsets) – A second CoreSubsets with possibly overlapping cores Returns: A new CoreSubsets with any overlap Return type: CoreSubsets
-
is_chip
(x, y)[source]¶ Determine if the chip with coordinates (x, y) is in the subset
Parameters: - x (int) – The x-coordinate of a chip
- y (int) – The y-coordinate of a chip
Returns: True if the chip with coordinates (x, y) is in the subset
Return type: bool
-
is_core
(x, y, processor_id)[source]¶ Determine if there is a chip with coordinates (x, y) in the subset, which has a core with the given ID in the subset
Parameters: - x (int) – The x-coordinate of a chip
- y (int) – The y-coordinate of a chip
- processor_id (int) – The ID of a core
Returns: Whether there is a chip with coordinates (x, y) in the subset, which has a core with the given ID in the subset
Return type: bool
-
values
()[source]¶ Return type: iterable(CoreSubset)
-
-
class
spinn_machine.
FixedRouteEntry
(processor_ids, link_ids)[source]¶ Bases:
object
Describes an entry in a SpiNNaker chip’s fixed route routing table.
-
link_ids
¶ The destination link IDs
Returns: An iterable of link IDs Return type: iterable(int)
-
processor_ids
¶ The destination processor IDs
Returns: An iterable of processor IDs Return type: iterable(int)
-
-
class
spinn_machine.
Link
(source_x, source_y, source_link_id, destination_x, destination_y)[source]¶ Bases:
object
Represents a directional link between SpiNNaker chips in the machine
Parameters: - source_x (int) – The x-coordinate of the source chip of the link
- source_y (int) – The y-coordinate of the source chip of the link
- source_link_id (int) – The ID of the link in the source chip
- destination_x (int) – The x-coordinate of the destination chip of the link
- destination_y (int) – The y-coordinate of the destination chip of the link
Raises: None – No known exceptions are raised
-
destination_x
¶ The x-coordinate of the destination chip of this link
Returns: The x-coordinate Return type: int
-
destination_y
¶ The y-coordinate of the destination chip of this link
Returns: The y-coordinate Return type: int
-
source_link_id
¶ The ID of the link on the source chip
Returns: The link ID Return type: int
-
source_x
¶ The x-coordinate of the source chip of this link
Returns: The x-coordinate Return type: int
-
source_y
¶ The y-coordinate of the source chip of this link
Returns: The y-coordinate Return type: int
-
class
spinn_machine.
Machine
(width, height, chips=None, origin=None)[source]¶ Bases:
object
A representation of a SpiNNaker Machine with a number of Chips. Machine is also iterable, providing ((x, y), chip) where:
- x is the x-coordinate of a chip
- y is the y-coordinate of a chip
- chip is the chip with the given x, y coordinates
Creates an abstract machine that must be superclassed by wrap type.
Use machine_fatcory methods to determine the correct machine class
Parameters: - width (int) – The width of the machine excluding any virtual chips
- height (int) – The height of the machine excluding any virtual chips
- chips (iterable(Chip)) – An iterable of chips in the machine
- origin (str) – Extra information about how this machine was created to be used in the str method. Example “Virtual” or “Json”
Raises: SpinnMachineAlreadyExistsException – If any two chips have the same x and y coordinates
-
BOARD_48_CHIPS
= [(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7)]¶
-
BOARD_VERSION_FOR_48_CHIPS
= [4, 5]¶
-
BOARD_VERSION_FOR_4_CHIPS
= [2, 3]¶
-
CHIPS_PER_BOARD
= {(0, 0): 18, (0, 1): 18, (0, 2): 18, (0, 3): 18, (1, 0): 18, (1, 1): 17, (1, 2): 18, (1, 3): 17, (1, 4): 18, (2, 0): 18, (2, 1): 18, (2, 2): 18, (2, 3): 18, (2, 4): 18, (2, 5): 18, (3, 0): 18, (3, 1): 17, (3, 2): 18, (3, 3): 17, (3, 4): 18, (3, 5): 17, (3, 6): 18, (4, 0): 18, (4, 1): 18, (4, 2): 18, (4, 3): 18, (4, 4): 18, (4, 5): 18, (4, 6): 18, (4, 7): 18, (5, 1): 18, (5, 2): 17, (5, 3): 18, (5, 4): 17, (5, 5): 18, (5, 6): 17, (5, 7): 18, (6, 2): 18, (6, 3): 18, (6, 4): 18, (6, 5): 18, (6, 6): 18, (6, 7): 18, (7, 3): 18, (7, 4): 18, (7, 5): 18, (7, 6): 18, (7, 7): 18}¶
-
DEFAULT_MAX_CORES_PER_CHIP
= 18¶
-
LINK_ADD_TABLE
= [(1, 0), (1, 1), (0, 1), (-1, 0), (-1, -1), (0, -1)]¶
-
MAX_BANDWIDTH_PER_ETHERNET_CONNECTED_CHIP
= 2560¶
-
MAX_CHIPS_PER_48_BOARD
= 48¶
-
MAX_CHIPS_PER_4_CHIP_BOARD
= 4¶
-
MAX_CHIP_X_ID_ON_ONE_BOARD
= 7¶
-
MAX_CHIP_Y_ID_ON_ONE_BOARD
= 7¶
-
SIZE_X_OF_ONE_BOARD
= 8¶
-
SIZE_Y_OF_ONE_BOARD
= 8¶
-
add_chip
(chip)[source]¶ Add a chip to the machine
Parameters: chip ( Chip
) – The chip to add to the machineReturns: Nothing is returned Return type: None Raises: SpinnMachineAlreadyExistsException – If a chip with the same x and y coordinates already exists
-
add_chips
(chips)[source]¶ Add some chips to the machine
Parameters: chips (iterable( Chip
)) – an iterable of chipsReturns: Nothing is returned Return type: None Raises: SpinnMachineAlreadyExistsException – If a chip with the same x and y coordinates as one being added already exists
-
add_fpga_links
()[source]¶ Add FPGA links that are on a given machine depending on the version of the board.
-
add_spinnaker_links
()[source]¶ Add SpiNNaker links that are on a given machine depending on the version of the board.
-
chip_coordinates
¶ An iterable of chip coordinates in the machine
Returns: An iterable of chip coordinates Return type: iterable(int,int)
-
chips
¶ An iterable of chips in the machine
Returns: An iterable of chips Return type: iterable( Chip
)Raises: None – does not raise any known exceptions
-
cores_and_link_output_string
()[source]¶ Get a string detailing the number of cores and links
Return type: str
-
ethernet_connected_chips
¶ The chips in the machine that have an Ethernet connection
Return type: iterable(Chip)
-
get_chip_at
(x, y)[source]¶ Get the chip at a specific (x, y) location. Also implemented as __getitem__((x, y))
Parameters: - x (int) – the x-coordinate of the requested chip
- y (int) – the y-coordinate of the requested chip
Returns: the chip at the specified location, or None if no such chip
Return type: Raises: None – does not raise any known exceptions
-
get_chips_by_ethernet
(ethernet_x, ethernet_y)[source]¶ Yields the actual chips on the board with this ethernet. Including the Ethernet chip itself.
Wrap-arounds are handled as appropriate.
This method does check if the chip actually exists.
Parameters: - ethernet_x – The x coordinate of a (local 0,0) legal ethernet chip
- ethernet_y – The y coordinate of a (local 0,0) legal ethernet chip
Returns: Yields the chips on this board.
Return type: iterable(Chip)
-
get_cores_and_link_count
()[source]¶ Get the number of cores and links from the machine
Links are assumed to be bidirectional so the total links counted is half of the unidirectional links found.
Spinnaker and fpga links are not included.
Returns: tuple of (n_cores, n_links) Return type: tuple(int,int)
-
get_down_xys_by_ethernet
(ethernet_x, ethernet_y)[source]¶ Yields the (x,y) coordinates of the down chips on the board with this ethernet.
Note the Ethernet chip itself can not be missing if validated
Wrap-arounds are handled as appropriate.
This method does check if the chip actually exists.
Parameters: - ethernet_x – The x coordinate of a (local 0,0) legal ethernet chip
- ethernet_y – The y coordinate of a (local 0,0) legal ethernet chip
Returns: Yields the (x, y) of the down chips on this board.
Return type: iterable(tuple(int,int))
-
get_existing_xys_by_ethernet
(ethernet_x, ethernet_y)[source]¶ Yields the (x,y)s of actual chips on the board with this ethernet. Including the Ethernet chip itself.
Wrap-arounds are handled as appropriate.
This method does check if the chip actually exists.
Parameters: - ethernet_x – The x coordinate of a (local 0,0) legal ethernet chip
- ethernet_y – The y coordinate of a (local 0,0) legal ethernet chip
Returns: Yields the (x,y)s of chips on this board.
Return type: iterable(tuple(int,int))
-
get_existing_xys_on_board
(chip)[source]¶ Get the chips that are on the same board as the given chip
Parameters: chip – The chip to find other chips on the same board as Returns: An iterable of (x, y) coordinates of chips on the same board Return type: iterable(tuple(int,int))
-
get_fpga_link_with_id
(fpga_id, fpga_link_id, board_address=None)[source]¶ Get an FPGA link data item that corresponds to the FPGA and FPGA link for a given board address.
Parameters: - fpga_id (int) – the ID of the FPGA that the data is going through. Refer to technical document located here for more detail: https://drive.google.com/file/d/0B9312BuJXntlVWowQlJ3RE8wWVE
- fpga_link_id (int) – the link ID of the FPGA. Refer to technical document located here for more detail: https://drive.google.com/file/d/0B9312BuJXntlVWowQlJ3RE8wWVE
- board_address (str) – the board address that this FPGA link is associated with
Return type: Returns: the given FPGA link object or None if no such link
-
get_global_xy
(local_x, local_y, ethernet_x, ethernet_y)[source]¶ Converts the local x and y coordinates into global x,y coordinates, under the assumption that they are on the board with local 0,0 at ethernet_x, ethernet_y
This method does take wrap-arounds into consideration.
GIGO: This method does not check if input parameters make sense, nor does it check if there is a chip at the resulting global x,y
Parameters: - local_x – A valid local x coordinate for a chip
- local_y – A valid local y coordinate for a chip
- ethernet_x – The global ethernet x for the board the chip is on
- ethernet_y – The global ethernet y for the board the chip is on
Returns: global (x,y) coordinates of the chip
Return type: tuple(int,int)
-
get_local_xy
(chip)[source]¶ Converts the x and y coordinates into the local coordinates on the board as if the ethernet was at position 0,0
This method does take wrap-arounds into consideration.
This method assumes that chip is on the machine or is a copy of a chip on the machine
Parameters: chip – A Chip in the machine Returns: Local (x, y) coordinates. Return type: tuple(int,int)
-
get_spinnaker_link_with_id
(spinnaker_link_id, board_address=None)[source]¶ Get a SpiNNaker link with a given ID
Parameters: - spinnaker_link_id (int) – The ID of the link
- board_address (str or None) – the board address that this SpiNNaker link is associated with
Returns: The SpiNNaker link data or None if no link
Return type:
-
get_vector
(source, destination)[source]¶ Get mathematical shortest vector (x, y, z) from source to destination
This method does not check if the chips and links it assumes to take actually exist. For example long paths along a none wrapping edge may well travel through the missing area.
This method does take wrap-arounds into consideration as applicable.
From https://github.com/project-rig/rig/blob/master/rig/geometry.py Described in http://jhnet.co.uk/articles/torus_paths
Use the same algorithm as vector_length using the best x, y pair as minimize(x, y, 0)
Parameters: - source ((int, int)) – (x,y) coordinates of the source chip
- destination – (x,y) coordinates of the destination chip
Returns:
-
get_vector_length
(source, destination)[source]¶ Get the mathematical length of the shortest vector (x, y, z) from source to destination
Use the same algorithm as vector to find the best x, y pair but then is optimised to directly calculate length
This method does not check if the chips and links it assumes to take actually exist. For example long paths along a none wrapping edge may well travel through the missing area.
This method does take wrap-arounds into consideration as applicable.
From https://github.com/project-rig/rig/blob/master/rig/geometry.py Described in http://jhnet.co.uk/articles/torus_paths
On full wrap-around machines (before minimisation) the vectors can have any of the 4 combinations of positive and negative x and y The positive one is: destination - source % dimension The negative one is: positive - dimension If source is less than dimension the negative one is the wrap around If destination is greater than source the positive one wraps
One no wrap or part wrap boards the x/y that does not wrap is just destination - source
The length of vectors where both x and y have the same sign will be max(abs(x), abs(y)). As the z direction can be used in minimisation The length of vectors where x and y have opposite signs will be abs(x) and abs(y) as these are already minimum so z is not used.
GIGO: This method does not check if input parameters make sense,
Parameters: - source ((int, int)) – (x,y) coordinates of the source chip
- destination ((int, int)) – (x,y) coordinates of the destination chip
Returns: The distance in steps
Return type: int
-
get_xy_cores_by_ethernet
(ethernet_x, ethernet_y)[source]¶ Yields the potential x,y locations and the typical number of cores of all the chips on the board with this ethernet.
Includes the Ethernet chip itself.
Wrap-arounds are handled as appropriate.
Note: This method does not check if the chip actually exists, nor report the actual number of cores on this chip, as is intended to be called to create the chips.
The number of cores is based on the 1,000,000 core machine where the board where built with the the 17 core chips placed in the same location on nearly every board.
Warning: GIGO! This methods assumes that ethernet_x and ethernet_y are the local 0,0 of an existing board, within the width and height of the machine.
Parameters: - ethernet_x – The x coordinate of a (local 0,0) legal ethernet chip
- ethernet_y – The y coordinate of a (local 0,0) legal ethernet chip
Returns: Yields (x, y, n_cores) where x , y are coordinates of all the potential chips on this board, and n_cores is the typcial number of cores for a chip in that possition.
Return type: iterable(tuple(int,int))
-
get_xys_by_ethernet
(ethernet_x, ethernet_y)[source]¶ Yields the potential x,y locations of all the chips on the board with this ethernet. Including the Ethernet chip itself.
Wrap-arounds are handled as appropriate.
Note: This method does not check if the chip actually exists as is intended to be called to create the chips.
Warning: GIGO! This methods assumes that ethernet_x and ethernet_y are the local 0,0 of an existing board, within the width and height of the machine.
Parameters: - ethernet_x – The x coordinate of a (local 0,0) legal ethernet chip
- ethernet_y – The y coordinate of a (local 0,0) legal ethernet chip
Returns: Yields the (x, y) coordinates of all the potential chips on this board.
Return type: iterable(tuple(int,int))
-
height
¶ The height to the machine ignoring virtual chips
Returns: The height to the machine ignoring virtual chips Return type: int
-
is_chip_at
(x, y)[source]¶ Determine if a chip exists at the given coordinates. Also implemented as __contains__((x, y))
Parameters: - x (int) – x location of the chip to test for existence
- y (int) – y location of the chip to test for existence
Returns: True if the chip exists, False otherwise
Return type: bool
Raises: None – does not raise any known exceptions
-
is_link_at
(x, y, link)[source]¶ Determine if a link exists at the given coordinates
Parameters: - x (int) – The x location of the chip to test the link of
- y (int) – The y location of the chip to test the link of
- link (int) – The link to test the existence of
-
local_xys
¶ Provides a list of local (x,y) values for a perfect board on this machine.
Local (x,y)s never include wrap-arounds.
Note: no check is done to see if any board in the machine actually has a chip with this local x, y
Returns: a list of (x,y) coordinates Return type: iterable(tuple(int,int))
-
max_chip_x
¶ The maximum x-coordinate of any chip in the board
Returns: The maximum x-coordinate Return type: int
-
max_chip_y
¶ The maximum y-coordinate of any chip in the board
Returns: The maximum y-coordinate Return type: int
-
static
max_cores_per_chip
()[source]¶ Gets the max core per chip for the while system.
There is no guarantee that there will be any Chips with this many cores, only that there will be no cores with more.
Returns: the default cores per chip unless overridden by set
-
maximum_user_cores_on_chip
¶ The maximum number of user cores on any chip
-
multiple_48_chip_boards
()[source]¶ Checks that the width and height correspond to the expected size for a multi-board machine made up of more than one 48 chip board.
The assumption is that any size machine can be supported but that only ones with an expected 48 chip board size can have more than one ethernet chip.
Returns: True if this machine can have multiple 48 chip boards Return type: bool
-
n_chips
¶ The number of chips in the machine.
Return type: int
-
static
set_max_cores_per_chip
(new_max)[source]¶ Allows setting the max number of cores per chip for the whole system.
Allows virtual machines to go higher than normal.
Real machines can only be capped never increased beyond what they actually have.
Parameters: new_max – New value to use for the max Raises: SpinnMachineException if max_cores_per_chip has already been used and is now being changed. The Exception also happens if the value is set twice to difference values. For example in the script and in the config.
-
spinnaker_links
¶ The set of SpiNNaker links in the machine
Return type: iterable(SpinnakerLinkData)
-
total_available_user_cores
¶ The total number of cores on the machine which are not monitor cores
Returns: total Return type: int
-
total_cores
¶ The total number of cores on the machine, including monitors
Returns: total Return type: int
-
unreachable_incoming_chips
()[source]¶ Detects chips that are not reachable from any of their neighbours
Current implementation does NOT deal with group of unreachable chips
Returns: List (hopefully empty) if the (x,y) cooridinates of unreachable chips.
-
unreachable_incoming_local_chips
()[source]¶ Detects chips that are not reachable from any of their LOCAL neighbours
Current implementation does NOT deal with group of unreachable chips
Returns: List (hopefully empty) if the (x,y) cooridinates of unreachable chips.
-
unreachable_outgoing_chips
()[source]¶ Detects chips that can not reach any of their neighbours
Current implementation does NOT deal with group of unreachable chips
Returns: List (hopefully empty) if the (x,y) cooridinates of unreachable chips.
-
unreachable_outgoing_local_chips
()[source]¶ Detects chips that can not reach any of their LOCAL neighbours
Current implementation does NOT deal with group of unreachable chips
Returns: List (hopefully empty) if the (x,y) cooridinates of unreachable chips.
-
validate
()[source]¶ Validates the machine and raises an exception in unexpected conditions.
Assumes that at the time this is called all chips are on the board.
This allows the checks to be avoided when creating a virtual machine (Except of course in testing)
An Error is raised if there is a chip with a x outside of the range 0 to width -1 (except for virtual ones) An Error is raised if there is a chip with a y outside of the range 0 to height -1 (except for virtual ones) An Error is raise if there is no chip at the declared ethernet x and y An Error is raised if an ethernet chip is not at a local 0,0 An Error is raised if there is no ethernet chip is at 0,0 An Error is raised if this is a unexpected multiple board situation :rtype: None
-
width
¶ The width to the machine ignoring virtual chips
Returns: The width to the machine ignoring virtual chips Return type: int
-
wrap
¶ String to represent the type of wrap.
Returns: Short string for type of wrap
-
xy_over_link
(x, y, link)[source]¶ Get the potential x,y location of the chip reached over this link.
Wrap-arounds are handled as appropriate.
Note: This method does not check if either chip source or destination actually exists as is intended to be called to create the links.
It is the callers responsibility to check the validity of this call before making it or the validity of the result.
Warning: GIGO! This methods assumes that x and y are within the width and height of the machine, and that the link goes to another chip on the machine.
On machine without full wrap-around it is possible that this method generates x,y values that fall outside of the legal values including negative values, x = width or y = height.
Parameters: - x – The x coordinate of a chip that will exist on the machine
- y – The y coordinate of a chip that will exist on the machine
- link – The link to another chip that could exist on the machine
Returns: x and y coordinates of the chip over that link if it is valid or some fictional x,y if not.
Return type: tuple(int,int)
-
class
spinn_machine.
MulticastRoutingEntry
(routing_entry_key, mask, processor_ids=None, link_ids=None, defaultable=False, spinnaker_route=None)[source]¶ Bases:
object
Represents an entry in a SpiNNaker chip’s multicast routing table
Parameters: - routing_entry_key (int) – The routing key_combo
- mask (int) – The route key_combo mask
- processor_ids (iterable(int)) – The destination processor IDs
- link_ids (iterable(int)) – The destination link IDs
- defaultable (bool) – if this entry is defaultable (it receives packets from its directly opposite route position)
Raises: spinn_machine.exceptions.SpinnMachineAlreadyExistsException –
- If processor_ids contains the same ID more than once
- If link_ids contains the same ID more than once
-
defaultable
¶ Whether this entry is a defaultable entry
Returns: the bool that represents if a entry is defaultable or not Return type: bool
-
link_ids
¶ The destination link IDs
Returns: An iterable of link IDs Return type: iterable(int)
-
mask
¶ The routing mask
Returns: The routing mask Return type: int
-
merge
(other_entry)[source]¶ Merges together two multicast routing entries. The entry to merge must have the same key and mask. The merge will join the processor IDs and link IDs from both the entries. This could be used to add a new destination to an existing route in a routing table. It is also possible to use the add (+) operator or the or (|) operator with the same effect.
Parameters: other_entry ( MulticastRoutingEntry
) – The multicast entry to merge with this entryReturns: A new multicast routing entry with merged destinations Return type: MulticastRoutingEntry
Raises: spinn_machine.exceptions.SpinnMachineInvalidParameterException – If the key and mask of the other entry do not match
-
processor_ids
¶ The destination processor IDs
Returns: An iterable of processor IDs Return type: iterable(int)
-
routing_entry_key
¶ The routing key
Returns: The routing key Return type: int
-
spinnaker_route
¶
-
class
spinn_machine.
Processor
(processor_id, clock_speed=200000000, is_monitor=False, dtcm_available=65536)[source]¶ Bases:
object
A processor object included in a SpiNNaker chip
Parameters: - processor_id (int) – ID of the processor in the chip
- clock_speed (int) – The number of CPU cycles per second of the processor
- is_monitor (bool) – Determines if the processor is considered the monitor processor, and so should not be otherwise allocated
- dtcm_available (int) – Data Tightly Coupled Memory available
Raises: spinn_machine.exceptions.SpinnMachineInvalidParameterException – If the clock speed is negative
-
CLOCK_SPEED
= 200000000¶
-
DTCM_AVAILABLE
= 65536¶
-
clock_speed
¶ The clock speed of the processor in cycles per second
Returns: The clock speed in cycles per second Return type: int
-
clone_as_system_processor
()[source]¶ Creates a clone of this processor but changing it to a system processor.
Returns: A new Processor with the same properties INCLUDING the ID except now set as a System processor Return type: Processor
-
cpu_cycles_available
¶ The number of CPU cycles available from this processor per ms
Returns: the number of CPU cycles available on this processor Return type: int
-
dtcm_available
¶ The amount of DTCM available on this processor
Returns: the amount of DTCM available on this processor Return type: int
-
is_monitor
¶ Determines if the processor is the monitor, and therefore not to be allocated
Warning
Currently rejection processors are also marked as monitors.
Returns: True if the processor is the monitor, False otherwise Return type: bool
-
processor_id
¶ The ID of the processor
Returns: ID of the processor Return type: int
-
class
spinn_machine.
Router
(links, emergency_routing_enabled=False, n_available_multicast_entries=1024)[source]¶ Bases:
object
Represents a router of a chip, with a set of available links. The router is iterable over the links, providing (source_link_id, link) where:
- source_link_id is the ID of a link
- link is the link with ID source_link_id
Parameters: - links (iterable(
Link
)) – iterable of links - emergency_routing_enabled (bool) – Determines if the router emergency routing is operating
- n_available_multicast_entries (int) – The number of entries available in the routing table
Raises: spinn_machine.exceptions.SpinnMachineAlreadyExistsException – If any two links have the same source_link_id
-
LINK_OPPOSITE
= 3¶
-
MAX_CORES_PER_ROUTER
= 18¶
-
MAX_LINKS_PER_ROUTER
= 6¶
-
ROUTER_DEFAULT_AVAILABLE_ENTRIES
= 1024¶
-
add_link
(link)[source]¶ Add a link to the router of the chip
Parameters: link ( spinn_machine.Link
) – The link to be addedReturns: Nothing is returned Return type: None Raises: spinn_machine.exceptions.SpinnMachineAlreadyExistsException – If another link already exists with the same source_link_id
-
static
convert_routing_table_entry_to_spinnaker_route
(routing_table_entry)[source]¶ Convert a routing table entry represented in software to a binary routing table entry usable on the machine
Parameters: routing_table_entry ( MulticastRoutingEntry
) – The entry to convertReturn type: int
-
static
convert_spinnaker_route_to_routing_ids
(route)[source]¶ Convert a binary routing table entry usable on the machine to lists of route IDs usable in a routing table entry represented in software.
Parameters: route (int) – The routing table entry Returns: The list of processor IDs, and the list of link IDs. Return type: tuple(list(int), list(int))
-
emergency_routing_enabled
¶ Indicator of whether emergency routing is enabled
Returns: True if emergency routing is enabled, False otherwise Return type: bool Raises: None – does not raise any known exceptions
-
get_link
(source_link_id)[source]¶ Get the link with the given ID, or None if no such link. Also implemented as __getitem__(source_link_id)
Parameters: source_link_id (int) – The ID of the link to find Returns: The link, or None if no such link Return type: Link
Raises: None – No known exceptions are raised
-
get_neighbouring_chips_coords
()[source]¶ Utility method to convert links into x and y coordinates
Returns: iterable list of destination coordinates in x and y dict Return type: iterable(dict(str,int))
-
is_link
(source_link_id)[source]¶ Determine if there is a link with ID source_link_id. Also implemented as __contains__(source_link_id)
Parameters: source_link_id (int) – The ID of the link to find Returns: True if there is a link with the given ID, False otherwise Return type: bool Raises: None – No known exceptions are raised
-
links
¶ The available links of this router
Returns: an iterable of available links Return type: iterable( Link
)Raises: None – does not raise any known exceptions
-
n_available_multicast_entries
¶ The number of available multicast entries in the routing tables
Returns: The number of available entries Return type: int Raises: None – does not raise any known exceptions
-
class
spinn_machine.
SDRAM
(size=122683392)[source]¶ Bases:
object
Represents the properties of the SDRAM of a chip in the machine
Parameters: size (int) – the space available in SDRAM -
DEFAULT_SDRAM_BYTES
= 122683392¶
-
max_sdram_found
= 0¶
-
size
¶ The SDRAM available for user applications
Returns: The space available in bytes Return type: int
-
-
class
spinn_machine.
SpiNNakerTriadGeometry
(triad_width, triad_height, roots, centre)[source]¶ Bases:
object
Geometry of a “triad” of SpiNNaker boards
The geometry is defined by the arguments to the constructor; the standard arrangement can be obtained from get_spinn5_geometry
Note that the geometry defines what a Triad is in terms of the dimensions of a triad and where the Ethernet chips occur in the triad
Parameters: - triad_width (int) – width of a triad in chips
- triad_height (int) – height of a triad in chips
- roots (list of (int, int)) – locations of the Ethernet connected chips
- centre ((float, float)) – the distance from each Ethernet chip to the centre of the hexagon
-
get_ethernet_chip_coordinates
(x, y, width, height, root_x=0, root_y=0)[source]¶ Get the coordinates of a chip’s local Ethernet connected chip according to this triad geometry object
Warning
local_eth_coord()
will always produce the coordinates of the Ethernet-connected SpiNNaker chip on the same SpiNN-5 board as the supplied chip. This chip may not actually be working.Parameters: - x (int) – x-coordinate of the chip to find the nearest Ethernet of
- y (int) – y-coordinate of the chip to find the nearest Ethernet of
- width (int) – width of the SpiNNaker machine (must be a multiple of the triad width of this geometry)
- height (int) – height of the SpiNNaker machine (must be a multiple of the triad height of this geometry)
- root_x (int) – x-coordinate of the boot chip (default 0, 0)
- root_y (int) – y-coordinate of the boot chip (default 0, 0)
Returns: The coordinates of the closest Ethernet chip
Return type: (int, int)
-
get_local_chip_coordinate
(x, y, root_x=0, root_y=0)[source]¶ Get the coordinates of a chip on its board of a multi-board system relative to the Ethernet chip of the board.
Note
This function assumes the system is constructed from SpiNN-5 boards
Parameters: - x (int) – The x-coordinate of the chip to find the location of
- y (int) – The y-coordinate of the chip to find the location of
- root_x (int) – The x-coordinate of the boot chip (default 0, 0)
- root_y (int) – The y-coordinate of the boot chip (default 0, 0)
Returns: the coordinates of the chip relative to its board
Return type: (int, int)
-
get_potential_ethernet_chips
(width, height)[source]¶ Get the coordinates of chips that should be Ethernet chips
Parameters: - width – The width of the machine to find the chips in
- height – The height of the machine to find the chips in
-
static
get_spinn5_geometry
()[source]¶ Get the geometry object for a SpiNN-5 arrangement of boards
Returns: a SpiNNakerTriadGeometry
object.
-
spinn5_triad_geometry
= None¶
-
spinn_machine.
virtual_machine
(width, height, n_cpus_per_chip=None, sdram_per_chip=122683392, down_chips=None, down_cores=None, down_links=None, router_entries_per_chip=1024, validate=True)[source]¶ Parameters: - width (int) – the width of the virtual machine in chips
- height (int) – the height of the virtual machine in chips
- n_cpus_per_chip (int) – The number of CPUs to put on each chip
- sdram_per_chip (int or None) – The amount of SDRAM to give to each chip
- router_entries_per_chip (int) – the number of entries to each router
- validate (bool) – if True will call the machine validate function
Returns: a virtual machine (that cannot execute code)
Return type:
-
spinn_machine.
machine_from_chips
(chips)[source]¶ Create a machine with the assumed wrap-around based on the sizes.
The size of the machine is calculated from the list of chips.
Parameters: chips (list(Chip)) – Full list of all chips on this machine. Or at least a list which includes a chip with the highest X and one with the highest Y (excluding any virtual chips) Returns: A subclass of Machine Return type: Machine
-
spinn_machine.
machine_from_size
(width, height, chips=None, origin=None)[source]¶ Create a machine with the assumed wrap-around based on the sizes.
This could include a machine with no wrap-arounds, only vertical ones, only horizontal ones or both.
Note: If the sizes do not match the ones for a known wrap-around machine, no wrap-arounds is assumed.
Parameters: - width (int) – The width of the machine excluding any virtual chips
- height (int) – The height of the machine excluding any virtual chips
- chips (list(Chip) or None) – Any chips to be added.
- origin (str or None) – Extra information about how this machine was created to be used in the str method. Example “Virtual” or “Json”
Returns: A subclass of Machine
Return type: