7043271558

Committed 28 Nov 2023 09:14AM UTC coverage: 84.39% (+0.08%) from 84.31%

Build # 7043271558

Build Type

Pull #525

github

Committed by

Christian-B

Commit Message

merged in master

Pull Request Pull Request #525: Improve message when Placer runs out of room.

Run Details

1614 of 2090 branches covered (0.0%)

Branch coverage included in aggregate %.

52 of 56 new or added lines in 2 files covered. (92.86%)

3 existing lines in 1 file now uncovered.

5203 of 5988 relevant lines covered (86.89%)

0.87 hits per line

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

96.18

/pacman/data/pacman_data_writer.py

# Copyright (c) 2021 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
import logging
from typing import Optional
from spinn_utilities.log import FormatAdapter
from spinn_utilities.overrides import overrides
from spinn_machine.data.machine_data_writer import MachineDataWriter
from pacman.model.graphs.application import ApplicationEdge, ApplicationVertex
from pacman.model.graphs.machine import MachineVertex
from pacman.model.placements import Placements
from pacman.model.routing_info import RoutingInfo
from pacman.model.routing_table_by_partition import (
    MulticastRoutingTableByPartition)
from pacman.model.routing_tables import MulticastRoutingTables
from pacman.model.tags import Tags
from pacman.exceptions import PacmanConfigurationException
from .pacman_data_view import PacmanDataView, _PacmanDataModel

logger = FormatAdapter(logging.getLogger(__name__))
__temp_dir = None

REPORTS_DIRNAME = "reports"
# pylint: disable=protected-access


