7018423533

Committed 28 Nov 2023 12:01PM UTC coverage: 62.806% (-0.3%) from 63.082%

Build # 7018423533

Build Type

Pull #1334

github

Committed by

rowleya

Commit Message

Make this work properly

Pull Request Pull Request #1334: Spif 1d

Run Details

1910 of 4463 branches covered (0.0%)

Branch coverage included in aggregate %.

43 of 136 new or added lines in 3 files covered. (31.62%)

25 existing lines in 1 file now uncovered.

12708 of 18812 relevant lines covered (67.55%)

0.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

27.27

/spynnaker/pyNN/external_devices_models/spif_output_device.py

# Copyright (c) 2022 The University of Manchester
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from typing import Dict, Iterable, Tuple
from spinn_utilities.overrides import overrides
from spinn_utilities.config_holder import set_config
from pacman.model.graphs.application import (
    ApplicationFPGAVertex, FPGAConnection)
from pacman.model.graphs.machine import MachineVertex
from spinn_front_end_common.abstract_models import (
    AbstractSendMeMulticastCommandsVertex, LiveOutputDevice,
    HasCustomAtomKeyMap)
from spynnaker.pyNN.models.common import PopulationApplicationVertex
from spynnaker.pyNN.data.spynnaker_data_view import SpynnakerDataView
from spynnaker.pyNN.spynnaker_external_device_plugin_manager import (
    SpynnakerExternalDevicePluginManager)
from .spif_devices import (
    SPIF_FPGA_ID, SPIF_OUTPUT_FPGA_LINK,
    set_distiller_key, set_distiller_mask,
    set_distiller_mask_delayed, set_distiller_shift,
    set_xp_key_delayed, set_xp_mask_delayed)
from pacman.utilities.utility_calls import get_keys

# The maximum number of partitions that can be supported.
N_OUTGOING = 6


