6941305697

Committed 21 Nov 2023 08:42AM UTC coverage: 63.155% (+1.6%) from 61.529%

Build # 6941305697

Build Type

Pull #1342

github

Committed by

Christian-B

Commit Message

set_not_recording indices: Optional[Collection[int]]

Pull Request Pull Request #1342: Type Annotations and Checking

Run Details

1960 of 4482 branches covered (0.0%)

Branch coverage included in aggregate %.

4149 of 5079 new or added lines in 233 files covered. (81.69%)

193 existing lines in 78 files now uncovered.

12726 of 18772 relevant lines covered (67.79%)

0.68 hits per line

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

53.52

/spynnaker/pyNN/extra_algorithms/splitter_components/splitter_poisson_delegate.py

# Copyright (c) 2020 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 List, Sequence, Tuple
from spinn_utilities.overrides import overrides
from pacman.model.graphs.machine import MachineVertex
from pacman.model.graphs.common import Slice
from pacman.model.resources import AbstractSDRAM
from pacman.model.partitioner_splitters import AbstractSplitterCommon
from pacman.exceptions import PacmanConfigurationException
from pacman.model.partitioner_splitters import SplitterFixedLegacy
from pacman.utilities.utility_objs import ChipCounter
from spynnaker.pyNN.models.spike_source import SpikeSourcePoissonVertex
from .abstract_supports_one_to_one_sdram_input import (
    AbstractSupportsOneToOneSDRAMInput)


class SplitterPoissonDelegate(SplitterFixedLegacy[SpikeSourcePoissonVertex]):
    """
    A splitter for Poisson sources that will ignore sources that are
    one-to-one connected to a single Population.
    """

    @property
    def send_over_sdram(self) -> bool:
        """
        Whether this vertex is to be sent using SDRAM.

        :rtype: bool
        """
        # If there is only one outgoing projection, and it is one-to-one
        # connected to the target, and the target knows what to do, leave
        # it to the target
        if len(self.governed_app_vertex.outgoing_projections) != 1:
            return False
        proj = self.governed_app_vertex.outgoing_projections[0]
        # pylint: disable=protected-access
        post_vertex = proj._projection_edge.post_vertex
        if not isinstance(post_vertex.splitter,
                          AbstractSupportsOneToOneSDRAMInput):
            return False
        return post_vertex.splitter.handles_source_vertex(proj)

    @overrides(SplitterFixedLegacy.set_governed_app_vertex)
    def set_governed_app_vertex(self, app_vertex: SpikeSourcePoissonVertex):
        if not isinstance(app_vertex, SpikeSourcePoissonVertex):
            raise PacmanConfigurationException(
                f"The vertex {app_vertex} cannot be supported by the "
                "SplitterPoissonDelegate as the only vertex supported by this "
                "splitter is a SpikeSourcePoissonVertex. Please use the "
                "correct splitter for your vertex and try again.")
        super().set_governed_app_vertex(app_vertex)

    @overrides(SplitterFixedLegacy.create_machine_vertices)
    def create_machine_vertices(self, chip_counter: ChipCounter):
        # If sending over SDRAM, let the target handle this
        if self.send_over_sdram:
            return

        # If we passed this part, use the super class
        super().create_machine_vertices(chip_counter)

    @overrides(AbstractSplitterCommon.get_in_coming_slices)
    def get_in_coming_slices(self) -> List[Slice]:
        if self.send_over_sdram:
            proj = self.governed_app_vertex.outgoing_projections[0]
            # pylint: disable=protected-access
            post_vertex = proj._projection_edge.post_vertex
            return list(post_vertex.splitter.get_in_coming_slices())
        return super().get_in_coming_slices()

    @overrides(AbstractSplitterCommon.get_out_going_slices)
    def get_out_going_slices(self) -> List[Slice]:
        if self.send_over_sdram:
            proj = self.governed_app_vertex.outgoing_projections[0]
            # pylint: disable=protected-access
            post_vertex = proj._projection_edge.post_vertex
            return list(post_vertex.splitter.get_out_going_slices())
        return super().get_out_going_slices()

    @overrides(AbstractSplitterCommon.get_out_going_vertices)
    def get_out_going_vertices(self, partition_id: str) -> List[MachineVertex]:
        if self.send_over_sdram:
            return []
        return super().get_out_going_vertices(partition_id)

    @overrides(AbstractSplitterCommon.get_same_chip_groups)
    def get_same_chip_groups(self) -> Sequence[
            Tuple[Sequence[MachineVertex], AbstractSDRAM]]:
        if self.send_over_sdram:
            return []
        return super().get_same_chip_groups()