class PacmanDataWriter(MachineDataWriter, PacmanDataView):
    """
    See :py:class:`spinn_utilities.data.UtilsDataWriter`.

    This class is designed to only be used directly within the PACMAN
    repository unit tests as all methods are available to subclasses.
    """
    __pacman_data: _PacmanDataModel = _PacmanDataModel()
    __slots__ = ()

    @overrides(MachineDataWriter._mock)
    def _mock(self) -> None:
        MachineDataWriter._mock(self)
        self.__pacman_data._clear()

    @overrides(MachineDataWriter._setup)
    def _setup(self) -> None:
        MachineDataWriter._setup(self)
        self.__pacman_data._clear()

    @overrides(MachineDataWriter._hard_reset)
    def _hard_reset(self) -> None:
        MachineDataWriter._hard_reset(self)
        self.__pacman_data._hard_reset()

    @overrides(MachineDataWriter._soft_reset)
    def _soft_reset(self) -> None:
        MachineDataWriter._soft_reset(self)
        self.__pacman_data._soft_reset()

    def set_placements(self, placements: Placements):
        """
        Set the placements.

        :param Placements placements:
        :raises TypeError: if the placements is not a Placements
        """
        if not isinstance(placements, Placements):
            raise TypeError("placements should be a Placements")
        self.__pacman_data._placements = placements

    def set_routing_infos(self, routing_infos: RoutingInfo):
        """
        Set the routing_infos.

        :param RoutingInfo routing_infos:
        :raises TypeError: if the routing_infos is not a RoutingInfo
        """
        if not isinstance(routing_infos, RoutingInfo):
            raise TypeError("routing_infos should be a RoutingInfo")
        self.__pacman_data._routing_infos = routing_infos

    def set_tags(self, tags: Tags):
        """
        Set the tags.

        :param Tags tags:
        :raises TypeError: if the tags is not a Tags
        """
        if not isinstance(tags, Tags):
            raise TypeError("tags should be a Tags")
        self.__pacman_data._tags = tags

    def set_uncompressed(self, router_tables: MulticastRoutingTables):
        """
        Sets the uncompressed `router_tables` value.

        :param MulticastRoutingTables router_tables: new value
        :raises TypeError:
            if the router_tables is not a MulticastRoutingTables
        """
        if not isinstance(router_tables, MulticastRoutingTables):
            raise TypeError(
                "router_tables should be a MulticastRoutingTables")
        self.__pacman_data._uncompressed = router_tables

    def set_precompressed(self, router_tables: MulticastRoutingTables):
        """
        Sets the precompressed `router_tables` value.

        :param MulticastRoutingTables router_tables: new value
        :raises TypeError:
            if the router_tables is not a MulticastRoutingTables
        """
        if not isinstance(router_tables, MulticastRoutingTables):
            raise TypeError(
                "router_tables should be a MulticastRoutingTables")
        self.__pacman_data._precompressed = router_tables

    def set_plan_n_timesteps(self, plan_n_timesteps: Optional[int]):
        """
        Sets the `plan_n_timestep`. Use `None` for run forever.

        :param plan_n_timesteps:
        :type plan_n_timesteps: int or None
        :raises TypeError: if the plan_n_timesteps are not an int or `None`
        :raises PacmanConfigurationException: On a negative plan_n_timesteps
        """
        if plan_n_timesteps is not None:
            if not isinstance(plan_n_timesteps, int):
                raise TypeError("plan_n_timesteps should be an int")
            if plan_n_timesteps < 0:
                raise PacmanConfigurationException(
                    f"plan_n_timesteps {plan_n_timesteps} "
                    f"must not be negative")
        self.__pacman_data._plan_n_timesteps = plan_n_timesteps

    def set_routing_table_by_partition(
            self, routing_table_by_partition:
            MulticastRoutingTableByPartition):
        """
        Sets the `_routing_table_by_partition`.

        :param MulticastRoutingTableByPartition routing_table_by_partition:
            raises TypeError: if routing_table_by_partition is no a
            MulticastRoutingTableByPartition
        """
        if not isinstance(
                routing_table_by_partition, MulticastRoutingTableByPartition):
            raise TypeError(
                "routing_table_by_partition should be a "
                "MulticastRoutingTableByPartition")
        self.__pacman_data._routing_table_by_partition = \
            routing_table_by_partition

    @classmethod
    def add_vertex(cls, vertex: ApplicationVertex):
        if cls.__pacman_data._graph is None:
            raise cls._exception("graph")
        if not cls.get_requires_mapping():
            raise PacmanConfigurationException(
                "This call is only expected if requires mapping is True")
        cls.__pacman_data._graph.add_vertex(vertex)

    @classmethod
    def add_edge(cls, edge: ApplicationEdge,
                 outgoing_edge_partition_name: str):
        if cls.__pacman_data._graph is None:
            raise cls._exception("graph")
        if not cls.get_requires_mapping():
            raise PacmanConfigurationException(
                "This call is only expected if requires mapping is True")
        cls.__pacman_data._graph.add_edge(edge, outgoing_edge_partition_name)

    def add_monitor_all_chips(self, vertex: MachineVertex):
        """
        Reports that a monitor has been added to every chip.
        Should be called once for each monitor added to all chips.
        Should not be called for monitors only added to Ethernet-enabled chips.

        Only affect is to change the numbers reported by the `get_monitor`
        methods.

        :param ~pacman.model.graphs.machine.MachineVertex vertex:
            One of the vertices added to each core, assumed to be typical of
            all.
        """
        self.__pacman_data._monitor_cores += 1
        self.__pacman_data._monitor_sdram += \
            vertex.sdram_required.get_total_sdram(self.get_plan_n_timestep())

    def set_n_required(self, n_boards_required, n_chips_required):
        """
        Sets (if not `None`) the number of boards/chips requested by the user.

        :param n_boards_required:
            `None` or the number of boards requested by the user
        :type n_boards_required: int or None
        :param n_chips_required:
            `None` or the number of chips requested by the user
        :type n_chips_required: int or None
        """
        if n_boards_required is None:
            if n_chips_required is None:
                return
            elif not isinstance(n_chips_required, int):
                raise TypeError("n_chips_required must be an int (or None)")
            if n_chips_required <= 0:
                raise ValueError(
                    "n_chips_required must be positive and not "
                    f"{n_chips_required}")
        else:
            if n_chips_required is not None:
                raise ValueError(
                    "Illegal call with both both param provided as "
                    f"{n_boards_required}, {n_chips_required}")
            if not isinstance(n_boards_required, int):
                raise TypeError("n_boards_required must be an int (or None)")
            if n_boards_required <= 0:
                raise ValueError(
                    "n_boards_required must be positive and not "
                    f"{n_boards_required}")
        if self.__pacman_data._n_boards_required is not None or \
                self.__pacman_data._n_chips_required is not None:
            raise ValueError(
                "Illegal second call to set_n_required")
        self.__pacman_data._n_boards_required = n_boards_required
        self.__pacman_data._n_chips_required = n_chips_required

    def set_n_chips_in_graph(self, n_chips_in_graph):
        """
        Sets the number of chips needed by the graph.

        :param int n_chips_in_graph:
        """
        if not isinstance(n_chips_in_graph, int):
            raise TypeError("n_chips_in_graph must be an int (or None)")
        if n_chips_in_graph <= 0:
            raise ValueError(
                "n_chips_in_graph must be positive and not "
                f"{n_chips_in_graph}")
        self.__pacman_data._n_chips_in_graph = n_chips_in_graph

