7286732851

Committed 21 Dec 2023 10:08AM UTC coverage: 62.858% (+0.08%) from 62.778%

Build # 7286732851

Build Type

Pull #1425

github

Committed by

Christian-B

Commit Message

flake8

Pull Request Pull Request #1425: Overrides check

Run Details

1909 of 4477 branches covered (0.0%)

Branch coverage included in aggregate %.

323 of 344 new or added lines in 66 files covered. (93.9%)

27 existing lines in 17 files now uncovered.

12794 of 18914 relevant lines covered (67.64%)

0.68 hits per line

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

44.26

/spynnaker/pyNN/models/utility_models/delays/delay_extension_machine_vertex.py

# Copyright (c) 2016 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 __future__ import annotations
from enum import IntEnum
from typing import Sequence, TYPE_CHECKING

from spinnman.model.enums import ExecutableType
from spinn_front_end_common.interface.simulation import simulation_utilities
from spinn_front_end_common.utilities.constants import SIMULATION_N_BYTES
from spinn_utilities.overrides import overrides
from pacman.model.graphs.machine import MachineVertex
from pacman.model.resources import AbstractSDRAM
from spinn_front_end_common.interface.provenance import (
    ProvidesProvenanceDataFromMachineImpl, ProvenanceWriter)
from spinn_front_end_common.abstract_models import (
    AbstractHasAssociatedBinary, AbstractGeneratesDataSpecification)
from spynnaker.pyNN.data import SpynnakerDataView
from spynnaker.pyNN.utilities.constants import SPIKE_PARTITION_ID
from .delay_extension_vertex import DelayExtensionVertex
if TYPE_CHECKING:
    from pacman.model.placements import Placement
    from spinn_front_end_common.interface.ds import DataSpecificationGenerator