1	# Copyright (c) 2020 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 typing import List, Sequence, Tuple	1✔
15	from spinn_utilities.overrides import overrides	1✔
16	from pacman.model.graphs.machine import MachineVertex	1✔
17	from pacman.model.graphs.common import Slice	1✔
18	from pacman.model.resources import AbstractSDRAM	1✔
19	from pacman.model.partitioner_splitters import AbstractSplitterCommon	1✔
20	from pacman.exceptions import PacmanConfigurationException	1✔
21	from pacman.model.partitioner_splitters import SplitterFixedLegacy	1✔
22	from pacman.utilities.utility_objs import ChipCounter	1✔
23	from spynnaker.pyNN.models.spike_source import SpikeSourcePoissonVertex	1✔
24	from .abstract_supports_one_to_one_sdram_input import (	1✔
25	AbstractSupportsOneToOneSDRAMInput)
26
27
28	class SplitterPoissonDelegate(SplitterFixedLegacy[SpikeSourcePoissonVertex]):	1✔
29	"""
30	A splitter for Poisson sources that will ignore sources that are
31	one-to-one connected to a single Population.
32	"""
33
34	@property	1✔
35	def send_over_sdram(self) -> bool:	1✔
36	"""
37	Whether this vertex is to be sent using SDRAM.
38
39	:rtype: bool
40	"""
41	# If there is only one outgoing projection, and it is one-to-one
42	# connected to the target, and the target knows what to do, leave
43	# it to the target
44	if len(self.governed_app_vertex.outgoing_projections) != 1:	1!
45	return False	1✔
46	proj = self.governed_app_vertex.outgoing_projections[0]	×
47	# pylint: disable=protected-access
48	post_vertex = proj._projection_edge.post_vertex	×
49	if not isinstance(post_vertex.splitter,	×
50	AbstractSupportsOneToOneSDRAMInput):
51	return False	×
52	return post_vertex.splitter.handles_source_vertex(proj)	×
53
54	@overrides(SplitterFixedLegacy.set_governed_app_vertex)	1✔
55	def set_governed_app_vertex(self, app_vertex: SpikeSourcePoissonVertex):	1✔
56	if not isinstance(app_vertex, SpikeSourcePoissonVertex):	1!
57	raise PacmanConfigurationException(	×
58	f"The vertex {app_vertex} cannot be supported by the "
59	"SplitterPoissonDelegate as the only vertex supported by this "
60	"splitter is a SpikeSourcePoissonVertex. Please use the "
61	"correct splitter for your vertex and try again.")
62	super().set_governed_app_vertex(app_vertex)	1✔
63
64	@overrides(SplitterFixedLegacy.create_machine_vertices)	1✔
65	def create_machine_vertices(self, chip_counter: ChipCounter):	1✔
66	# If sending over SDRAM, let the target handle this
67	if self.send_over_sdram:	1!
68	return	×
69
70	# If we passed this part, use the super class
71	super().create_machine_vertices(chip_counter)	1✔
72
73	@overrides(AbstractSplitterCommon.get_in_coming_slices)	1✔
74	def get_in_coming_slices(self) -> List[Slice]:	1✔
75	if self.send_over_sdram:	×
76	proj = self.governed_app_vertex.outgoing_projections[0]	×
77	# pylint: disable=protected-access
78	post_vertex = proj._projection_edge.post_vertex	×
NEW 79	return list(post_vertex.splitter.get_in_coming_slices())	×
NEW 80	return super().get_in_coming_slices()	×
81
82	@overrides(AbstractSplitterCommon.get_out_going_slices)	1✔
83	def get_out_going_slices(self) -> List[Slice]:	1✔
84	if self.send_over_sdram:	×
85	proj = self.governed_app_vertex.outgoing_projections[0]	×
86	# pylint: disable=protected-access
87	post_vertex = proj._projection_edge.post_vertex	×
NEW 88	return list(post_vertex.splitter.get_out_going_slices())	×
NEW 89	return super().get_out_going_slices()	×
90
91	@overrides(AbstractSplitterCommon.get_out_going_vertices)	1✔
92	def get_out_going_vertices(self, partition_id: str) -> List[MachineVertex]:	1✔
93	if self.send_over_sdram:	×
94	return []	×
NEW 95	return super().get_out_going_vertices(partition_id)	×
96
97	@overrides(AbstractSplitterCommon.get_same_chip_groups)	1✔
98	def get_same_chip_groups(self) -> Sequence[	1✔
99	Tuple[Sequence[MachineVertex], AbstractSDRAM]]:
100	if self.send_over_sdram:	1!
101	return []	×
102	return super().get_same_chip_groups()	1✔

SpiNNakerManchester / sPyNNaker / 6941305697

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