1	# Copyright (c) 2021 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 __future__ import annotations	1✔
15	import logging	1✔
16	from typing import Optional	1✔
17	from spinn_utilities.log import FormatAdapter	1✔
18	from spinn_utilities.overrides import overrides	1✔
19	from spinn_machine.data.machine_data_writer import MachineDataWriter	1✔
20	from pacman.model.graphs.application import ApplicationEdge, ApplicationVertex	1✔
21	from pacman.model.graphs.machine import MachineVertex	1✔
22	from pacman.model.placements import Placements	1✔
23	from pacman.model.routing_info import RoutingInfo	1✔
24	from pacman.model.routing_table_by_partition import (	1✔
25	MulticastRoutingTableByPartition)
26	from pacman.model.routing_tables import MulticastRoutingTables	1✔
27	from pacman.model.tags import Tags	1✔
28	from pacman.exceptions import PacmanConfigurationException	1✔
29	from .pacman_data_view import PacmanDataView, _PacmanDataModel	1✔
30
31	logger = FormatAdapter(logging.getLogger(__name__))	1✔
32	__temp_dir = None	1✔
33
34	REPORTS_DIRNAME = "reports"	1✔
35	# pylint: disable=protected-access
36
37
38	class PacmanDataWriter(MachineDataWriter, PacmanDataView):	1✔
39	"""
40	See :py:class:`spinn_utilities.data.UtilsDataWriter`.
41
42	This class is designed to only be used directly within the PACMAN
43	repository unit tests as all methods are available to subclasses.
44	"""
45	__pacman_data: _PacmanDataModel = _PacmanDataModel()	1✔
46	__slots__ = ()	1✔
47
48	@overrides(MachineDataWriter._mock)	1✔
49	def _mock(self) -> None:	1✔
50	MachineDataWriter._mock(self)	1✔
51	self.__pacman_data._clear()	1✔
52
53	@overrides(MachineDataWriter._setup)	1✔
54	def _setup(self) -> None:	1✔
55	MachineDataWriter._setup(self)	1✔
56	self.__pacman_data._clear()	1✔
57
58	@overrides(MachineDataWriter._hard_reset)	1✔
59	def _hard_reset(self) -> None:	1✔
60	MachineDataWriter._hard_reset(self)	1✔
61	self.__pacman_data._hard_reset()	1✔
62
63	@overrides(MachineDataWriter._soft_reset)	1✔
64	def _soft_reset(self) -> None:	1✔
65	MachineDataWriter._soft_reset(self)	1✔
66	self.__pacman_data._soft_reset()	1✔
67
68	def set_placements(self, placements: Placements):	1✔
69	"""
70	Set the placements.
71
72	:param Placements placements:
73	:raises TypeError: if the placements is not a Placements
74	"""
75	if not isinstance(placements, Placements):	1✔
76	raise TypeError("placements should be a Placements")	1✔
77	self.__pacman_data._placements = placements	1✔
78
79	def set_routing_infos(self, routing_infos: RoutingInfo):	1✔
80	"""
81	Set the routing_infos.
82
83	:param RoutingInfo routing_infos:
84	:raises TypeError: if the routing_infos is not a RoutingInfo
85	"""
86	if not isinstance(routing_infos, RoutingInfo):	1✔
87	raise TypeError("routing_infos should be a RoutingInfo")	1✔
88	self.__pacman_data._routing_infos = routing_infos	1✔
89
90	def set_tags(self, tags: Tags):	1✔
91	"""
92	Set the tags.
93
94	:param Tags tags:
95	:raises TypeError: if the tags is not a Tags
96	"""
97	if not isinstance(tags, Tags):	1✔
98	raise TypeError("tags should be a Tags")	1✔
99	self.__pacman_data._tags = tags	1✔
100
101	def set_uncompressed(self, router_tables: MulticastRoutingTables):	1✔
102	"""
103	Sets the uncompressed `router_tables` value.
104
105	:param MulticastRoutingTables router_tables: new value
106	:raises TypeError:
107	if the router_tables is not a MulticastRoutingTables
108	"""
109	if not isinstance(router_tables, MulticastRoutingTables):	1✔
110	raise TypeError(	1✔
111	"router_tables should be a MulticastRoutingTables")
112	self.__pacman_data._uncompressed = router_tables	1✔
113
114	def set_precompressed(self, router_tables: MulticastRoutingTables):	1✔
115	"""
116	Sets the precompressed `router_tables` value.
117
118	:param MulticastRoutingTables router_tables: new value
119	:raises TypeError:
120	if the router_tables is not a MulticastRoutingTables
121	"""
122	if not isinstance(router_tables, MulticastRoutingTables):	1✔
123	raise TypeError(	1✔
124	"router_tables should be a MulticastRoutingTables")
125	self.__pacman_data._precompressed = router_tables	1✔
126
127	def set_plan_n_timesteps(self, plan_n_timesteps: Optional[int]):	1✔
128	"""
129	Sets the `plan_n_timestep`. Use `None` for run forever.
130
131	:param plan_n_timesteps:
132	:type plan_n_timesteps: int or None
133	:raises TypeError: if the plan_n_timesteps are not an int or `None`
134	:raises PacmanConfigurationException: On a negative plan_n_timesteps
135	"""
136	if plan_n_timesteps is not None:	1✔
137	if not isinstance(plan_n_timesteps, int):	1✔
138	raise TypeError("plan_n_timesteps should be an int")	1✔
139	if plan_n_timesteps < 0:	1✔
140	raise PacmanConfigurationException(	1✔
141	f"plan_n_timesteps {plan_n_timesteps} "
142	f"must not be negative")
143	self.__pacman_data._plan_n_timesteps = plan_n_timesteps	1✔
144
145	def set_routing_table_by_partition(	1✔
146	self, routing_table_by_partition:
147	MulticastRoutingTableByPartition):
148	"""
149	Sets the `_routing_table_by_partition`.
150
151	:param MulticastRoutingTableByPartition routing_table_by_partition:
152	raises TypeError: if routing_table_by_partition is no a
153	MulticastRoutingTableByPartition
154	"""
155	if not isinstance(	1✔
156	routing_table_by_partition, MulticastRoutingTableByPartition):
157	raise TypeError(	1✔
158	"routing_table_by_partition should be a "
159	"MulticastRoutingTableByPartition")
160	self.__pacman_data._routing_table_by_partition = \	1✔
161	routing_table_by_partition
162
163	@classmethod	1✔
164	def add_vertex(cls, vertex: ApplicationVertex):	1✔
165	if cls.__pacman_data._graph is None:	1✔
166	raise cls._exception("graph")	1✔
167	if not cls.get_requires_mapping():	1✔
168	raise PacmanConfigurationException(	1✔
169	"This call is only expected if requires mapping is True")
170	cls.__pacman_data._graph.add_vertex(vertex)	1✔
171
172	@classmethod	1✔
173	def add_edge(cls, edge: ApplicationEdge,	1✔
174	outgoing_edge_partition_name: str):
175	if cls.__pacman_data._graph is None:	1✔
176	raise cls._exception("graph")	1✔
177	if not cls.get_requires_mapping():	1✔
178	raise PacmanConfigurationException(	1✔
179	"This call is only expected if requires mapping is True")
180	cls.__pacman_data._graph.add_edge(edge, outgoing_edge_partition_name)	1✔
181
182	def add_monitor_all_chips(self, vertex: MachineVertex):	1✔
183	"""
184	Reports that a monitor has been added to every chip.
185	Should be called once for each monitor added to all chips.
186	Should not be called for monitors only added to Ethernet-enabled chips.
187
188	Only affect is to change the numbers reported by the `get_monitor`
189	methods.
190
191	:param ~pacman.model.graphs.machine.MachineVertex vertex:
192	One of the vertices added to each core, assumed to be typical of
193	all.
194	"""
195	self.__pacman_data._monitor_cores += 1	1✔
196	self.__pacman_data._monitor_sdram += \	1✔
197	vertex.sdram_required.get_total_sdram(self.get_plan_n_timestep())
198
199	def set_n_required(self, n_boards_required, n_chips_required):	1✔
200	"""
201	Sets (if not `None`) the number of boards/chips requested by the user.
202
203	:param n_boards_required:
204	`None` or the number of boards requested by the user
205	:type n_boards_required: int or None
206	:param n_chips_required:
207	`None` or the number of chips requested by the user
208	:type n_chips_required: int or None
209	"""
210	if n_boards_required is None:	1✔
211	if n_chips_required is None:	1✔
212	return	1✔
213	elif not isinstance(n_chips_required, int):	1✔
214	raise TypeError("n_chips_required must be an int (or None)")	1✔
215	if n_chips_required <= 0:	1✔
216	raise ValueError(	1✔
217	"n_chips_required must be positive and not "
218	f"{n_chips_required}")
219	else:
220	if n_chips_required is not None:	1✔
221	raise ValueError(	1✔
222	"Illegal call with both both param provided as "
223	f"{n_boards_required}, {n_chips_required}")
224	if not isinstance(n_boards_required, int):	1✔
225	raise TypeError("n_boards_required must be an int (or None)")	1✔
226	if n_boards_required <= 0:	1✔
227	raise ValueError(	1✔
228	"n_boards_required must be positive and not "
229	f"{n_boards_required}")
230	if self.__pacman_data._n_boards_required is not None or \	1!
231	self.__pacman_data._n_chips_required is not None:
NEW 232	raise ValueError(	×
233	"Illegal second call to set_n_required")
234	self.__pacman_data._n_boards_required = n_boards_required	1✔
235	self.__pacman_data._n_chips_required = n_chips_required	1✔
236
237	def set_n_chips_in_graph(self, n_chips_in_graph):	1✔
238	"""
239	Sets the number of chips needed by the graph.
240
241	:param int n_chips_in_graph:
242	"""
243	if not isinstance(n_chips_in_graph, int):	1!
NEW 244	raise TypeError("n_chips_in_graph must be an int (or None)")	×
245	if n_chips_in_graph <= 0:	1!
NEW 246	raise ValueError(	×
247	"n_chips_in_graph must be positive and not "
248	f"{n_chips_in_graph}")
249	self.__pacman_data._n_chips_in_graph = n_chips_in_graph	1✔

SpiNNakerManchester / PACMAN / 7043271558

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