class SPIFOutputDevice(
        ApplicationFPGAVertex, PopulationApplicationVertex,
        AbstractSendMeMulticastCommandsVertex, LiveOutputDevice):
    """
    Output (only) to a SPIF device.  Each SPIF device can accept up to 6
    incoming projections.
    Keys sent from Populations to SPIF will be mapped by removing the
    SpiNNaker key and adding an index so that the source Population can
    be identified.  Source Populations must be split into power-of-two
    sized cores to ensure that keys are contiguous.
    The keys output by SPIF will be of the form:

         (projection_index << output_key_shift) | neuron_id

    By default, the projection index will be in the top 8 bits of the
    packet, but this can be controlled with the output_key_shift parameter.
    """

    __slots__ = ("__incoming_partitions", "__create_database",
                 "__output_key_shift", "__output_key_and_mask")

    def __init__(self, board_address=None, chip_coords=None, label=None,
                 create_database=True, database_notify_host=None,
                 database_notify_port_num=None, database_ack_port_num=None,
                 output_key_shift=24):
        """
        :param board_address: The board IP address of the SPIF device
        :type board_address: int or None
        :param chip_coords: The chip coordinates of the SPIF device
        :type chip_coords: tuple(int, int) or None
        :param label: The label to give the SPIF device
        :type label: int or None
        :param bool create_database:
            Whether the database will be used to decode keys or not
        :param database_notify_host: The host that will read the database
        :type database_notify_host: str or None
        :param database_notify_port_num:
            The port of the host that will read the database
        :type database_notify_port_num: int or None
        :param database_ack_port_num:
            The port to listen on for responses from the host reading the
            database
        :type database_ack_port_num: int or None
        :param int proj_index_shift:
            The shift to apply to the population indices when added to the key
        """
        super(SPIFOutputDevice, self).__init__(
            n_atoms=1,
            outgoing_fpga_connection=FPGAConnection(
                SPIF_FPGA_ID, SPIF_OUTPUT_FPGA_LINK, board_address,
                chip_coords),
            label=label)
        self.__incoming_partitions = list()
        # Force creation of the database, to be used in the read side of things
        if create_database:
            set_config("Database", "create_database", "True")
            SpynnakerExternalDevicePluginManager.add_database_socket_address(
                database_notify_host, database_notify_port_num,
                database_ack_port_num)
        self.__create_database = create_database
        self.__output_key_shift = output_key_shift
        self.__output_key_and_mask = dict()

    def set_output_key_and_mask(self, population, key, mask):
        """ Set the output key to be written into packets when received by
            SPIF, and the mask to apply before adding the key.  The key should
            be the exact value that will be "or'ed" with the packet after
            masking.  The mask should be the mask to apply to the incoming
            SpiNNaker key to extract the neuron id bits.  The key and mask
            will not be checked; please make sure you are using values that
            make sense!

        :param Population population: The PyNN source Population
        :param int key: The key to "or" with the incoming key *after* masking
        :param int mask: The mask to "and" with the incoming SpiNNaker key
        """
        # pylint: disable=protected-access
        self.__output_key_and_mask[population._vertex] = (key, mask)

    def __is_power_of_2(self, v):
        """ Determine if a value is a power of 2.

        :param int v: The value to test
        :rtype: bool
        """
        return (v & (v - 1) == 0) and (v != 0)

    @overrides(ApplicationFPGAVertex.add_incoming_edge)
    def add_incoming_edge(self, edge, partition):
        if len(self.__incoming_partitions) >= N_OUTGOING:
            raise ValueError(
                f"Only {N_OUTGOING} outgoing connections are supported per"
                " spif device (existing partitions:"
                f" {self.__incoming_partitions}")
        # Ensure the incoming thing is split appropriately, as otherwise keys
        # won't be correct
        max_atoms = partition.pre_vertex.get_max_atoms_per_core()
        if max_atoms < partition.pre_vertex.n_atoms:
            if not self.__is_power_of_2(max_atoms):
                raise ValueError(
                    "The incoming vertex will be split into units of"
                    f" {max_atoms}, which means that the keys won't be"
                    " contiguous.  Please choose a power-of-two size for the"
                    " maximum atoms per core")
        self.__incoming_partitions.append(partition)
        if self.__create_database and len(self.__incoming_partitions) == 1:
            SpynnakerDataView.add_live_output_device(self)

    def _get_set_key_payload(self, index):
        """
        Get the payload for the command to set the router key.

        :param int index: The index of key to get
        :rtype: int
        """
        r_infos = SpynnakerDataView.get_routing_infos()
        return r_infos.get_first_key_from_pre_vertex(
            self.__incoming_partitions[index].pre_vertex,
            self.__incoming_partitions[index].identifier)

    def _get_set_mask_payload(self, index):
        """
        Get the payload for the command to set the router mask.

        :param int index: The index of the mask to get
        :rtype: int
        """
        r_infos = SpynnakerDataView.get_routing_infos()
        return r_infos.get_routing_info_from_pre_vertex(
            self.__incoming_partitions[index].pre_vertex,
            self.__incoming_partitions[index].identifier).mask

    def _get_set_dist_mask_payload(self, index):
        """ Get the payload for the command to set the distiller mask
        """
        r_infos = SpynnakerDataView.get_routing_infos()
        return ~r_infos.get_routing_info_from_pre_vertex(
            self.__incoming_partitions[index].pre_vertex,
            self.__incoming_partitions[index].identifier).mask & 0xFFFFFFFF

    @property
    @overrides(AbstractSendMeMulticastCommandsVertex.start_resume_commands)
    def start_resume_commands(self):
        # The commands here are delayed, as at the time of providing them,
        # we don't know the key or mask of the incoming link...
        commands = list()
        for i, part in enumerate(self.__incoming_partitions):
            commands.append(set_xp_key_delayed(i, self._get_set_key_payload))
            commands.append(set_xp_mask_delayed(i, self._get_set_mask_payload))
            if part.pre_vertex in self.__output_key_and_mask:
                key, mask = self.__output_key_and_mask[part.pre_vertex]
                commands.append(set_distiller_key(i, key))
                commands.append(set_distiller_mask(i, mask))
            else:
                commands.append(set_distiller_key(
                    i, i << self.__output_key_shift))
                commands.append(set_distiller_mask_delayed(
                    i, self._get_set_dist_mask_payload))
            commands.append(set_distiller_shift(
                i, part.pre_vertex.n_colour_bits))
        return commands

    @property
    @overrides(AbstractSendMeMulticastCommandsVertex.pause_stop_commands)
    def pause_stop_commands(self):
        return []

    @property
    @overrides(AbstractSendMeMulticastCommandsVertex.timed_commands)
    def timed_commands(self):
        return []

    @overrides(LiveOutputDevice.get_device_output_keys)
    def get_device_output_keys(self) -> Dict[MachineVertex, Tuple[int, int]]:
        all_keys: dict[MachineVertex, Tuple[int, int]] = dict()
        routing_infos = SpynnakerDataView.get_routing_infos()
        for i, part in enumerate(self.__incoming_partitions):
            if part.pre_vertex in self.__output_key_and_mask:
                key, mask = self.__output_key_and_mask[part.pre_vertex]
            else:
                key = i << self.__output_key_shift
                mask = self._get_set_dist_mask_payload(i)
            shift = part.pre_vertex.n_colour_bits
            for m_vertex in part.pre_vertex.get_out_going_vertices(
                    part.identifier):
                atom_keys: Iterable[Tuple[int, int]] = list()
                if isinstance(m_vertex.app_vertex, HasCustomAtomKeyMap):
                    atom_keys = m_vertex.app_vertex.get_atom_key_map(
                        m_vertex, part.identifier, routing_infos)
                else:
                    r_info = routing_infos.get_routing_info_from_pre_vertex(
                        m_vertex, part.identifier)
                    # r_info could be None if there are no outgoing edges,
                    # at which point there is nothing to do here anyway
                    if r_info is not None:
                        vertex_slice = m_vertex.vertex_slice
                        keys = get_keys(r_info.key, vertex_slice)
                        start = vertex_slice.lo_atom
                        atom_keys = [(i, k) for i, k in enumerate(keys, start)]

                atom_keys_mapped = [(i, key | ((k & mask) >> shift))
                                    for i, k in atom_keys]
                all_keys[m_vertex] = atom_keys_mapped
        return all_keys

