6798499853

Committed 08 Nov 2023 12:53PM UTC coverage: 61.317% (-0.07%) from 61.383%

Build # 6798499853

Build Type

Pull #1408

github

Committed by

rowleya

Commit Message

Re-add

Pull Request Pull Request #1408: Spif Multi Output

Run Details

1930 of 4475 branches covered (0.0%)

Branch coverage included in aggregate %.

25 of 61 new or added lines in 2 files covered. (40.98%)

45 existing lines in 2 files now uncovered.

11772 of 17871 relevant lines covered (65.87%)

0.66 hits per line

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

32.05

/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 spinn_utilities.overrides import overrides
from spinn_utilities.config_holder import set_config
from pacman.model.graphs.application import (
    ApplicationFPGAVertex, FPGAConnection)
from spinn_front_end_common.abstract_models import (
    AbstractSendMeMulticastCommandsVertex)
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)

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


class SPIFOutputDevice(
        ApplicationFPGAVertex, PopulationApplicationVertex,
        AbstractSendMeMulticastCommandsVertex):
    """
    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:
            SpynnakerDataView.add_live_output_vertex(
                partition.pre_vertex, partition.identifier)

    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
        """
        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
        """
        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
    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
    def pause_stop_commands(self):
        return []

    @property
    def timed_commands(self):
        return []

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	from spinn_utilities.overrides import overrides	1✔
15	from spinn_utilities.config_holder import set_config	1✔
16	from pacman.model.graphs.application import (	1✔
17	ApplicationFPGAVertex, FPGAConnection)
18	from spinn_front_end_common.abstract_models import (	1✔
19	AbstractSendMeMulticastCommandsVertex)
20	from spynnaker.pyNN.models.common import PopulationApplicationVertex	1✔
21	from spynnaker.pyNN.data.spynnaker_data_view import SpynnakerDataView	1✔
22	from spynnaker.pyNN.spynnaker_external_device_plugin_manager import (	1✔
23	SpynnakerExternalDevicePluginManager)
24	from .spif_devices import (	1✔
25	SPIF_FPGA_ID, SPIF_OUTPUT_FPGA_LINK,
26	set_distiller_key, set_distiller_mask,
27	set_distiller_mask_delayed, set_distiller_shift,
28	set_xp_key_delayed, set_xp_mask_delayed)
29
30	# The maximum number of partitions that can be supported.
31	N_OUTGOING = 6	1✔
32
33
34	class SPIFOutputDevice(	1✔
35	ApplicationFPGAVertex, PopulationApplicationVertex,
36	AbstractSendMeMulticastCommandsVertex):
37	"""
38	Output (only) to a SPIF device. Each SPIF device can accept up to 6
39	incoming projections.
40	Keys sent from Populations to SPIF will be mapped by removing the
41	SpiNNaker key and adding an index so that the source Population can
42	be identified. Source Populations must be split into power-of-two
43	sized cores to ensure that keys are contiguous.
44	The keys output by SPIF will be of the form:
45
46	(projection_index << output_key_shift) \| neuron_id
47
48	By default, the projection index will be in the top 8 bits of the
49	packet, but this can be controlled with the output_key_shift parameter.
50	"""
51
52	__slots__ = ["__incoming_partitions", "__create_database",	1✔
53	"__output_key_shift", "__output_key_and_mask"]
54
55	def __init__(self, board_address=None, chip_coords=None, label=None,	1✔
56	create_database=True, database_notify_host=None,
57	database_notify_port_num=None, database_ack_port_num=None,
58	output_key_shift=24):
59	"""
60	:param board_address: The board IP address of the SPIF device
61	:type board_address: int or None
62	:param chip_coords: The chip coordinates of the SPIF device
63	:type chip_coords: tuple(int, int) or None
64	:param label: The label to give the SPIF device
65	:type label: int or None
66	:param bool create_database:
67	Whether the database will be used to decode keys or not
68	:param database_notify_host: The host that will read the database
69	:type database_notify_host: str or None
70	:param database_notify_port_num:
71	The port of the host that will read the database
72	:type database_notify_port_num: int or None
73	:param database_ack_port_num:
74	The port to listen on for responses from the host reading the
75	database
76	:type database_ack_port_num: int or None
77	:param int proj_index_shift:
78	The shift to apply to the population indices when added to the key
79	"""
UNCOV 80	super(SPIFOutputDevice, self).__init__(	×
81	n_atoms=1,
82	outgoing_fpga_connection=FPGAConnection(
83	SPIF_FPGA_ID, SPIF_OUTPUT_FPGA_LINK, board_address,
84	chip_coords),
85	label=label)
NEW 86	self.__incoming_partitions = list()	×
87	# Force creation of the database, to be used in the read side of things
88	if create_database:	×
89	set_config("Database", "create_database", "True")	×
90	SpynnakerExternalDevicePluginManager.add_database_socket_address(	×
91	database_notify_host, database_notify_port_num,
92	database_ack_port_num)
93	self.__create_database = create_database	×
NEW 94	self.__output_key_shift = output_key_shift	×
NEW 95	self.__output_key_and_mask = dict()	×
96
97	def set_output_key_and_mask(self, population, key, mask):	1✔
98	""" Set the output key to be written into packets when received by
99	SPIF, and the mask to apply before adding the key. The key should
100	be the exact value that will be "or'ed" with the packet after
101	masking. The mask should be the mask to apply to the incoming
102	SpiNNaker key to extract the neuron id bits. The key and mask
103	will not be checked; please make sure you are using values that
104	make sense!
105
106	:param Population population: The PyNN source Population
107	:param int key: The key to "or" with the incoming key after masking
108	:param int mask: The mask to "and" with the incoming SpiNNaker key
109	"""
110	# pylint: disable=protected-access
NEW 111	self.__output_key_and_mask[population._vertex] = (key, mask)	×
112
113	def __is_power_of_2(self, v):	1✔
114	""" Determine if a value is a power of 2.
115
116	:param int v: The value to test
117	:rtype: bool
118	"""
NEW 119	return (v & (v - 1) == 0) and (v != 0)	×
120
121	@overrides(ApplicationFPGAVertex.add_incoming_edge)	1✔
122	def add_incoming_edge(self, edge, partition):	1✔
NEW 123	if len(self.__incoming_partitions) >= N_OUTGOING:	×
124	raise ValueError(	×
125	f"Only {N_OUTGOING} outgoing connections are supported per"
126	" spif device (existing partitions:"
127	f" {self.__incoming_partitions}")
128	# Ensure the incoming thing is split appropriately, as otherwise keys
129	# won't be correct
NEW 130	max_atoms = partition.pre_vertex.get_max_atoms_per_core()	×
NEW 131	if max_atoms < partition.pre_vertex.n_atoms:	×
NEW 132	if not self.__is_power_of_2(max_atoms):	×
NEW 133	raise ValueError(	×
134	"The incoming vertex will be split into units of"
135	f" {max_atoms}, which means that the keys won't be"
136	" contiguous. Please choose a power-of-two size for the"
137	" maximum atoms per core")
NEW 138	self.__incoming_partitions.append(partition)	×
139	if self.__create_database:	×
140	SpynnakerDataView.add_live_output_vertex(	×
141	partition.pre_vertex, partition.identifier)
142
143	def _get_set_key_payload(self, index):	1✔
144	"""
145	Get the payload for the command to set the router key.
146
147	:param int index: The index of key to get
148	"""
149	r_infos = SpynnakerDataView.get_routing_infos()	×
150	return r_infos.get_first_key_from_pre_vertex(	×
151	self.__incoming_partitions[index].pre_vertex,
152	self.__incoming_partitions[index].identifier)
153
154	def _get_set_mask_payload(self, index):	1✔
155	"""
156	Get the payload for the command to set the router mask.
157
158	:param int index: The index of the mask to get
159	"""
160	r_infos = SpynnakerDataView.get_routing_infos()	×
161	return r_infos.get_routing_info_from_pre_vertex(	×
162	self.__incoming_partitions[index].pre_vertex,
163	self.__incoming_partitions[index].identifier).mask
164
165	def _get_set_dist_mask_payload(self, index):	1✔
166	""" Get the payload for the command to set the distiller mask
167	"""
NEW 168	r_infos = SpynnakerDataView.get_routing_infos()	×
NEW 169	return ~r_infos.get_routing_info_from_pre_vertex(	×
170	self.__incoming_partitions[index].pre_vertex,
171	self.__incoming_partitions[index].identifier).mask & 0xFFFFFFFF
172
173	@property	1✔
174	def start_resume_commands(self):	1✔
175	# The commands here are delayed, as at the time of providing them,
176	# we don't know the key or mask of the incoming link...
NEW 177	commands = list()	×
NEW 178	for i, part in enumerate(self.__incoming_partitions):	×
NEW 179	commands.append(set_xp_key_delayed(i, self._get_set_key_payload))	×
NEW 180	commands.append(set_xp_mask_delayed(i, self._get_set_mask_payload))	×
NEW 181	if part.pre_vertex in self.__output_key_and_mask:	×
NEW 182	key, mask = self.__output_key_and_mask[part.pre_vertex]	×
NEW 183	commands.append(set_distiller_key(i, key))	×
NEW 184	commands.append(set_distiller_mask(i, mask))	×
185	else:
NEW 186	commands.append(set_distiller_key(	×
187	i, i << self.__output_key_shift))
NEW 188	commands.append(set_distiller_mask_delayed(	×
189	i, self._get_set_dist_mask_payload))
NEW 190	commands.append(set_distiller_shift(	×
191	i, part.pre_vertex.n_colour_bits))
NEW 192	return commands	×
193
194	@property	1✔
195	def pause_stop_commands(self):	1✔
196	return []	×
197
198	@property	1✔
199	def timed_commands(self):	1✔
200	return []	×

SpiNNakerManchester / sPyNNaker / 6798499853

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