class DelayExtensionMachineVertex(
        MachineVertex, ProvidesProvenanceDataFromMachineImpl,
        AbstractHasAssociatedBinary, AbstractGeneratesDataSpecification):
    """
    Vertex that implements a delay extension.
    Not expected to be directly referenced in user code.
    """

    __slots__ = (
        "__sdram",
        "__drop_late_spikes")

    class _DELAY_EXTENSION_REGIONS(IntEnum):
        """
        Region indices.
        """
        SYSTEM = 0
        DELAY_PARAMS = 1
        PROVENANCE_REGION = 2
        TDMA_REGION = 3

    class EXTRA_PROVENANCE_DATA_ENTRIES(IntEnum):
        """
        Indices into raw provenance data about delay extension vertices.
        """
        #: The number of packets received
        N_PACKETS_RECEIVED = 0
        #: The number of packets processed
        N_PACKETS_PROCESSED = 1
        #: The number of packets added to a send queue
        N_PACKETS_ADDED = 2
        #: The number of packets sent
        N_PACKETS_SENT = 3
        #: The number of times a buffer overflowed
        N_BUFFER_OVERFLOWS = 4
        #: The number of delays
        N_DELAYS = 5
        #: The number of packets lost due to saturation
        N_PACKETS_LOST_DUE_TO_COUNT_SATURATION = 6
        #: The number of packets with bad neuron IDs
        N_PACKETS_WITH_INVALID_NEURON_IDS = 7
        #: The number of packets lost due to an invalid key
        N_PACKETS_DROPPED_DUE_TO_INVALID_KEY = 8
        #: The number of packets that arrived too late
        N_LATE_SPIKES = 9
        #: The maximum number of packets queued for background processing
        MAX_BACKGROUND_QUEUED = 10
        #: The number of times the background queue overflowed
        N_BACKGROUND_OVERLOADS = 11

    N_EXTRA_PROVENANCE_DATA_ENTRIES = len(EXTRA_PROVENANCE_DATA_ENTRIES)

    COUNT_SATURATION_NAME = "saturation_count"
    INVALID_NEURON_ID_COUNT_NAME = "invalid_neuron_count"
    INVALID_KEY_COUNT_NAME = "invalid_key_count"
    N_PACKETS_RECEIVED_NAME = "Number_of_packets_received"
    N_PACKETS_PROCESSED_NAME = "Number_of_packets_processed"
    MISMATCH_ADDED_FROM_PROCESSED_NAME = (
        "Number_of_packets_added_to_delay_slot")
    N_PACKETS_SENT_NAME = "Number_of_packets_sent"
    INPUT_BUFFER_LOST_NAME = "Times_the_input_buffer_lost_packets"
    N_LATE_SPIKES_NAME = "Number_of_late_spikes"
    DELAYED_FOR_TRAFFIC_NAME = "Number_of_times_delayed_to_spread_traffic"
    BACKGROUND_OVERLOADS_NAME = "Times_the_background_queue_overloaded"
    BACKGROUND_MAX_QUEUED_NAME = "Max_backgrounds_queued"

    def __init__(self, sdram: AbstractSDRAM, label, vertex_slice,
                 app_vertex=None):
        """
        :param ~pacman.model.resources.AbstractSDRAM sdram:
            The SDRAM required by the vertex
        :param str label: The name of the vertex
        :param ~pacman.model.graphs.common.Slice vertex_slice:
            The slice of the vertex
        :param ~pacman.model.graphs.application.ApplicationVertex app_vertex:
            The application vertex that caused this machine vertex to be
            created. If `None`, there is no such application vertex.
        """
        super().__init__(
            label, app_vertex=app_vertex, vertex_slice=vertex_slice)
        self.__sdram = sdram

    @property
    @overrides(MachineVertex.app_vertex)
    def app_vertex(self) -> DelayExtensionVertex:
        assert isinstance(self._app_vertex, DelayExtensionVertex)
        return self._app_vertex

    @property
    @overrides(ProvidesProvenanceDataFromMachineImpl._provenance_region_id)
    def _provenance_region_id(self) -> int:
        return self._DELAY_EXTENSION_REGIONS.PROVENANCE_REGION

    @property
    @overrides(
        ProvidesProvenanceDataFromMachineImpl._n_additional_data_items)
    def _n_additional_data_items(self) -> int:
        return self.N_EXTRA_PROVENANCE_DATA_ENTRIES

    @property
    @overrides(MachineVertex.sdram_required)
    def sdram_required(self) -> AbstractSDRAM:
        return self.__sdram

    @overrides(ProvidesProvenanceDataFromMachineImpl.
               parse_extra_provenance_items)
    def parse_extra_provenance_items(
            self, label: str, x: int, y: int, p: int,
            provenance_data: Sequence[int]):
        (n_received, n_processed, n_added, n_sent, n_overflows, n_delays,
         n_sat, n_bad_neuron, n_bad_keys, n_late_spikes, max_bg,
         n_bg_overloads) = provenance_data

        with ProvenanceWriter() as db:
            db.insert_core(
                x, y, p, self.COUNT_SATURATION_NAME, n_sat)
            if n_sat != 0:
                db.insert_report(
                    f"The delay extension {label} has dropped {n_sat} packets "
                    f"because during certain time steps a neuron was asked to "
                    f"spike more than 256 times. This causes a saturation on "
                    f"the count tracker which is a uint8. "
                    f"Reduce the packet rates, or modify the delay extension "
                    f"to have larger counters.")

            db.insert_core(
                x, y, p, self.INVALID_NEURON_ID_COUNT_NAME,
                n_bad_neuron)
            if n_bad_neuron != 0:
                db.insert_report(
                    f"The delay extension {label} has dropped {n_bad_neuron} "
                    f"packets because their neuron id was not valid. "
                    f"This is likely a routing issue. "
                    f"Please fix and try again")

            db.insert_core(
                x, y, p, self.INVALID_KEY_COUNT_NAME, n_bad_keys)
            if n_bad_keys != 0:
                db.insert_report(
                    f"The delay extension {label} has dropped {n_bad_keys} "
                    f"packets due to the packet key being invalid. "
                    f"This is likely a routing issue. "
                    f"Please fix and try again")

            db.insert_core(x, y, p, self.N_PACKETS_RECEIVED_NAME, n_received)

            db.insert_core(x, y, p, self.N_PACKETS_PROCESSED_NAME,
                           n_processed)
            if n_received != n_processed:
                db.insert_report(
                    f"The delay extension {label} only processed "
                    f"{n_processed} of {n_received} received packets.  "
                    f"This could indicate a fault.")

            db.insert_core(
                x, y, p, self.MISMATCH_ADDED_FROM_PROCESSED_NAME, n_added)
            if n_added != n_processed:
                db.insert_report(
                    f"The delay extension {label} only added {n_added} of "
                    f"{n_processed} processed packets.  This could indicate "
                    f"a routing or filtering fault")

            db.insert_core(x, y, p, self.N_PACKETS_SENT_NAME, n_sent)

            db.insert_core(
                x, y, p, self.INPUT_BUFFER_LOST_NAME, n_overflows)
            if n_overflows > 0:
                db.insert_report(
                    f"The input buffer for {label} lost packets on "
                    f"{n_overflows} occasions. This is often a sign that the "
                    f"system is running too quickly for the number of "
                    f"neurons per core.  "
                    f"Please increase the timer_tic or time_scale_factor "
                    f"or decrease the number of neurons per core.")

            db.insert_core(x, y, p, self.DELAYED_FOR_TRAFFIC_NAME, n_delays)

            db.insert_core(x, y, p, self.N_LATE_SPIKES_NAME, n_late_spikes)
            if n_late_spikes == 0:
                pass
            elif self.app_vertex.drop_late_spikes:
                db.insert_report(
                    f"On {label}, {n_late_spikes} packets were dropped from "
                    f"the input buffer, because they arrived too late to be "
                    f"processed in a given time step. "
                    "Try increasing the time_scale_factor located within the "
                    ".spynnaker.cfg file or in the pynn.setup() method.")
            else:
                db.insert_report(
                    f"On {label}, {n_late_spikes} packets arrived too late to "
                    f"be processed in a given time step. Try increasing the "
                    "time_scale_factor located within the .spynnaker.cfg file "
                    "or in the pynn.setup() method.")

            db.insert_core(
                x, y, p, self.BACKGROUND_MAX_QUEUED_NAME, max_bg)
            if max_bg > 1:
                db.insert_report(
                    f"On {label}, a maximum of {max_bg} background tasks "
                    f"were queued. Try increasing the time_scale_factor "
                    f"located within the .spynnaker.cfg file or in the "
                    f"pynn.setup() method.")

            db.insert_core(
                x, y, p, self.BACKGROUND_OVERLOADS_NAME, n_bg_overloads)
            if n_bg_overloads > 0:
                db.insert_report(
                    f"On {label}, the background queue overloaded "
                    f"{n_bg_overloads} times. "
                    f"Try increasing the time_scale_factor located within the "
                    ".spynnaker.cfg file or in the pynn.setup() method.")

    @overrides(MachineVertex.get_n_keys_for_partition)
    def get_n_keys_for_partition(self, partition_id: str) -> int:
        n_keys = super().get_n_keys_for_partition(partition_id)
        v = self.app_vertex
        n_colours = 2 ** v.n_colour_bits
        return n_keys * v.n_delay_stages * n_colours

    @overrides(AbstractHasAssociatedBinary.get_binary_file_name)
    def get_binary_file_name(self) -> str:
        return "delay_extension.aplx"

    @overrides(AbstractHasAssociatedBinary.get_binary_start_type)
    def get_binary_start_type(self) -> ExecutableType:
        return ExecutableType.USES_SIMULATION_INTERFACE

    @overrides(AbstractGeneratesDataSpecification.generate_data_specification)
    def generate_data_specification(
            self, spec: DataSpecificationGenerator, placement: Placement):
        vertex = placement.vertex

        # Reserve memory:
        spec.comment("\nReserving memory space for data regions:\n\n")

        # ###################################################################
        # Reserve SDRAM space for memory areas:
        delay_params_sz = self.app_vertex.delay_params_size()

        spec.reserve_memory_region(
            region=self._DELAY_EXTENSION_REGIONS.SYSTEM,
            size=SIMULATION_N_BYTES, label='setup')

        spec.reserve_memory_region(
            region=self._DELAY_EXTENSION_REGIONS.DELAY_PARAMS,
            size=delay_params_sz, label='delay_params')

        # reserve region for provenance
        self.reserve_provenance_data_region(spec)

        self._write_setup_info(spec, vertex.get_binary_file_name())

        spec.comment("\n*** Spec for Delay Extension Instance ***\n\n")

        routing_infos = SpynnakerDataView.get_routing_infos()
        key = routing_infos.get_first_key_from_pre_vertex(
            vertex, SPIKE_PARTITION_ID)

        srcs = self.app_vertex.source_vertex.splitter.get_out_going_vertices(
            SPIKE_PARTITION_ID)
        for source_vertex in srcs:
            if source_vertex.vertex_slice == self.vertex_slice:
                r_info = routing_infos.get_routing_info_from_pre_vertex(
                    source_vertex, SPIKE_PARTITION_ID)
                assert (r_info is not None)
                incoming_key = r_info.key
                incoming_mask = r_info.mask
                break

        self.write_delay_parameters(
            spec, self.vertex_slice, key, incoming_key, incoming_mask)

        # End-of-Spec:
        spec.end_specification()

    def _write_setup_info(self, spec, binary_name):
        """
        :param ~data_specification.DataSpecificationGenerator spec:
        :param str binary_name: the binary name
        """
        # Write this to the system region (to be picked up by the simulation):
        spec.switch_write_focus(self._DELAY_EXTENSION_REGIONS.SYSTEM)
        spec.write_array(simulation_utilities.get_simulation_header_array(
            binary_name))

    def write_delay_parameters(
            self, spec, vertex_slice, key, incoming_key, incoming_mask):
        """
        Generate Delay Parameter data.

        :param ~data_specification.DataSpecificationGenerator spec:
        :param ~pacman.model.graphs.common.Slice vertex_slice:
        :param int key:
        :param int incoming_key:
        :param int incoming_mask:
        """
        # pylint: disable=too-many-arguments

        # Write spec with commands to construct required delay region:
        spec.comment(
            f"Writing Delay Parameters for {vertex_slice.n_atoms} Neurons:\n")

        # Set the focus to the memory region 2 (delay parameters):
        spec.switch_write_focus(self._DELAY_EXTENSION_REGIONS.DELAY_PARAMS)

        # Write header info to the memory region:
        # Write Key info for this core and the incoming key and mask:
        if key is None:
            spec.write_value(0)
            spec.write_value(0)
        else:
            spec.write_value(1)
            spec.write_value(data=key)
        spec.write_value(data=incoming_key)
        spec.write_value(data=incoming_mask)

        # Write the number of neurons in the block:
        spec.write_value(data=vertex_slice.n_atoms)

        app_vertex = self.app_vertex
        # Write the number of blocks of delays:
        spec.write_value(data=app_vertex.n_delay_stages)

        # write the delay per delay stage
        spec.write_value(data=app_vertex.delay_per_stage)

        # write whether to throw away spikes
        spec.write_value(data=int(app_vertex.drop_late_spikes))

        # Write the number of colour bits
        spec.write_value(data=app_vertex.n_colour_bits)