1	# Copyright (c) 2022 The University of Manchester
2	#
3	# Licensed under the Apache License, Version 2.0 (the "License");
4	# you may not use this file except in compliance with the License.
5	# You may obtain a copy of the License at
6	#
7	# https://www.apache.org/licenses/LICENSE-2.0
8	#
9	# Unless required by applicable law or agreed to in writing, software
10	# distributed under the License is distributed on an "AS IS" BASIS,
11	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	# See the License for the specific language governing permissions and
13	# limitations under the License.
14
15	from typing import Dict, Iterable, Tuple	1✔
16	from spinn_utilities.overrides import overrides	1✔
17	from spinn_utilities.config_holder import set_config	1✔
18	from pacman.model.graphs.application import (	1✔
19	ApplicationFPGAVertex, FPGAConnection)
20	from pacman.model.graphs.machine import MachineVertex	1✔
21	from spinn_front_end_common.abstract_models import (	1✔
22	AbstractSendMeMulticastCommandsVertex, LiveOutputDevice,
23	HasCustomAtomKeyMap)
24	from spynnaker.pyNN.models.common import PopulationApplicationVertex	1✔
25	from spynnaker.pyNN.data.spynnaker_data_view import SpynnakerDataView	1✔
26	from spynnaker.pyNN.spynnaker_external_device_plugin_manager import (	1✔
27	SpynnakerExternalDevicePluginManager)
28	from .spif_devices import (	1✔
29	SPIF_FPGA_ID, SPIF_OUTPUT_FPGA_LINK,
30	set_distiller_key, set_distiller_mask,
31	set_distiller_mask_delayed, set_distiller_shift,
32	set_xp_key_delayed, set_xp_mask_delayed)
33	from pacman.utilities.utility_calls import get_keys	1✔
34
35	# The maximum number of partitions that can be supported.
36	N_OUTGOING = 6	1✔
37
38
39	class SPIFOutputDevice(	1✔
40	ApplicationFPGAVertex, PopulationApplicationVertex,
41	AbstractSendMeMulticastCommandsVertex, LiveOutputDevice):
42	"""
43	Output (only) to a SPIF device. Each SPIF device can accept up to 6
44	incoming projections.
45	Keys sent from Populations to SPIF will be mapped by removing the
46	SpiNNaker key and adding an index so that the source Population can
47	be identified. Source Populations must be split into power-of-two
48	sized cores to ensure that keys are contiguous.
49	The keys output by SPIF will be of the form:
50
51	(projection_index << output_key_shift) \| neuron_id
52
53	By default, the projection index will be in the top 8 bits of the
54	packet, but this can be controlled with the output_key_shift parameter.
55	"""
56
57	__slots__ = ("__incoming_partitions", "__create_database",	1✔
58	"__output_key_shift", "__output_key_and_mask")
59
60	def __init__(self, board_address=None, chip_coords=None, label=None,	1✔
61	create_database=True, database_notify_host=None,
62	database_notify_port_num=None, database_ack_port_num=None,
63	output_key_shift=24):
64	"""
65	:param board_address: The board IP address of the SPIF device
66	:type board_address: int or None
67	:param chip_coords: The chip coordinates of the SPIF device
68	:type chip_coords: tuple(int, int) or None
69	:param label: The label to give the SPIF device
70	:type label: int or None
71	:param bool create_database:
72	Whether the database will be used to decode keys or not
73	:param database_notify_host: The host that will read the database
74	:type database_notify_host: str or None
75	:param database_notify_port_num:
76	The port of the host that will read the database
77	:type database_notify_port_num: int or None
78	:param database_ack_port_num:
79	The port to listen on for responses from the host reading the
80	database
81	:type database_ack_port_num: int or None
82	:param int proj_index_shift:
83	The shift to apply to the population indices when added to the key
84	"""
UNCOV 85	super(SPIFOutputDevice, self).__init__(	×
86	n_atoms=1,
87	outgoing_fpga_connection=FPGAConnection(
88	SPIF_FPGA_ID, SPIF_OUTPUT_FPGA_LINK, board_address,
89	chip_coords),
90	label=label)
UNCOV 91	self.__incoming_partitions = list()	×
92	# Force creation of the database, to be used in the read side of things
UNCOV 93	if create_database:	×
94	set_config("Database", "create_database", "True")	×
95	SpynnakerExternalDevicePluginManager.add_database_socket_address(	×
96	database_notify_host, database_notify_port_num,
97	database_ack_port_num)
UNCOV 98	self.__create_database = create_database	×
99	self.__output_key_shift = output_key_shift	×
100	self.__output_key_and_mask = dict()	×
101
102	def set_output_key_and_mask(self, population, key, mask):	1✔
103	""" Set the output key to be written into packets when received by
104	SPIF, and the mask to apply before adding the key. The key should
105	be the exact value that will be "or'ed" with the packet after
106	masking. The mask should be the mask to apply to the incoming
107	SpiNNaker key to extract the neuron id bits. The key and mask
108	will not be checked; please make sure you are using values that
109	make sense!
110
111	:param Population population: The PyNN source Population
112	:param int key: The key to "or" with the incoming key after masking
113	:param int mask: The mask to "and" with the incoming SpiNNaker key
114	"""
115	# pylint: disable=protected-access
UNCOV 116	self.__output_key_and_mask[population._vertex] = (key, mask)	×
117
118	def __is_power_of_2(self, v):	1✔
119	""" Determine if a value is a power of 2.
120
121	:param int v: The value to test
122	:rtype: bool
123	"""
UNCOV 124	return (v & (v - 1) == 0) and (v != 0)	×
125
126	@overrides(ApplicationFPGAVertex.add_incoming_edge)	1✔
127	def add_incoming_edge(self, edge, partition):	1✔
UNCOV 128	if len(self.__incoming_partitions) >= N_OUTGOING:	×
129	raise ValueError(	×
130	f"Only {N_OUTGOING} outgoing connections are supported per"
131	" spif device (existing partitions:"
132	f" {self.__incoming_partitions}")
133	# Ensure the incoming thing is split appropriately, as otherwise keys
134	# won't be correct
135	max_atoms = partition.pre_vertex.get_max_atoms_per_core()	×
136	if max_atoms < partition.pre_vertex.n_atoms:	×
137	if not self.__is_power_of_2(max_atoms):	×
138	raise ValueError(	×
139	"The incoming vertex will be split into units of"
140	f" {max_atoms}, which means that the keys won't be"
141	" contiguous. Please choose a power-of-two size for the"
142	" maximum atoms per core")
UNCOV 143	self.__incoming_partitions.append(partition)	×
NEW UNCOV 144	if self.__create_database and len(self.__incoming_partitions) == 1:	×
NEW 145	SpynnakerDataView.add_live_output_device(self)	×
146
147	def _get_set_key_payload(self, index):	1✔
148	"""
149	Get the payload for the command to set the router key.
150
151	:param int index: The index of key to get
152	:rtype: int
153	"""
154	r_infos = SpynnakerDataView.get_routing_infos()	×
155	return r_infos.get_first_key_from_pre_vertex(	×
156	self.__incoming_partitions[index].pre_vertex,
157	self.__incoming_partitions[index].identifier)
158
159	def _get_set_mask_payload(self, index):	1✔
160	"""
161	Get the payload for the command to set the router mask.
162
163	:param int index: The index of the mask to get
164	:rtype: int
165	"""
UNCOV 166	r_infos = SpynnakerDataView.get_routing_infos()	×
UNCOV 167	return r_infos.get_routing_info_from_pre_vertex(	×
168	self.__incoming_partitions[index].pre_vertex,
169	self.__incoming_partitions[index].identifier).mask
170
171	def _get_set_dist_mask_payload(self, index):	1✔
172	""" Get the payload for the command to set the distiller mask
173	"""
UNCOV 174	r_infos = SpynnakerDataView.get_routing_infos()	×
UNCOV 175	return ~r_infos.get_routing_info_from_pre_vertex(	×
176	self.__incoming_partitions[index].pre_vertex,
177	self.__incoming_partitions[index].identifier).mask & 0xFFFFFFFF
178
179	@property	1✔
180	@overrides(AbstractSendMeMulticastCommandsVertex.start_resume_commands)	1✔
181	def start_resume_commands(self):	1✔
182	# The commands here are delayed, as at the time of providing them,
183	# we don't know the key or mask of the incoming link...
184	commands = list()	×
185	for i, part in enumerate(self.__incoming_partitions):	×
UNCOV 186	commands.append(set_xp_key_delayed(i, self._get_set_key_payload))	×
UNCOV 187	commands.append(set_xp_mask_delayed(i, self._get_set_mask_payload))	×
UNCOV 188	if part.pre_vertex in self.__output_key_and_mask:	×
UNCOV 189	key, mask = self.__output_key_and_mask[part.pre_vertex]	×
UNCOV 190	commands.append(set_distiller_key(i, key))	×
UNCOV 191	commands.append(set_distiller_mask(i, mask))	×
192	else:
UNCOV 193	commands.append(set_distiller_key(	×
194	i, i << self.__output_key_shift))
195	commands.append(set_distiller_mask_delayed(	×
196	i, self._get_set_dist_mask_payload))
197	commands.append(set_distiller_shift(	×
198	i, part.pre_vertex.n_colour_bits))
199	return commands	×
200
201	@property	1✔
202	@overrides(AbstractSendMeMulticastCommandsVertex.pause_stop_commands)	1✔
203	def pause_stop_commands(self):	1✔
UNCOV 204	return []	×
205
206	@property	1✔
207	@overrides(AbstractSendMeMulticastCommandsVertex.timed_commands)	1✔
208	def timed_commands(self):	1✔
209	return []	×
210
211	@overrides(LiveOutputDevice.get_device_output_keys)	1✔
212	def get_device_output_keys(self) -> Dict[MachineVertex, Tuple[int, int]]:	1✔
NEW UNCOV 213	all_keys: dict[MachineVertex, Tuple[int, int]] = dict()	×
NEW 214	routing_infos = SpynnakerDataView.get_routing_infos()	×
NEW UNCOV 215	for i, part in enumerate(self.__incoming_partitions):	×
NEW UNCOV 216	if part.pre_vertex in self.__output_key_and_mask:	×
NEW UNCOV 217	key, mask = self.__output_key_and_mask[part.pre_vertex]	×
218	else:
NEW 219	key = i << self.__output_key_shift	×
NEW 220	mask = self._get_set_dist_mask_payload(i)	×
NEW 221	shift = part.pre_vertex.n_colour_bits	×
NEW 222	for m_vertex in part.pre_vertex.get_out_going_vertices(	×
223	part.identifier):
NEW 224	atom_keys: Iterable[Tuple[int, int]] = list()	×
NEW 225	if isinstance(m_vertex.app_vertex, HasCustomAtomKeyMap):	×
NEW 226	atom_keys = m_vertex.app_vertex.get_atom_key_map(	×
227	m_vertex, part.identifier, routing_infos)
228	else:
NEW 229	r_info = routing_infos.get_routing_info_from_pre_vertex(	×
230	m_vertex, part.identifier)
231	# r_info could be None if there are no outgoing edges,
232	# at which point there is nothing to do here anyway
NEW 233	if r_info is not None:	×
NEW 234	vertex_slice = m_vertex.vertex_slice	×
NEW 235	keys = get_keys(r_info.key, vertex_slice)	×
NEW 236	start = vertex_slice.lo_atom	×
NEW 237	atom_keys = [(i, k) for i, k in enumerate(keys, start)]	×
238
NEW 239	atom_keys_mapped = [(i, key \| ((k & mask) >> shift))	×
240	for i, k in atom_keys]
NEW 241	all_keys[m_vertex] = atom_keys_mapped	×
NEW 242	return all_keys	×

SpiNNakerManchester / sPyNNaker / 7018423533

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous