spinn_machine package

Subpackages

Submodules

spinn_machine.config_setup module

spinn_machine.config_setup.add_spinn_machine_cfg() None[source]

Add the local configuration and all dependent configuration files.

spinn_machine.config_setup.unittest_setup() None[source]

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

Note

This file should only be called from SpiNNMachine/unittests

spinn_machine.exceptions module

exception spinn_machine.exceptions.SpinnMachineAlreadyExistsException(item: str, value)[source]

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

property item: str

The item of which there is already one.

property value

The value of the item.

exception spinn_machine.exceptions.SpinnMachineException[source]

Bases: Exception

A generic exception which all other exceptions in this package extend.

exception spinn_machine.exceptions.SpinnMachineInvalidParameterException(parameter: str, value, problem: str)[source]

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

property parameter: str

The name of the parameter.

property problem: str

The problem with the setting of the parameter.

property value

The value of the parameter.

spinn_machine.full_wrap_machine module

class spinn_machine.full_wrap_machine.FullWrapMachine(width: int, height: int, chip_core_map: Dict[Tuple[int, int], int], origin: str = '')[source]

Bases: Machine

Parameters:
  • width (int) – The width of the machine excluding

  • height (int) – The height of the machine

  • chip_core_map (dict((int, int), int)) – A map off the expected x,y coordinates on a standard board to the most likely number of cores on that chip.

  • 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

concentric_xys(radius: int, start: Tuple[int, int]) Iterable[Tuple[int, int]][source]

A generator that produces coordinates for concentric rings of possible chips based on the links of the chips.

No check is done to see if the chip exists. This may even produce coordinates with negative numbers

Mostly copied from: https://github.com/project-rig/rig/blob/master/rig/geometry.py

Parameters:
  • radius (int) – The radius of rings to produce (0 = start only)

  • start (tuple(int,int)) – The start coordinate

Return type:

iterable(tuple(int,int))

get_down_xys_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[int, int]][source]

Yields the (x,y) coordinates of the down chips on the board with this Ethernet-enabled chip.

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 (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled 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: int, ethernet_y: int) Iterable[Tuple[int, int]][source]

Yields the (x,y)s of actual chips on the board with this Ethernet-enabled chip. Including the Ethernet-enabled chip itself.

Wrap-arounds are handled as appropriate.

This method does check if the chip actually exists.

Parameters:
  • ethernet_x (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled chip

Returns:

Yields the (x,y)s of chips on this board.

Return type:

iterable(tuple(int,int))

get_global_xy(local_x: int, local_y: int, ethernet_x: int, ethernet_y: int) Tuple[int, int][source]

Converts the local (X, Y) coordinates into global (x,y) coordinates, under the assumption that they are on the board with local (0,0) at global coordinates (ethernet_x, ethernet_y).

This method does take wrap-arounds into consideration.

Warning

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 (int) – A valid local x coordinate for a chip

  • local_y (int) – A valid local y coordinate for a chip

  • ethernet_x (int) – The global Ethernet-enabled chip X coordinate for the board the chip is on

  • ethernet_y (int) – The global Ethernet-enabled chip Y coordinate for the board the chip is on

Returns:

global (x,y) coordinates of the chip

Return type:

tuple(int,int)

get_local_xy(chip: Chip) Tuple[int, int][source]

Converts the x and y coordinates into the local coordinates on the board as if the Ethernet-enabled chip 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 (Chip) – A Chip in the machine

Returns:

Local (x, y) coordinates.

Return type:

tuple(int,int)

get_vector(source: Tuple[int, int], destination: Tuple[int, int]) Tuple[int, int, int][source]

Get mathematical shortest vector (x, y, z) from source to destination. The z direction uses the diagonal inter-chip links; (0,0,1) is equivalent to (1,1,0) in terms of where it reaches but uses a more efficient route.

This method does not check if the chips and links it assumes to take actually exist. For example long paths along a non-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 (tuple(int, int)) – (x,y) coordinates of the source chip

  • destination (tuple(int, int)) – (x,y) coordinates of the destination chip

Returns:

The vector

get_vector_length(source: Tuple[int, int], destination: Tuple[int, int]) int[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 non-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.

Warning

GIGO: This method does not check if input parameters make sense.

Parameters:
  • source (tuple(int, int)) – (x,y) coordinates of the source chip

  • destination (tuple(int, int)) – (x,y) coordinates of the destination chip

Returns:

The distance in steps

Return type:

int

get_xy_cores_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[Tuple[int, int], int]][source]

Yields the potential (x,y) locations and the typical number of cores of all the chips on the board with this Ethernet-enabled chip.

Includes the Ethernet-enabled 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 (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled 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 typical number of cores for a chip in that position.

Return type:

iterable(tuple(tuple(int,int),int))

get_xys_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[int, int]][source]

Yields the potential x,y locations of all the chips on the board with this Ethernet-enabled chip. Including the Ethernet-enabled 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 (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled chip

Returns:

Yields the (x, y) coordinates of all the potential chips on this board.

Return type:

iterable(tuple(int,int))

multiple_48_chip_boards() bool[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-enabled chip.

Returns:

True if this machine can have multiple 48 chip boards

Return type:

bool

property wrap: str

A short string representing the type of wrap.

Return type:

str

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 (int) – The x coordinate of a chip that will exist on the machine

  • y (int) – The y coordinate of a chip that will exist on the machine

  • link (int) – 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)

spinn_machine.horizontal_wrap_machine module

class spinn_machine.horizontal_wrap_machine.HorizontalWrapMachine(width: int, height: int, chip_core_map: Dict[Tuple[int, int], int], origin: str = '')[source]

Bases: Machine

Parameters:
  • width (int) – The width of the machine excluding

  • height (int) – The height of the machine

  • chip_core_map (dict((int, int), int)) – A map off the expected x,y coordinates on a standard board to the most likely number of cores on that chip.

  • 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

concentric_xys(radius: int, start: Tuple[int, int]) Iterable[Tuple[int, int]][source]

A generator that produces coordinates for concentric rings of possible chips based on the links of the chips.

No check is done to see if the chip exists. This may even produce coordinates with negative numbers

Mostly copied from: https://github.com/project-rig/rig/blob/master/rig/geometry.py

Parameters:
  • radius (int) – The radius of rings to produce (0 = start only)

  • start (tuple(int,int)) – The start coordinate

Return type:

iterable(tuple(int,int))

get_down_xys_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[int, int]][source]

Yields the (x,y) coordinates of the down chips on the board with this Ethernet-enabled chip.

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 (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled 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: int, ethernet_y: int) Iterable[Tuple[int, int]][source]

Yields the (x,y)s of actual chips on the board with this Ethernet-enabled chip. Including the Ethernet-enabled chip itself.

Wrap-arounds are handled as appropriate.

This method does check if the chip actually exists.

Parameters:
  • ethernet_x (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled chip

Returns:

Yields the (x,y)s of chips on this board.

Return type:

iterable(tuple(int,int))

get_global_xy(local_x: int, local_y: int, ethernet_x: int, ethernet_y: int) Tuple[int, int][source]

Converts the local (X, Y) coordinates into global (x,y) coordinates, under the assumption that they are on the board with local (0,0) at global coordinates (ethernet_x, ethernet_y).

This method does take wrap-arounds into consideration.

Warning

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 (int) – A valid local x coordinate for a chip

  • local_y (int) – A valid local y coordinate for a chip

  • ethernet_x (int) – The global Ethernet-enabled chip X coordinate for the board the chip is on

  • ethernet_y (int) – The global Ethernet-enabled chip Y coordinate for the board the chip is on

Returns:

global (x,y) coordinates of the chip

Return type:

tuple(int,int)

get_local_xy(chip: Chip) Tuple[int, int][source]

Converts the x and y coordinates into the local coordinates on the board as if the Ethernet-enabled chip 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 (Chip) – A Chip in the machine

Returns:

Local (x, y) coordinates.

Return type:

tuple(int,int)

get_vector(source: Tuple[int, int], destination: Tuple[int, int]) Tuple[int, int, int][source]

Get mathematical shortest vector (x, y, z) from source to destination. The z direction uses the diagonal inter-chip links; (0,0,1) is equivalent to (1,1,0) in terms of where it reaches but uses a more efficient route.

This method does not check if the chips and links it assumes to take actually exist. For example long paths along a non-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 (tuple(int, int)) – (x,y) coordinates of the source chip

  • destination (tuple(int, int)) – (x,y) coordinates of the destination chip

Returns:

The vector

get_vector_length(source: Tuple[int, int], destination: Tuple[int, int]) int[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 non-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.

Warning

GIGO: This method does not check if input parameters make sense.

Parameters:
  • source (tuple(int, int)) – (x,y) coordinates of the source chip

  • destination (tuple(int, int)) – (x,y) coordinates of the destination chip

Returns:

The distance in steps

Return type:

int

get_xy_cores_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[Tuple[int, int], int]][source]

Yields the potential (x,y) locations and the typical number of cores of all the chips on the board with this Ethernet-enabled chip.

Includes the Ethernet-enabled 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 (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled 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 typical number of cores for a chip in that position.

Return type:

iterable(tuple(tuple(int,int),int))

get_xys_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[int, int]][source]

Yields the potential x,y locations of all the chips on the board with this Ethernet-enabled chip. Including the Ethernet-enabled 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 (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled chip

Returns:

Yields the (x, y) coordinates of all the potential chips on this board.

Return type:

iterable(tuple(int,int))

multiple_48_chip_boards() bool[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-enabled chip.

Returns:

True if this machine can have multiple 48 chip boards

Return type:

bool

property wrap: str

A short string representing the type of wrap.

Return type:

str

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 (int) – The x coordinate of a chip that will exist on the machine

  • y (int) – The y coordinate of a chip that will exist on the machine

  • link (int) – 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)

spinn_machine.json_machine module

spinn_machine.json_machine.machine_from_json(j_machine: Dict[str, int | float | str | None | Dict[str, int | float | str | None | JsonObject | List[int | float | str | None | JsonObject | JsonArray]] | List[int | float | str | None | Dict[str, int | float | str | None | JsonObject | JsonArray] | JsonArray]] | str) Machine[source]

Generate a model of a machine from a JSON description of that machine.

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

Returns:

The machine model.

Return type:

Machine

spinn_machine.json_machine.to_json() Dict[str, int | float | str | None | Dict[str, int | float | str | None | JsonObject | List[int | float | str | None | JsonObject | JsonArray]] | List[int | float | str | None | Dict[str, int | float | str | None | JsonObject | JsonArray] | JsonArray]][source]

Runs the code to write the machine in Java readable JSON.

Return type:

dict

spinn_machine.json_machine.to_json_path(file_path: str) None[source]

Runs the code to write the machine in Java readable JSON.

Parameters:

file_path (str) – Location to write file to. Warning will overwrite!

Return type:

None

spinn_machine.machine_factory module

spinn_machine.machine_factory.machine_repair(original: Machine, removed_chips: Iterable[Tuple[int, int]] = ())[source]

Remove chips that can’t be reached or that can’t reach other chips due to missing links.

Also remove any one way links.

Parameters:
  • original (Machine) – the original machine

  • removed_chips (list(tuple(int,int))) – List of chips (x and y coordinates) that have been removed while the machine was being created. One-way links to these chip are expected repairs so always done and never logged

Raises:

SpinnMachineException – if repair_machine is false and an unexpected repair is needed.

Returns:

Either the original machine or a repaired replacement

Return type:

Machine

spinn_machine.no_wrap_machine module

class spinn_machine.no_wrap_machine.NoWrapMachine(width: int, height: int, chip_core_map: Dict[Tuple[int, int], int], origin: str = '')[source]

Bases: Machine

Parameters:
  • width (int) – The width of the machine excluding

  • height (int) – The height of the machine

  • chip_core_map (dict((int, int), int)) – A map off the expected x,y coordinates on a standard board to the most likely number of cores on that chip.

  • 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

concentric_xys(radius: int, start: Tuple[int, int]) Iterable[Tuple[int, int]][source]

A generator that produces coordinates for concentric rings of possible chips based on the links of the chips.

No check is done to see if the chip exists. This may even produce coordinates with negative numbers

Mostly copied from: https://github.com/project-rig/rig/blob/master/rig/geometry.py

Parameters:
  • radius (int) – The radius of rings to produce (0 = start only)

  • start (tuple(int,int)) – The start coordinate

Return type:

iterable(tuple(int,int))

get_down_xys_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[int, int]][source]

Yields the (x,y) coordinates of the down chips on the board with this Ethernet-enabled chip.

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 (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled 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: int, ethernet_y: int) Iterable[Tuple[int, int]][source]

Yields the (x,y)s of actual chips on the board with this Ethernet-enabled chip. Including the Ethernet-enabled chip itself.

Wrap-arounds are handled as appropriate.

This method does check if the chip actually exists.

Parameters:
  • ethernet_x (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled chip

Returns:

Yields the (x,y)s of chips on this board.

Return type:

iterable(tuple(int,int))

get_global_xy(local_x: int, local_y: int, ethernet_x: int, ethernet_y: int) Tuple[int, int][source]

Converts the local (X, Y) coordinates into global (x,y) coordinates, under the assumption that they are on the board with local (0,0) at global coordinates (ethernet_x, ethernet_y).

This method does take wrap-arounds into consideration.

Warning

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 (int) – A valid local x coordinate for a chip

  • local_y (int) – A valid local y coordinate for a chip

  • ethernet_x (int) – The global Ethernet-enabled chip X coordinate for the board the chip is on

  • ethernet_y (int) – The global Ethernet-enabled chip Y coordinate for the board the chip is on

Returns:

global (x,y) coordinates of the chip

Return type:

tuple(int,int)

get_local_xy(chip: Chip) Tuple[int, int][source]

Converts the x and y coordinates into the local coordinates on the board as if the Ethernet-enabled chip 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 (Chip) – A Chip in the machine

Returns:

Local (x, y) coordinates.

Return type:

tuple(int,int)

get_vector(source: Tuple[int, int], destination: Tuple[int, int]) Tuple[int, int, int][source]

Get mathematical shortest vector (x, y, z) from source to destination. The z direction uses the diagonal inter-chip links; (0,0,1) is equivalent to (1,1,0) in terms of where it reaches but uses a more efficient route.

This method does not check if the chips and links it assumes to take actually exist. For example long paths along a non-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 (tuple(int, int)) – (x,y) coordinates of the source chip

  • destination (tuple(int, int)) – (x,y) coordinates of the destination chip

Returns:

The vector

get_vector_length(source: Tuple[int, int], destination: Tuple[int, int]) int[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 non-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.

Warning

GIGO: This method does not check if input parameters make sense.

Parameters:
  • source (tuple(int, int)) – (x,y) coordinates of the source chip

  • destination (tuple(int, int)) – (x,y) coordinates of the destination chip

Returns:

The distance in steps

Return type:

int

get_xy_cores_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[Tuple[int, int], int]][source]

Yields the potential (x,y) locations and the typical number of cores of all the chips on the board with this Ethernet-enabled chip.

Includes the Ethernet-enabled 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 (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled 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 typical number of cores for a chip in that position.

Return type:

iterable(tuple(tuple(int,int),int))

get_xys_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[int, int]][source]

Yields the potential x,y locations of all the chips on the board with this Ethernet-enabled chip. Including the Ethernet-enabled 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 (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled chip

Returns:

Yields the (x, y) coordinates of all the potential chips on this board.

Return type:

iterable(tuple(int,int))

multiple_48_chip_boards() bool[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-enabled chip.

Returns:

True if this machine can have multiple 48 chip boards

Return type:

bool

property wrap: str

A short string representing the type of wrap.

Return type:

str

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 (int) – The x coordinate of a chip that will exist on the machine

  • y (int) – The y coordinate of a chip that will exist on the machine

  • link (int) – 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)

spinn_machine.vertical_wrap_machine module

class spinn_machine.vertical_wrap_machine.VerticalWrapMachine(width: int, height: int, chip_core_map: Dict[Tuple[int, int], int], origin: str = '')[source]

Bases: Machine

Parameters:
  • width (int) – The width of the machine excluding

  • height (int) – The height of the machine

  • chip_core_map (dict((int, int), int)) – A map off the expected x,y coordinates on a standard board to the most likely number of cores on that chip.

  • 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

concentric_xys(radius: int, start: Tuple[int, int]) Iterable[Tuple[int, int]][source]

A generator that produces coordinates for concentric rings of possible chips based on the links of the chips.

No check is done to see if the chip exists. This may even produce coordinates with negative numbers

Mostly copied from: https://github.com/project-rig/rig/blob/master/rig/geometry.py

Parameters:
  • radius (int) – The radius of rings to produce (0 = start only)

  • start (tuple(int,int)) – The start coordinate

Return type:

iterable(tuple(int,int))

get_down_xys_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[int, int]][source]

Yields the (x,y) coordinates of the down chips on the board with this Ethernet-enabled chip.

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 (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled 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: int, ethernet_y: int) Iterable[Tuple[int, int]][source]

Yields the (x,y)s of actual chips on the board with this Ethernet-enabled chip. Including the Ethernet-enabled chip itself.

Wrap-arounds are handled as appropriate.

This method does check if the chip actually exists.

Parameters:
  • ethernet_x (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled chip

Returns:

Yields the (x,y)s of chips on this board.

Return type:

iterable(tuple(int,int))

get_global_xy(local_x: int, local_y: int, ethernet_x: int, ethernet_y: int) Tuple[int, int][source]

Converts the local (X, Y) coordinates into global (x,y) coordinates, under the assumption that they are on the board with local (0,0) at global coordinates (ethernet_x, ethernet_y).

This method does take wrap-arounds into consideration.

Warning

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 (int) – A valid local x coordinate for a chip

  • local_y (int) – A valid local y coordinate for a chip

  • ethernet_x (int) – The global Ethernet-enabled chip X coordinate for the board the chip is on

  • ethernet_y (int) – The global Ethernet-enabled chip Y coordinate for the board the chip is on

Returns:

global (x,y) coordinates of the chip

Return type:

tuple(int,int)

get_local_xy(chip: Chip) Tuple[int, int][source]

Converts the x and y coordinates into the local coordinates on the board as if the Ethernet-enabled chip 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 (Chip) – A Chip in the machine

Returns:

Local (x, y) coordinates.

Return type:

tuple(int,int)

get_vector(source: Tuple[int, int], destination: Tuple[int, int]) Tuple[int, int, int][source]

Get mathematical shortest vector (x, y, z) from source to destination. The z direction uses the diagonal inter-chip links; (0,0,1) is equivalent to (1,1,0) in terms of where it reaches but uses a more efficient route.

This method does not check if the chips and links it assumes to take actually exist. For example long paths along a non-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 (tuple(int, int)) – (x,y) coordinates of the source chip

  • destination (tuple(int, int)) – (x,y) coordinates of the destination chip

Returns:

The vector

get_vector_length(source: Tuple[int, int], destination: Tuple[int, int]) int[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 non-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.

Warning

GIGO: This method does not check if input parameters make sense.

Parameters:
  • source (tuple(int, int)) – (x,y) coordinates of the source chip

  • destination (tuple(int, int)) – (x,y) coordinates of the destination chip

Returns:

The distance in steps

Return type:

int

get_xy_cores_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[Tuple[int, int], int]][source]

Yields the potential (x,y) locations and the typical number of cores of all the chips on the board with this Ethernet-enabled chip.

Includes the Ethernet-enabled 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 (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled 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 typical number of cores for a chip in that position.

Return type:

iterable(tuple(tuple(int,int),int))

get_xys_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[int, int]][source]

Yields the potential x,y locations of all the chips on the board with this Ethernet-enabled chip. Including the Ethernet-enabled 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 (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled chip

Returns:

Yields the (x, y) coordinates of all the potential chips on this board.

Return type:

iterable(tuple(int,int))

multiple_48_chip_boards() bool[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-enabled chip.

Returns:

True if this machine can have multiple 48 chip boards

Return type:

bool

property wrap: str

A short string representing the type of wrap.

Return type:

str

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 (int) – The x coordinate of a chip that will exist on the machine

  • y (int) – The y coordinate of a chip that will exist on the machine

  • link (int) – 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)

Module contents

An abstraction of a SpiNNaker Machine. The main functionality is provided 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 virtual Chip 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: int, y: int, n_processors: int, router: Router, sdram: int, nearest_ethernet_x: int, nearest_ethernet_y: int, ip_address: str | None = None, tag_ids: Iterable[int] | None = None, down_cores: Collection[int] | None = None, parent_link: int | None = None, v_to_p_map: bytes | None = 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 (int) – an SDRAM for the chip

  • ip_address (str or None) – the IP address of the chip, or None if no Ethernet attached

  • 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 (iterable(int) or None) – Ids of cores that are down for this Chip

  • parent_link (int or None) – The link down which the parent chips is found in the tree of chips towards the root (boot) chip

  • v_to_p_map (bytearray or None) – An array indexed by virtual core which gives the physical core number or 0xFF if no entry for the core

Raises:

SpinnMachineAlreadyExistsException – If processors contains any two processors with the same processor_id

get_first_none_monitor_processor() Processor | None[source]

Get the first processor in the list which is not a monitor core.

Return type:

Processor or None

get_physical_core_id(virtual_p: int) int | None[source]

Get the physical core ID from a virtual core ID.

Parameters:

virtual_p (int) – The virtual core ID

Return type:

int or None if core not in map

get_physical_core_string(virtual_p: int) str[source]

Get a string that can be appended to a core to show the physical core, or an empty string if not possible.

Parameters:

virtual_p (int) – The virtual core ID

Return type:

str

get_processor_with_id(processor_id: int) Processor | None[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 or None

property ip_address: str | None

The IP address of the chip, or None if there is no Ethernet connected to the chip.

Return type:

str or None

is_processor_with_id(processor_id: int) bool[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

property n_processors: int

The total number of processors.

Return type:

int

property n_user_processors: int

The total number of processors that are not monitors.

Return type:

int

property nearest_ethernet_x: int

The X-coordinate of the nearest Ethernet chip.

Return type:

int

property nearest_ethernet_y: int

The Y-coordinate of the nearest Ethernet chip.

Return type:

int

The link down which the parent is found in the tree of chips rooted at the machine root chip (probably 0, 0 in most cases). This will be None if the chip information didn’t contain this value.

Return type:

int or None

property processors: Iterator[Processor]

An iterable of available processors.

Return type:

iterable(Processor)

property router: Router

The router object associated with the chip.

Return type:

Router

property sdram: int

The SDRAM associated with the chip.

Return type:

int

property tag_ids: Iterable[int]

The tag IDs supported by this chip.

Return type:

iterable(int)

property x: int

The X-coordinate of the chip in the two-dimensional grid of chips.

Return type:

int

property y: int

The Y-coordinate of the chip in the two-dimensional grid of chips.

Return type:

int

class spinn_machine.CoreSubset(x: int, y: int, processor_ids: Iterable[int])[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: int)[source]

Adds a processor ID to this subset

Parameters:

processor_id (int) – A processor ID

intersect(other: CoreSubset) CoreSubset[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

property processor_ids: Iterator[int]

The processor IDs on the chip that in the subset.

Return type:

iterable(int)

property x: int

The X-coordinate of the chip

Return type:

int

property y: int

The Y-coordinate of the chip

Return type:

int

class spinn_machine.CoreSubsets(core_subsets: Iterable[CoreSubset] = ())[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: CoreSubset)[source]

Add a core subset to the set

Parameters:

core_subset (CoreSubset) – The core subset to add

add_core_subsets(core_subsets: Iterable[CoreSubset])[source]

Merges a core subsets into this one.

Parameters:

core_subsets (iterable(CoreSubset)) – the core subsets to add

add_processor(x: int, y: int, processor_id: int)[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

property core_subsets: Iterable[CoreSubset]

The one-per-chip subsets.

Returns:

Iterable of core subsets

Return type:

iterable(CoreSubset)

get_core_subset_for_chip(x: int, y: int) CoreSubset[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:

CoreSubset

intersect(other: CoreSubsets) CoreSubsets[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: int, y: int) bool[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: int, y: int, processor_id: int) bool[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() Iterable[CoreSubset][source]
Return type:

iterable(CoreSubset)

class spinn_machine.FixedRouteEntry(processor_ids: Iterable[int], link_ids: Iterable[int])[source]

Bases: object

Describes the sole entry in a SpiNNaker chip’s fixed route routing table. There is only one fixed route entry per chip.

Parameters:
  • processor_ids (iterable(int)) –

  • link_ids (iterable(int)) –

The destination link IDs.

Return type:

frozenset(int)

property processor_ids: FrozenSet[int]

The destination processor IDs.

Return type:

frozenset(int)

class spinn_machine.FrozenCoreSubsets(core_subsets: Iterable[CoreSubset] = ())[source]

Bases: CoreSubsets

Represents a frozen 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: CoreSubset)[source]

Add a core subset to the set

Parameters:

core_subset (CoreSubset) – The core subset to add

add_core_subsets(core_subsets: Iterable[CoreSubset])[source]

Merges a core subsets into this one.

Parameters:

core_subsets (iterable(CoreSubset)) – the core subsets to add

add_processor(x: int, y: int, processor_id: int)[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

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

property destination_x: int

The X-coordinate of the destination chip of this link.

Return type:

int

property destination_y: int

The Y-coordinate of the destination chip of this link.

Return type:

int

The ID of the link on the source chip.

Return type:

int

property source_x: int

The X-coordinate of the source chip of this link.

Return type:

int

property source_y: int

The Y-coordinate of the source chip of this link.

Return type:

int

class spinn_machine.Machine(width: int, height: int, chip_core_map: Dict[Tuple[int, int], int], origin: str = '')[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.

Parameters:
  • width (int) – The width of the machine excluding

  • height (int) – The height of the machine

  • chip_core_map (dict((int, int), int)) – A map off the expected x,y coordinates on a standard board to the most likely number of cores on that chip.

  • 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

add_chip(chip: Chip)[source]

Add a chip to the machine.

Parameters:

chip (Chip) – The chip to add to the machine

Raises:

SpinnMachineAlreadyExistsException – If a chip with the same x and y coordinates already exists

add_chips(chips: Iterable[Chip])[source]

Add some chips to the machine.

Parameters:

chips (iterable(Chip)) – an iterable of chips

Raises:

SpinnMachineAlreadyExistsException – If a chip with the same x and y coordinates as one being added already exists

Add FPGA links that are on a given machine depending on the version of the board.

Add SpiNNaker links that are on a given machine depending on the version of the board.

property boot_chip: Chip

The chip used to boot the machine.

Return type:

Chip

property chip_coordinates: Iterator[Tuple[int, int]]

An iterable of chip coordinates in the machine.

Return type:

iterable(tuple(int,int))

property chips: Iterator[Chip]

An iterable of chips in the machine.

Return type:

iterable(Chip)

abstract concentric_xys(radius: int, start: Tuple[int, int]) Iterable[Tuple[int, int]][source]

A generator that produces coordinates for concentric rings of possible chips based on the links of the chips.

No check is done to see if the chip exists. This may even produce coordinates with negative numbers

Mostly copied from: https://github.com/project-rig/rig/blob/master/rig/geometry.py

Parameters:
  • radius (int) – The radius of rings to produce (0 = start only)

  • start (tuple(int,int)) – The start coordinate

Return type:

iterable(tuple(int,int))

property ethernet_connected_chips: Sequence[Chip]

The chips in the machine that have an Ethernet connection.

Return type:

iterable(Chip)

get_chip_at(x: int, y: int) Chip | None[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:

Chip or None

get_chips_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Chip][source]

Yields the actual chips on the board with this Ethernet-enabled chip. Including the Ethernet-enabled chip itself.

Wrap-arounds are handled as appropriate.

This method does check if the chip actually exists.

Parameters:
  • ethernet_x (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled chip

Returns:

Yields the chips on this board.

Return type:

iterable(Chip)

get_cores_count() int[source]

Get the number of cores from the machine.

Returns:

n_cores

Return type:

int

abstract get_down_xys_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[int, int]][source]

Yields the (x,y) coordinates of the down chips on the board with this Ethernet-enabled chip.

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 (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled chip

Returns:

Yields the (x, y) of the down chips on this board.

Return type:

iterable(tuple(int,int))

abstract get_existing_xys_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[int, int]][source]

Yields the (x,y)s of actual chips on the board with this Ethernet-enabled chip. Including the Ethernet-enabled chip itself.

Wrap-arounds are handled as appropriate.

This method does check if the chip actually exists.

Parameters:
  • ethernet_x (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled chip

Returns:

Yields the (x,y)s of chips on this board.

Return type:

iterable(tuple(int,int))

get_existing_xys_on_board(chip: Chip) Iterable[XY][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 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 or None) – optional board address that this FPGA link is associated with. This is ignored if chip_coords is not None. If this is None and chip_coords is None, the boot board will be assumed.

  • chip_coords (tuple(int, int) or None) – optional chip coordinates that this FPGA link is associated with. If this is None and board_address is None, the boot board will be assumed.

Returns:

the given FPGA link object

Return type:

FPGALinkData

abstract get_global_xy(local_x: int, local_y: int, ethernet_x: int, ethernet_y: int) Tuple[int, int][source]

Converts the local (X, Y) coordinates into global (x,y) coordinates, under the assumption that they are on the board with local (0,0) at global coordinates (ethernet_x, ethernet_y).

This method does take wrap-arounds into consideration.

Warning

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 (int) – A valid local x coordinate for a chip

  • local_y (int) – A valid local y coordinate for a chip

  • ethernet_x (int) – The global Ethernet-enabled chip X coordinate for the board the chip is on

  • ethernet_y (int) – The global Ethernet-enabled chip Y coordinate for the board the chip is on

Returns:

global (x,y) coordinates of the chip

Return type:

tuple(int,int)

Get the number of 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:

n_links; fractional parts indicate partial link problems

Return type:

float

abstract get_local_xy(chip: Chip) XY[source]

Converts the x and y coordinates into the local coordinates on the board as if the Ethernet-enabled chip 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 (Chip) – A Chip in the machine

Returns:

Local (x, y) coordinates.

Return type:

tuple(int,int)

Get a SpiNNaker link with a given ID.

Parameters:
  • spinnaker_link_id (int) – The ID of the link

  • board_address (str or None) – optional board address that this SpiNNaker link is associated with. This is ignored if chip_coords is not None. If this is None and chip_coords is None, the boot board will be assumed.

  • chip_coords (tuple(int, int) or None) – optional chip coordinates that this SpiNNaker link is associated with. If this is None and board_address is None, the boot board will be assumed.

Returns:

The SpiNNaker link data

Return type:

SpinnakerLinkData

get_unused_xy() Tuple[int, int][source]

Finds an unused (x,y) coordinate on this machine.

This method will not return an (x,y) of an existing chip

This method will not return an (x,y) on any existing board even if that chip does not exist, i.e., it will not return (x,y) of a known dead chip.

It will however return the same unused_xy until a chip is added at that location.

Returns:

an unused (x,y) coordinate

Return type:

(int, int)

abstract get_vector(source: Tuple[int, int], destination: Tuple[int, int]) Tuple[int, int, int][source]

Get mathematical shortest vector (x, y, z) from source to destination. The z direction uses the diagonal inter-chip links; (0,0,1) is equivalent to (1,1,0) in terms of where it reaches but uses a more efficient route.

This method does not check if the chips and links it assumes to take actually exist. For example long paths along a non-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 (tuple(int, int)) – (x,y) coordinates of the source chip

  • destination (tuple(int, int)) – (x,y) coordinates of the destination chip

Returns:

The vector

abstract get_vector_length(source: Tuple[int, int], destination: Tuple[int, int]) int[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 non-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.

Warning

GIGO: This method does not check if input parameters make sense.

Parameters:
  • source (tuple(int, int)) – (x,y) coordinates of the source chip

  • destination (tuple(int, int)) – (x,y) coordinates of the destination chip

Returns:

The distance in steps

Return type:

int

abstract get_xy_cores_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[Tuple[int, int], int]][source]

Yields the potential (x,y) locations and the typical number of cores of all the chips on the board with this Ethernet-enabled chip.

Includes the Ethernet-enabled 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 (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled 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 typical number of cores for a chip in that position.

Return type:

iterable(tuple(tuple(int,int),int))

abstract get_xys_by_ethernet(ethernet_x: int, ethernet_y: int) Iterable[Tuple[int, int]][source]

Yields the potential x,y locations of all the chips on the board with this Ethernet-enabled chip. Including the Ethernet-enabled 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 (int) – The X coordinate of a (local 0,0) legal Ethernet-enabled chip

  • ethernet_y (int) – The Y coordinate of a (local 0,0) legal Ethernet-enabled chip

Returns:

Yields the (x, y) coordinates of all the potential chips on this board.

Return type:

iterable(tuple(int,int))

property height: int

The height of the machine, in chips.

Return type:

int

is_chip_at(x: int, y: int) bool[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

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

property local_xys: Iterable[Tuple[int, int]]

Provides a list of local (x,y) coordinates 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).

Return type:

iterable(tuple(int,int))

property min_n_router_enteries: int

The minimum number of router_enteries found on any Chip

Returns:

The lowest n router entry found on any Router

Return type:

int

abstract multiple_48_chip_boards() bool[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-enabled chip.

Returns:

True if this machine can have multiple 48 chip boards

Return type:

bool

property n_chips: int

The number of chips in the machine.

Return type:

int

Return type:

iterable(tuple(int,int,int))

The set of SpiNNaker links in the machine.

Return type:

iterable(tuple(tuple(str,int), SpinnakerLinkData))

summary_string() str[source]

Gets a summary of the Machine and logs warnings for weirdness

Returns:

A String describing the Machine

Raises:
property total_available_user_cores: int

The total number of cores on the machine which are not monitor cores.

Return type:

int

property total_cores: int

The total number of cores on the machine, including monitors.

Return type:

int

unreachable_incoming_chips() List[Tuple[int, int]][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) coordinates of unreachable chips.

Return type:

list(tuple(int,int))

unreachable_incoming_local_chips() List[Tuple[int, int]][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) coordinates of unreachable chips.

Return type:

list(tuple(int,int))

unreachable_outgoing_chips() List[Tuple[int, int]][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) coordinates of unreachable chips.

Return type:

list(tuple(int,int))

unreachable_outgoing_local_chips() List[Tuple[int, int]][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) coordinates of unreachable chips.

Return type:

list(tuple(int,int))

validate() None[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)

Raises:

SpinnMachineException

  • An Error is raised if there is a chip with a x outside of the range 0 to width -1.

  • An Error is raised if there is a chip with a y outside of the range 0 to height -1.

  • An Error is raise if there is no chip at the declared Ethernet-enabled chip x and y.

  • An Error is raised if an Ethernet-enabled chip is not at a local 0,0.

  • An Error is raised if there is no Ethernet-enabled chip is at 0,0.

  • An Error is raised if this is a unexpected multiple board situation.

where_is_chip(chip: Chip) str[source]

Returns global and local location for this chip.

This method assumes that chip is on the machine or is a copy of a chip on the machine.

Parameters:

chip (Chip) – A Chip in the machine

Returns:

A human-readable description of the location of a chip.

Return type:

str

where_is_xy(x: int, y: int) str[source]

Returns global and local location for this chip.

Parameters:
  • x (int) – X coordinate

  • y (int) – Y coordinate

Returns:

A human-readable description of the location of a chip.

Return type:

str

property width: int

The width of the machine, in chips.

Return type:

int

abstract property wrap: str

A short string representing the type of wrap.

Return type:

str

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 (int) – The x coordinate of a chip that will exist on the machine

  • y (int) – The y coordinate of a chip that will exist on the machine

  • link (int) – 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: int, mask: int, *, processor_ids: Iterable[int], link_ids: Iterable[int], defaultable: bool = False, spinnaker_route: None = None)[source]
class spinn_machine.MulticastRoutingEntry(routing_entry_key: int, mask: int, *, processor_ids: None = None, link_ids: None = None, defaultable: bool = False, spinnaker_route: int)

Bases: object

Represents an entry in a SpiNNaker chip’s multicast routing table. There can be up to 1024 such entries per chip, but some may be reserved for system purposes.

Note

The processor_ids and link_ids parameters are only optional if a spinnaker_route is provided. If a spinnaker_route is provided the processor_ids and link_ids parameters are ignored.

Parameters:
  • routing_entry_key (int) – The routing key_combo

  • mask (int) – The route key_combo mask

  • processor_ids (iterable(int) or None) – The destination processor IDs

  • link_ids (iterable(int) or None) – The destination link IDs

  • defaultable (bool) – If this entry is defaultable (it receives packets from its directly opposite route position)

  • spinnaker_route (int or None) – The processor_ids and link_ids expressed as a single int.

Raises:
property defaultable: bool

Whether this entry is a defaultable entry. An entry is defaultable if it is duplicating the default behaviour of the SpiNNaker router (to pass a message out on the link opposite from where it was received, without routing it to any processors; source and destination chips for a message cannot be defaultable).

Return type:

bool

The destination link IDs.

Return type:

frozenset(int)

property mask: int

The routing mask.

Return type:

int

merge(other: MulticastRoutingEntry) MulticastRoutingEntry[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 (MulticastRoutingEntry) – The multicast entry to merge with this entry

Returns:

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

property processor_ids: FrozenSet[int]

The destination processor IDs.

Return type:

frozenset(int)

property routing_entry_key: int

The routing key.

Return type:

int

property spinnaker_route: int

The encoded SpiNNaker route.

Return type:

int

class spinn_machine.Processor(processor_id: int, clock_speed: int = 200000000, is_monitor: bool = False, dtcm_available: int = 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
property clock_speed: int

The clock speed of the processor in cycles per second.

Return type:

int

property cpu_cycles_available: int

The number of CPU cycles available from this processor per ms.

Return type:

int

property dtcm_available: int

The amount of DTCM available on this processor.

Return type:

int

static factory(processor_id: int, is_monitor: bool = False) Processor[source]
property is_monitor: bool

Determines if the processor is the monitor, and therefore not to be allocated.

Warning

Currently rejection processors are also marked as monitors.

Return type:

bool

property processor_id: int

The ID of the processor.

Return type:

int

class spinn_machine.Router(links: Iterable[Link], n_available_multicast_entries: int)[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

  • n_available_multicast_entries (int) – The number of entries available in the routing table

Raises:

SpinnMachineAlreadyExistsException – If any two links have the same source_link_id

MAX_CORES_PER_ROUTER = 18

Add a link to the router of the chip.

Parameters:

link (Link) – The link to be added

Raises:

SpinnMachineAlreadyExistsException – If another link already exists with the same source_link_id

static convert_routing_table_entry_to_spinnaker_route(routing_table_entry: MulticastRoutingEntry | FixedRouteEntry) int[source]

Convert a routing table entry represented in software to a binary routing table entry usable on the machine.

Parameters:

routing_table_entry (MulticastRoutingEntry or FixedRouteEntry) – The entry to convert

Return type:

int

static convert_spinnaker_route_to_routing_ids(route: int) Tuple[List[int], List[int]][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))

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 or None

get_neighbouring_chips_coords() List[Dict[str, int]][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))

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

The available links of this router.

Return type:

iterable(Link)

property n_available_multicast_entries: int

The number of available multicast entries in the routing tables.

Return type:

int

static opposite(link_id: int) int[source]

Given a valid link_id this method returns its opposite.

GIGO: this method assumes the input is valid. No verification is done

Parameters:

link_id (int) – A valid link_id

Returns:

The link_id for the opposite direction

Return type:

int

class spinn_machine.SpiNNakerTriadGeometry(triad_width: int, triad_height: int, board_width: int, board_height: int, roots: Sequence[Tuple[int, int]], centre: Tuple[float, float])[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

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

  • board_width (int) – width of a board in chips

  • board_height (int) – height of a board in chips

  • roots (list(tuple(int, int))) – locations of the Ethernet connected chips

  • centre (tuple(float, float)) –

    the distance from each Ethernet chip to the centre of the hexagon

    Note

    This is the theoretical centre, it might not be an actual chip

get_ethernet_chip_coordinates(x: int, y: int, width: int, height: int, root_x: int = 0, root_y: int = 0) Tuple[int, int][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: int, y: int, root_x: int = 0, root_y: int = 0) Tuple[int, int][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: int, height: int) Sequence[Tuple[int, int]][source]

Get the coordinates of chips that should be Ethernet chips

Parameters:
  • width (int) – The width of the machine to find the chips in

  • height (int) – The height of the machine to find the chips in

Return type:

list(tuple(int, int))

static get_spinn5_geometry() SpiNNakerTriadGeometry[source]

Get the geometry object for a SpiNN-5 arrangement of boards

Returns:

a SpiNNakerTriadGeometry object.

spinn5_triad_geometry: SpiNNakerTriadGeometry | None = None
spinn_machine.virtual_machine(width: int, height: int, n_cpus_per_chip: int | None = None, validate: bool = True)[source]

Create a virtual SpiNNaker machine, used for planning execution.

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

  • validate (bool) – if True will call the machine validate function

Returns:

a virtual machine (that cannot execute code)

Return type:

Machine