6926841603

Committed 02 Nov 2023 07:32AM UTC coverage: 84.035%. Remained the same

Build # 6926841603

Build Type

push

github

Committed by

Christian-B

Commit Message

merged in master

Run Details

1552 of 2025 branches covered (0.0%)

Branch coverage included in aggregate %.

182 of 183 new or added lines in 19 files covered. (99.45%)

39 existing lines in 8 files now uncovered.

5059 of 5842 relevant lines covered (86.6%)

0.87 hits per line

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

96.88

/pacman/model/partitioner_splitters/abstract_splitter_common.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 (
    Iterable, Generic, Optional, Sequence, Tuple, TypeVar, Union)
from spinn_utilities.abstract_base import AbstractBase, abstractmethod
from pacman.exceptions import PacmanConfigurationException
from pacman.model.graphs.application import ApplicationVertex
from pacman.utilities.utility_objs import ChipCounter
from pacman.model.graphs.common import Slice
from pacman.model.graphs.machine import (
    MachineVertex, MulticastEdgePartition, AbstractSDRAMPartition)
from pacman.model.resources import AbstractSDRAM

#: The type of vertex that we split.
#: :meta private:
V = TypeVar("V", bound=ApplicationVertex)


class AbstractSplitterCommon(Generic[V], metaclass=AbstractBase):
    """
    Common base class for vertex splitters, defining some utility methods.
    """

    __slots__ = (
        # the app vertex this splitter governs.
        "__governed_app_vertex", )

    def __init__(self) -> None:
        self.__governed_app_vertex: Optional[V] = None

    def __str__(self):
        try:
            return (
                f"{type(self).__name__} on {self.__governed_app_vertex.label}")
        except AttributeError:
            return f"{type(self).__name__} has no governed_app_vertex"

    def __repr__(self):
        return self.__str__()

    @property
    def governed_app_vertex(self) -> V:
        """
        The app vertex to be governed by this splitter object.

        :rtype: ~pacman.model.graphs.application.ApplicationVertex
        :raises PacmanConfigurationException:
            if the app vertex has not been been set.
        """
        if self.__governed_app_vertex is None:
            raise PacmanConfigurationException(
                "This splitter has no governing app vertex set")
        return self.__governed_app_vertex

    def set_governed_app_vertex(self, app_vertex: V):
        """
        Sets a application vertex to be governed by this splitter object.
        Once set it can't be reset.

        :param ~pacman.model.graphs.application.ApplicationVertex app_vertex:
            the app vertex to govern
        :raises PacmanConfigurationException:
            if the app vertex has already been set.
        """
        if self.__governed_app_vertex == app_vertex:
            return
        if self.__governed_app_vertex is not None:
            raise PacmanConfigurationException(
                f"The app vertex {self.__governed_app_vertex} is already"
                f" governed by this splitter. ")
        self.__governed_app_vertex = app_vertex
        app_vertex.splitter = self

    @abstractmethod
    def create_machine_vertices(self, chip_counter: ChipCounter):
        """
        Method for specific splitter objects to override.

        :param ~pacman.utilities.utility_objs.ChipCounter chip_counter:
            counter of used chips
        """
        raise NotImplementedError

    @abstractmethod
    def get_out_going_slices(self) -> Sequence[Slice]:
        """
        The slices of the output vertices.

        :return: list of Slices
        :rtype: list(~pacman.model.graphs.common.Slice)
        """
        raise NotImplementedError

    @abstractmethod
    def get_in_coming_slices(self) -> Sequence[Slice]:
        """
        The slices of the input vertices.

        :return: list of Slices
        :rtype: list(~pacman.model.graphs.common.Slice)
        """
        raise NotImplementedError

    @abstractmethod
    def get_out_going_vertices(
            self, partition_id: str) -> Sequence[MachineVertex]:
        """
        Get machine pre-vertices.

        The output vertices are the ones that will serve as source vertices
        for external edges.

        :param str partition_id: The identifier of the outgoing partition
        :rtype: list(~pacman.model.graphs.machine.MachineVertex)
        """
        raise NotImplementedError

    @abstractmethod
    def get_in_coming_vertices(
            self, partition_id: str) -> Sequence[MachineVertex]:
        """
        Get machine post-vertices for a given partition.

        The input vertices are the ones that will serve as target vertices
        for external edges.

        .. note::
            This method returns all that could be used
            for any source machine vertex in the given partition.

        :param str partition_id: The identifier of the incoming partition
        :rtype: list(~pacman.model.graphs.machine.MachineVertex)
        """
        raise NotImplementedError

    def get_source_specific_in_coming_vertices(
            self, source_vertex: ApplicationVertex,
            partition_id: str) -> Sequence[Tuple[
                MachineVertex, Sequence[
                    Union[MachineVertex, ApplicationVertex]]]]:
        """
        Get machine post-vertices for a given source.

        The input vertices are the ones that will serve as target vertices
        for external edges.

        .. note::
            This method allows filtering of the targets
            for a specific source machine vertex.

        This default method makes every machine vertex a target for the source.
        This should be overridden if there are specific machine vertices for
        any given source vertex.

        :param source_vertex: The source to get incoming vertices for
        :type source_vertex: ~pacman.model.graphs.application.ApplicationVertex
        :param str partition_id: The identifier of the incoming partition
        :return: A list of tuples of (target machine vertex, list of source
            machine or application vertices that should hit the target)
        :rtype: list(tuple(~pacman.model.graphs.machine.MachineVertex,
            list(~pacman.model.graphs.machine.MachineVertex or
            ~pacman.model.graphs.application.ApplicationVertex)))
        """
        return [(m_vertex, [source_vertex])
                for m_vertex in self.get_in_coming_vertices(partition_id)]

    @abstractmethod
    def machine_vertices_for_recording(
            self, variable_to_record: str) -> Iterable[MachineVertex]:
        """
        Gets the machine vertices which are recording this variable.

        :param str variable_to_record:
            the variable to get machine vertices for.
        :return: list of machine vertices
        :rtype: iterable(~pacman.model.graphs.machine.MachineVertex)
        """
        raise NotImplementedError

    @abstractmethod
    def reset_called(self):
        """
        Reset the splitter to be as if it has not operated a splitting yet.
        """
        raise NotImplementedError

    def get_same_chip_groups(self) -> Sequence[
            Tuple[Sequence[MachineVertex], AbstractSDRAM]]:
        """
        Get a list of lists of vertices and SDRAM which must be
        allocated on the same chip.  By default this returns a list of each
        machine vertex and its SDRAM; override if there are groups of
        machine vertices on the same chip.

        :rtype: list(list(~pacman.model.graphs.machine.MachineVertex),
            ~pacman.model.resources.AbstractSDRAM)
        """
        return [([v], v.sdram_required)
                for v in self.governed_app_vertex.machine_vertices]

    def get_internal_multicast_partitions(
            self) -> Sequence[MulticastEdgePartition]:
        """
        Get edge partitions between machine vertices that are to be
        handled by Multicast.  Returns empty by default, override if there
        are Multicast connections between internal vertices

        :rtype: list(~pacman.model.graphs.machine.MulticastEdgePartition)
        """
        return []

    def get_internal_sdram_partitions(
            self) -> Sequence[AbstractSDRAMPartition]:
        """
        Get edge partitions between machine vertices that are to be
        handled by SDRAM.  Returns empty by default, override if there
        are SDRAM connections between internal vertices

        :rtype: list(~pacman.model.graphs.machine.AbstractSDRAMPartition)
        """
        return []

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 (	1✔
15	Iterable, Generic, Optional, Sequence, Tuple, TypeVar, Union)
16	from spinn_utilities.abstract_base import AbstractBase, abstractmethod	1✔
17	from pacman.exceptions import PacmanConfigurationException	1✔
18	from pacman.model.graphs.application import ApplicationVertex	1✔
19	from pacman.utilities.utility_objs import ChipCounter	1✔
20	from pacman.model.graphs.common import Slice	1✔
21	from pacman.model.graphs.machine import (	1✔
22	MachineVertex, MulticastEdgePartition, AbstractSDRAMPartition)
23	from pacman.model.resources import AbstractSDRAM	1✔
24
25	#: The type of vertex that we split.
26	#: :meta private:
27	V = TypeVar("V", bound=ApplicationVertex)	1✔
28
29
30	class AbstractSplitterCommon(Generic[V], metaclass=AbstractBase):	1✔
31	"""
32	Common base class for vertex splitters, defining some utility methods.
33	"""
34
35	__slots__ = (	1✔
36	# the app vertex this splitter governs.
37	"__governed_app_vertex", )
38
39	def __init__(self) -> None:	1✔
40	self.__governed_app_vertex: Optional[V] = None	1✔
41
42	def __str__(self):	1✔
43	try:	1✔
44	return (	1✔
45	f"{type(self).__name__} on {self.__governed_app_vertex.label}")
46	except AttributeError:	1✔
47	return f"{type(self).__name__} has no governed_app_vertex"	1✔
48
49	def __repr__(self):	1✔
50	return self.__str__()	1✔
51
52	@property	1✔
53	def governed_app_vertex(self) -> V:	1✔
54	"""
55	The app vertex to be governed by this splitter object.
56
57	:rtype: ~pacman.model.graphs.application.ApplicationVertex
58	:raises PacmanConfigurationException:
59	if the app vertex has not been been set.
60	"""
61	if self.__governed_app_vertex is None:	1!
UNCOV 62	raise PacmanConfigurationException(	×
63	"This splitter has no governing app vertex set")
64	return self.__governed_app_vertex	1✔
65
66	def set_governed_app_vertex(self, app_vertex: V):	1✔
67	"""
68	Sets a application vertex to be governed by this splitter object.
69	Once set it can't be reset.
70
71	:param ~pacman.model.graphs.application.ApplicationVertex app_vertex:
72	the app vertex to govern
73	:raises PacmanConfigurationException:
74	if the app vertex has already been set.
75	"""
76	if self.__governed_app_vertex == app_vertex:	1✔
77	return	1✔
78	if self.__governed_app_vertex is not None:	1✔
79	raise PacmanConfigurationException(	1✔
80	f"The app vertex {self.__governed_app_vertex} is already"
81	f" governed by this splitter. ")
82	self.__governed_app_vertex = app_vertex	1✔
83	app_vertex.splitter = self	1✔
84
85	@abstractmethod	1✔
86	def create_machine_vertices(self, chip_counter: ChipCounter):	1✔
87	"""
88	Method for specific splitter objects to override.
89
90	:param ~pacman.utilities.utility_objs.ChipCounter chip_counter:
91	counter of used chips
92	"""
93	raise NotImplementedError
94
95	@abstractmethod	1✔
96	def get_out_going_slices(self) -> Sequence[Slice]:	1✔
97	"""
98	The slices of the output vertices.
99
100	:return: list of Slices
101	:rtype: list(~pacman.model.graphs.common.Slice)
102	"""
103	raise NotImplementedError
104
105	@abstractmethod	1✔
106	def get_in_coming_slices(self) -> Sequence[Slice]:	1✔
107	"""
108	The slices of the input vertices.
109
110	:return: list of Slices
111	:rtype: list(~pacman.model.graphs.common.Slice)
112	"""
113	raise NotImplementedError
114
115	@abstractmethod	1✔
116	def get_out_going_vertices(	1✔
117	self, partition_id: str) -> Sequence[MachineVertex]:
118	"""
119	Get machine pre-vertices.
120
121	The output vertices are the ones that will serve as source vertices
122	for external edges.
123
124	:param str partition_id: The identifier of the outgoing partition
125	:rtype: list(~pacman.model.graphs.machine.MachineVertex)
126	"""
127	raise NotImplementedError
128
129	@abstractmethod	1✔
130	def get_in_coming_vertices(	1✔
131	self, partition_id: str) -> Sequence[MachineVertex]:
132	"""
133	Get machine post-vertices for a given partition.
134
135	The input vertices are the ones that will serve as target vertices
136	for external edges.
137
138	.. note::
139	This method returns all that could be used
140	for any source machine vertex in the given partition.
141
142	:param str partition_id: The identifier of the incoming partition
143	:rtype: list(~pacman.model.graphs.machine.MachineVertex)
144	"""
145	raise NotImplementedError
146
147	def get_source_specific_in_coming_vertices(	1✔
148	self, source_vertex: ApplicationVertex,
149	partition_id: str) -> Sequence[Tuple[
150	MachineVertex, Sequence[
151	Union[MachineVertex, ApplicationVertex]]]]:
152	"""
153	Get machine post-vertices for a given source.
154
155	The input vertices are the ones that will serve as target vertices
156	for external edges.
157
158	.. note::
159	This method allows filtering of the targets
160	for a specific source machine vertex.
161
162	This default method makes every machine vertex a target for the source.
163	This should be overridden if there are specific machine vertices for
164	any given source vertex.
165
166	:param source_vertex: The source to get incoming vertices for
167	:type source_vertex: ~pacman.model.graphs.application.ApplicationVertex
168	:param str partition_id: The identifier of the incoming partition
169	:return: A list of tuples of (target machine vertex, list of source
170	machine or application vertices that should hit the target)
171	:rtype: list(tuple(~pacman.model.graphs.machine.MachineVertex,
172	list(~pacman.model.graphs.machine.MachineVertex or
173	~pacman.model.graphs.application.ApplicationVertex)))
174	"""
175	return [(m_vertex, [source_vertex])	1✔
176	for m_vertex in self.get_in_coming_vertices(partition_id)]
177
178	@abstractmethod	1✔
179	def machine_vertices_for_recording(	1✔
180	self, variable_to_record: str) -> Iterable[MachineVertex]:
181	"""
182	Gets the machine vertices which are recording this variable.
183
184	:param str variable_to_record:
185	the variable to get machine vertices for.
186	:return: list of machine vertices
187	:rtype: iterable(~pacman.model.graphs.machine.MachineVertex)
188	"""
189	raise NotImplementedError
190
191	@abstractmethod	1✔
192	def reset_called(self):	1✔
193	"""
194	Reset the splitter to be as if it has not operated a splitting yet.
195	"""
196	raise NotImplementedError
197
198	def get_same_chip_groups(self) -> Sequence[	1✔
199	Tuple[Sequence[MachineVertex], AbstractSDRAM]]:
200	"""
201	Get a list of lists of vertices and SDRAM which must be
202	allocated on the same chip. By default this returns a list of each
203	machine vertex and its SDRAM; override if there are groups of
204	machine vertices on the same chip.
205
206	:rtype: list(list(~pacman.model.graphs.machine.MachineVertex),
207	~pacman.model.resources.AbstractSDRAM)
208	"""
209	return [([v], v.sdram_required)	1✔
210	for v in self.governed_app_vertex.machine_vertices]
211
212	def get_internal_multicast_partitions(	1✔
213	self) -> Sequence[MulticastEdgePartition]:
214	"""
215	Get edge partitions between machine vertices that are to be
216	handled by Multicast. Returns empty by default, override if there
217	are Multicast connections between internal vertices
218
219	:rtype: list(~pacman.model.graphs.machine.MulticastEdgePartition)
220	"""
221	return []	1✔
222
223	def get_internal_sdram_partitions(	1✔
224	self) -> Sequence[AbstractSDRAMPartition]:
225	"""
226	Get edge partitions between machine vertices that are to be
227	handled by SDRAM. Returns empty by default, override if there
228	are SDRAM connections between internal vertices
229
230	:rtype: list(~pacman.model.graphs.machine.AbstractSDRAMPartition)
231	"""
232	return []	1✔

SpiNNakerManchester / PACMAN / 6926841603

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