1	# Copyright (c) 2016 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 __future__ import annotations	1✔
16	from enum import IntEnum	1✔
17	from typing import Sequence, TYPE_CHECKING	1✔
18
19	from spinnman.model.enums import ExecutableType	1✔
20	from spinn_front_end_common.interface.simulation import simulation_utilities	1✔
21	from spinn_front_end_common.utilities.constants import SIMULATION_N_BYTES	1✔
22	from spinn_utilities.overrides import overrides	1✔
23	from pacman.model.graphs.machine import MachineVertex	1✔
24	from pacman.model.resources import AbstractSDRAM	1✔
25	from spinn_front_end_common.interface.provenance import (	1✔
26	ProvidesProvenanceDataFromMachineImpl, ProvenanceWriter)
27	from spinn_front_end_common.abstract_models import (	1✔
28	AbstractHasAssociatedBinary, AbstractGeneratesDataSpecification)
29	from spynnaker.pyNN.data import SpynnakerDataView	1✔
30	from spynnaker.pyNN.utilities.constants import SPIKE_PARTITION_ID	1✔
31	from .delay_extension_vertex import DelayExtensionVertex	1✔
32	if TYPE_CHECKING:
33	from pacman.model.placements import Placement
34	from spinn_front_end_common.interface.ds import DataSpecificationGenerator
35
36
37	class DelayExtensionMachineVertex(	1✔
38	MachineVertex, ProvidesProvenanceDataFromMachineImpl,
39	AbstractHasAssociatedBinary, AbstractGeneratesDataSpecification):
40	"""
41	Vertex that implements a delay extension.
42	Not expected to be directly referenced in user code.
43	"""
44
45	__slots__ = (	1✔
46	"__sdram",
47	"__drop_late_spikes")
48
49	class _DELAY_EXTENSION_REGIONS(IntEnum):	1✔
50	"""
51	Region indices.
52	"""
53	SYSTEM = 0	1✔
54	DELAY_PARAMS = 1	1✔
55	PROVENANCE_REGION = 2	1✔
56	TDMA_REGION = 3	1✔
57
58	class EXTRA_PROVENANCE_DATA_ENTRIES(IntEnum):	1✔
59	"""
60	Indices into raw provenance data about delay extension vertices.
61	"""
62	#: The number of packets received
63	N_PACKETS_RECEIVED = 0	1✔
64	#: The number of packets processed
65	N_PACKETS_PROCESSED = 1	1✔
66	#: The number of packets added to a send queue
67	N_PACKETS_ADDED = 2	1✔
68	#: The number of packets sent
69	N_PACKETS_SENT = 3	1✔
70	#: The number of times a buffer overflowed
71	N_BUFFER_OVERFLOWS = 4	1✔
72	#: The number of delays
73	N_DELAYS = 5	1✔
74	#: The number of packets lost due to saturation
75	N_PACKETS_LOST_DUE_TO_COUNT_SATURATION = 6	1✔
76	#: The number of packets with bad neuron IDs
77	N_PACKETS_WITH_INVALID_NEURON_IDS = 7	1✔
78	#: The number of packets lost due to an invalid key
79	N_PACKETS_DROPPED_DUE_TO_INVALID_KEY = 8	1✔
80	#: The number of packets that arrived too late
81	N_LATE_SPIKES = 9	1✔
82	#: The maximum number of packets queued for background processing
83	MAX_BACKGROUND_QUEUED = 10	1✔
84	#: The number of times the background queue overflowed
85	N_BACKGROUND_OVERLOADS = 11	1✔
86
87	N_EXTRA_PROVENANCE_DATA_ENTRIES = len(EXTRA_PROVENANCE_DATA_ENTRIES)	1✔
88
89	COUNT_SATURATION_NAME = "saturation_count"	1✔
90	INVALID_NEURON_ID_COUNT_NAME = "invalid_neuron_count"	1✔
91	INVALID_KEY_COUNT_NAME = "invalid_key_count"	1✔
92	N_PACKETS_RECEIVED_NAME = "Number_of_packets_received"	1✔
93	N_PACKETS_PROCESSED_NAME = "Number_of_packets_processed"	1✔
94	MISMATCH_ADDED_FROM_PROCESSED_NAME = (	1✔
95	"Number_of_packets_added_to_delay_slot")
96	N_PACKETS_SENT_NAME = "Number_of_packets_sent"	1✔
97	INPUT_BUFFER_LOST_NAME = "Times_the_input_buffer_lost_packets"	1✔
98	N_LATE_SPIKES_NAME = "Number_of_late_spikes"	1✔
99	DELAYED_FOR_TRAFFIC_NAME = "Number_of_times_delayed_to_spread_traffic"	1✔
100	BACKGROUND_OVERLOADS_NAME = "Times_the_background_queue_overloaded"	1✔
101	BACKGROUND_MAX_QUEUED_NAME = "Max_backgrounds_queued"	1✔
102
103	def __init__(self, sdram: AbstractSDRAM, label, vertex_slice,	1✔
104	app_vertex=None):
105	"""
106	:param ~pacman.model.resources.AbstractSDRAM sdram:
107	The SDRAM required by the vertex
108	:param str label: The name of the vertex
109	:param ~pacman.model.graphs.common.Slice vertex_slice:
110	The slice of the vertex
111	:param ~pacman.model.graphs.application.ApplicationVertex app_vertex:
112	The application vertex that caused this machine vertex to be
113	created. If `None`, there is no such application vertex.
114	"""
115	super().__init__(	1✔
116	label, app_vertex=app_vertex, vertex_slice=vertex_slice)
117	self.__sdram = sdram	1✔
118
119	@property	1✔
120	@overrides(MachineVertex.app_vertex)	1✔
121	def app_vertex(self) -> DelayExtensionVertex:	1✔
122	assert isinstance(self._app_vertex, DelayExtensionVertex)	1✔
123	return self._app_vertex	1✔
124
125	@property	1✔
126	@overrides(ProvidesProvenanceDataFromMachineImpl._provenance_region_id)	1✔
127	def _provenance_region_id(self) -> int:	1✔
128	return self._DELAY_EXTENSION_REGIONS.PROVENANCE_REGION	×
129
130	@property	1✔
131	@overrides(	1✔
132	ProvidesProvenanceDataFromMachineImpl._n_additional_data_items)
133	def _n_additional_data_items(self) -> int:	1✔
134	return self.N_EXTRA_PROVENANCE_DATA_ENTRIES	×
135
136	@property	1✔
137	@overrides(MachineVertex.sdram_required)	1✔
138	def sdram_required(self) -> AbstractSDRAM:	1✔
139	return self.__sdram	1✔
140
141	@overrides(ProvidesProvenanceDataFromMachineImpl.	1✔
142	parse_extra_provenance_items)
143	def parse_extra_provenance_items(	1✔
144	self, label: str, x: int, y: int, p: int,
145	provenance_data: Sequence[int]):
UNCOV 146	(n_received, n_processed, n_added, n_sent, n_overflows, n_delays,	×
147	n_sat, n_bad_neuron, n_bad_keys, n_late_spikes, max_bg,
148	n_bg_overloads) = provenance_data
149
150	with ProvenanceWriter() as db:	×
151	db.insert_core(	×
152	x, y, p, self.COUNT_SATURATION_NAME, n_sat)
153	if n_sat != 0:	×
154	db.insert_report(	×
155	f"The delay extension {label} has dropped {n_sat} packets "
156	f"because during certain time steps a neuron was asked to "
157	f"spike more than 256 times. This causes a saturation on "
158	f"the count tracker which is a uint8. "
159	f"Reduce the packet rates, or modify the delay extension "
160	f"to have larger counters.")
161
162	db.insert_core(	×
163	x, y, p, self.INVALID_NEURON_ID_COUNT_NAME,
164	n_bad_neuron)
165	if n_bad_neuron != 0:	×
166	db.insert_report(	×
167	f"The delay extension {label} has dropped {n_bad_neuron} "
168	f"packets because their neuron id was not valid. "
169	f"This is likely a routing issue. "
170	f"Please fix and try again")
171
172	db.insert_core(	×
173	x, y, p, self.INVALID_KEY_COUNT_NAME, n_bad_keys)
174	if n_bad_keys != 0:	×
175	db.insert_report(	×
176	f"The delay extension {label} has dropped {n_bad_keys} "
177	f"packets due to the packet key being invalid. "
178	f"This is likely a routing issue. "
179	f"Please fix and try again")
180
181	db.insert_core(x, y, p, self.N_PACKETS_RECEIVED_NAME, n_received)	×
182
183	db.insert_core(x, y, p, self.N_PACKETS_PROCESSED_NAME,	×
184	n_processed)
185	if n_received != n_processed:	×
186	db.insert_report(	×
187	f"The delay extension {label} only processed "
188	f"{n_processed} of {n_received} received packets. "
189	f"This could indicate a fault.")
190
191	db.insert_core(	×
192	x, y, p, self.MISMATCH_ADDED_FROM_PROCESSED_NAME, n_added)
193	if n_added != n_processed:	×
194	db.insert_report(	×
195	f"The delay extension {label} only added {n_added} of "
196	f"{n_processed} processed packets. This could indicate "
197	f"a routing or filtering fault")
198
199	db.insert_core(x, y, p, self.N_PACKETS_SENT_NAME, n_sent)	×
200
201	db.insert_core(	×
202	x, y, p, self.INPUT_BUFFER_LOST_NAME, n_overflows)
203	if n_overflows > 0:	×
204	db.insert_report(	×
205	f"The input buffer for {label} lost packets on "
206	f"{n_overflows} occasions. This is often a sign that the "
207	f"system is running too quickly for the number of "
208	f"neurons per core. "
209	f"Please increase the timer_tic or time_scale_factor "
210	f"or decrease the number of neurons per core.")
211
212	db.insert_core(x, y, p, self.DELAYED_FOR_TRAFFIC_NAME, n_delays)	×
213
214	db.insert_core(x, y, p, self.N_LATE_SPIKES_NAME, n_late_spikes)	×
215	if n_late_spikes == 0:	×
216	pass	×
NEW 217	elif self.app_vertex.drop_late_spikes:	×
218	db.insert_report(	×
219	f"On {label}, {n_late_spikes} packets were dropped from "
220	f"the input buffer, because they arrived too late to be "
221	f"processed in a given time step. "
222	"Try increasing the time_scale_factor located within the "
223	".spynnaker.cfg file or in the pynn.setup() method.")
224	else:
225	db.insert_report(	×
226	f"On {label}, {n_late_spikes} packets arrived too late to "
227	f"be processed in a given time step. Try increasing the "
228	"time_scale_factor located within the .spynnaker.cfg file "
229	"or in the pynn.setup() method.")
230
231	db.insert_core(	×
232	x, y, p, self.BACKGROUND_MAX_QUEUED_NAME, max_bg)
233	if max_bg > 1:	×
234	db.insert_report(	×
235	f"On {label}, a maximum of {max_bg} background tasks "
236	f"were queued. Try increasing the time_scale_factor "
237	f"located within the .spynnaker.cfg file or in the "
238	f"pynn.setup() method.")
239
240	db.insert_core(	×
241	x, y, p, self.BACKGROUND_OVERLOADS_NAME, n_bg_overloads)
242	if n_bg_overloads > 0:	×
243	db.insert_report(	×
244	f"On {label}, the background queue overloaded "
245	f"{n_bg_overloads} times. "
246	f"Try increasing the time_scale_factor located within the "
247	".spynnaker.cfg file or in the pynn.setup() method.")
248
249	@overrides(MachineVertex.get_n_keys_for_partition)	1✔
250	def get_n_keys_for_partition(self, partition_id: str) -> int:	1✔
251	n_keys = super().get_n_keys_for_partition(partition_id)	1✔
252	v = self.app_vertex	1✔
253	n_colours = 2 ** v.n_colour_bits	1✔
254	return n_keys * v.n_delay_stages * n_colours	1✔
255
256	@overrides(AbstractHasAssociatedBinary.get_binary_file_name)	1✔
257	def get_binary_file_name(self) -> str:	1✔
258	return "delay_extension.aplx"	×
259
260	@overrides(AbstractHasAssociatedBinary.get_binary_start_type)	1✔
261	def get_binary_start_type(self) -> ExecutableType:	1✔
262	return ExecutableType.USES_SIMULATION_INTERFACE	×
263
264	@overrides(AbstractGeneratesDataSpecification.generate_data_specification)	1✔
265	def generate_data_specification(	1✔
266	self, spec: DataSpecificationGenerator, placement: Placement):
UNCOV 267	vertex = placement.vertex	×
268
269	# Reserve memory:
270	spec.comment("\nReserving memory space for data regions:\n\n")	×
271
272	# ###################################################################
273	# Reserve SDRAM space for memory areas:
NEW 274	delay_params_sz = self.app_vertex.delay_params_size()	×
275
276	spec.reserve_memory_region(	×
277	region=self._DELAY_EXTENSION_REGIONS.SYSTEM,
278	size=SIMULATION_N_BYTES, label='setup')
279
280	spec.reserve_memory_region(	×
281	region=self._DELAY_EXTENSION_REGIONS.DELAY_PARAMS,
282	size=delay_params_sz, label='delay_params')
283
284	# reserve region for provenance
285	self.reserve_provenance_data_region(spec)	×
286
287	self._write_setup_info(spec, vertex.get_binary_file_name())	×
288
289	spec.comment("\n* Spec for Delay Extension Instance *\n\n")	×
290
291	routing_infos = SpynnakerDataView.get_routing_infos()	×
292	key = routing_infos.get_first_key_from_pre_vertex(	×
293	vertex, SPIKE_PARTITION_ID)
294
295	srcs = self.app_vertex.source_vertex.splitter.get_out_going_vertices(	×
296	SPIKE_PARTITION_ID)
297	for source_vertex in srcs:	×
298	if source_vertex.vertex_slice == self.vertex_slice:	×
299	r_info = routing_infos.get_routing_info_from_pre_vertex(	×
300	source_vertex, SPIKE_PARTITION_ID)
NEW 301	assert (r_info is not None)	×
302	incoming_key = r_info.key	×
303	incoming_mask = r_info.mask	×
304	break	×
305
306	self.write_delay_parameters(	×
307	spec, self.vertex_slice, key, incoming_key, incoming_mask)
308
309	# End-of-Spec:
310	spec.end_specification()	×
311
312	def _write_setup_info(self, spec, binary_name):	1✔
313	"""
314	:param ~data_specification.DataSpecificationGenerator spec:
315	:param str binary_name: the binary name
316	"""
317	# Write this to the system region (to be picked up by the simulation):
318	spec.switch_write_focus(self._DELAY_EXTENSION_REGIONS.SYSTEM)	×
319	spec.write_array(simulation_utilities.get_simulation_header_array(	×
320	binary_name))
321
322	def write_delay_parameters(	1✔
323	self, spec, vertex_slice, key, incoming_key, incoming_mask):
324	"""
325	Generate Delay Parameter data.
326
327	:param ~data_specification.DataSpecificationGenerator spec:
328	:param ~pacman.model.graphs.common.Slice vertex_slice:
329	:param int key:
330	:param int incoming_key:
331	:param int incoming_mask:
332	"""
333	# pylint: disable=too-many-arguments
334
335	# Write spec with commands to construct required delay region:
336	spec.comment(	×
337	f"Writing Delay Parameters for {vertex_slice.n_atoms} Neurons:\n")
338
339	# Set the focus to the memory region 2 (delay parameters):
340	spec.switch_write_focus(self._DELAY_EXTENSION_REGIONS.DELAY_PARAMS)	×
341
342	# Write header info to the memory region:
343	# Write Key info for this core and the incoming key and mask:
344	if key is None:	×
345	spec.write_value(0)	×
346	spec.write_value(0)	×
347	else:
348	spec.write_value(1)	×
349	spec.write_value(data=key)	×
350	spec.write_value(data=incoming_key)	×
351	spec.write_value(data=incoming_mask)	×
352
353	# Write the number of neurons in the block:
354	spec.write_value(data=vertex_slice.n_atoms)	×
355
NEW 356	app_vertex = self.app_vertex	×
357	# Write the number of blocks of delays:
NEW 358	spec.write_value(data=app_vertex.n_delay_stages)	×
359
360	# write the delay per delay stage
NEW 361	spec.write_value(data=app_vertex.delay_per_stage)	×
362
363	# write whether to throw away spikes
NEW 364	spec.write_value(data=int(app_vertex.drop_late_spikes))	×
365
366	# Write the number of colour bits
NEW 367	spec.write_value(data=app_vertex.n_colour_bits)	×

SpiNNakerManchester / sPyNNaker / 7286732851

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