8448558431

Committed 27 Mar 2024 08:11AM UTC coverage: 88.096% (+1.0%) from 87.06%

Build # 8448558431

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #554 from SpiNNakerManchester/less_routers

Less routers

Run Details

2529 of 2921 branches covered (86.58%)

Branch coverage included in aggregate %.

4 of 4 new or added lines in 2 files covered. (100.0%)

8 existing lines in 1 file now uncovered.

4864 of 5471 relevant lines covered (88.91%)

0.89 hits per line

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

86.41

/pacman/model/routing_table_by_partition/multicast_routing_table_by_partition_entry.py

# Copyright (c) 2015 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 FrozenSet, Iterable, Optional, Union
from spinn_utilities.log import FormatAdapter
from pacman.exceptions import (
    PacmanConfigurationException, PacmanInvalidParameterException)

log = FormatAdapter(logging.getLogger(__name__))

_INCOMING_LINK_MASK = 0x07000000
_INCOMING_LINK_SHIFT = 24
_INCOMING_PROC_MASK = 0xF8000000
_INCOMING_PROC_SHIFT = 27
_OUTGOING_LINKS_MASK = 0x0000003F
_OUTGOING_LINK_1 = 0x00000001
_OUTGOING_PROCS_MASK = 0x00FFFFC0
_OUTGOING_PROC_1 = 0x00000040
_SPINNAKER_ROUTE_MASK = _OUTGOING_LINKS_MASK | _OUTGOING_PROCS_MASK
_COMPARE_MASK = _INCOMING_LINK_MASK | _SPINNAKER_ROUTE_MASK
_N_PROCS = 18
_N_LINKS = 6


class MulticastRoutingTableByPartitionEntry(object):
    """
    An entry in a path of a multicast route.
    """

    __slots__ = (
        # pylint: disable=wrong-spelling-in-comment
        # Entry made up of bits as follows:
        # | IL = 6 bits | IP = 1 bit | OL = 6 bits | OP = 18 bits |
        # IL = incoming link id
        # IP = whether the source is a processor or not
        # OL = outgoing links
        # OP = outgoing processors
        "_links_and_procs", )

    def __init__(self, out_going_links: Union[int, Iterable[int], None],
                 outgoing_processors: Union[int, Iterable[int], None],
                 incoming_processor: Optional[int] = None,
                 incoming_link: Optional[int] = None):
        """
        :param out_going_links:
            the edges this path entry goes down, each of which is between
            0 and 5
        :type out_going_links: int or iterable(int) or None
        :param outgoing_processors:
            the processors this path entry goes to, each of which is between
            0 and 17
        :type outgoing_processors: int or iterable(int) or None
        :param int incoming_processor:
            the direction this entry came from (between 0 and 17)
        :param int incoming_link:
            the direction this entry came from in link (between 0 and 5)
        :raises PacmanInvalidParameterException:
        """
        self._links_and_procs = 0
        if isinstance(out_going_links, int):
            self.__set_outgoing_links([out_going_links])
        elif out_going_links is not None:
            self.__set_outgoing_links(out_going_links)

        if isinstance(outgoing_processors, int):
            self.__set_outgoing_procs([outgoing_processors])
        elif outgoing_processors is not None:
            self.__set_outgoing_procs(outgoing_processors)

        if incoming_link is not None and incoming_processor is not None:
            raise PacmanInvalidParameterException(
                "The incoming direction for a path can only be from either "
                "one link or one processors, not both",
                str(incoming_link), str(incoming_processor))
        if incoming_processor is not None:
            self.__set_incoming_proc(incoming_processor)
        elif incoming_link is not None:
            self.__set_incoming_link(incoming_link)

    def __set_incoming_link(self, link: int):
        if link > _N_LINKS:
            raise ValueError(f"Link {link} > {_N_LINKS}")
        # Add one so that 0 means not set
        self._links_and_procs |= (link + 1) << _INCOMING_LINK_SHIFT

    def __set_incoming_proc(self, proc: int):
        if proc > _N_PROCS:
            raise ValueError(f"Processor {proc} > {_N_PROCS}")
        # Add one so that 0 means not set
        self._links_and_procs |= (proc + 1) << _INCOMING_PROC_SHIFT

    def __set_outgoing_links(self, links: Iterable[int]):
        for link in links:
            if link > _N_LINKS:
                raise ValueError(f"Link {link} > {_N_LINKS}")
            self._links_and_procs |= _OUTGOING_LINK_1 << link

    def __set_outgoing_procs(self, procs: Iterable[int]):
        for proc in procs:
            if proc > _N_PROCS:
                raise ValueError(f"Processor {proc} > {_N_PROCS}")
            self._links_and_procs |= _OUTGOING_PROC_1 << proc

    @property
    def processor_ids(self) -> FrozenSet[int]:
        """
        The destination processors of the entry.

        :rtype: frozenset(int)
        """
        return frozenset(i for i in range(_N_PROCS)
                         if self._links_and_procs & (_OUTGOING_PROC_1 << i))

    @property
    def link_ids(self) -> FrozenSet[int]:
        """
        The destination links of the entry.

        :rtype: frozenset(int)
        """
        return frozenset(i for i in range(_N_LINKS)
                         if self._links_and_procs & (_OUTGOING_LINK_1 << i))

    @property
    def incoming_link(self) -> Optional[int]:
        """
        The source link for this path entry.

        :rtype: int or None
        """
        link = ((self._links_and_procs & _INCOMING_LINK_MASK) >>
                _INCOMING_LINK_SHIFT)
        if link == 0:
            return None
        # Subtract 1 as 0 means not set
        return link - 1

    @incoming_link.setter
    def incoming_link(self, incoming_link: int):
        if self.incoming_processor is not None:
            raise PacmanConfigurationException(
                f"Entry already has an incoming processor "
                f"{self.incoming_processor}")
        self_link = self.incoming_link
        if self_link is not None and self_link != incoming_link:
            raise PacmanConfigurationException(
                f"Entry already has an incoming link {self_link}")
        self.__set_incoming_link(incoming_link)

    @property
    def incoming_processor(self) -> Optional[int]:
        """
        The source processor.

        :rtype: int or None
        """
        proc = ((self._links_and_procs & _INCOMING_PROC_MASK) >>
                _INCOMING_PROC_SHIFT)
        if proc == 0:
            return None
        # Subtract 1 as 0 means not set
        return proc - 1

    @incoming_processor.setter
    def incoming_processor(self, incoming_processor: int):
        if self.incoming_link is not None:
            raise PacmanConfigurationException(
                f"Entry already has an incoming link {self.incoming_link}")
        self_proc = self.incoming_processor
        if self_proc is not None and self_proc != incoming_processor:
            raise PacmanConfigurationException(
                f"Entry already has an incoming processor {self_proc}")
        self.__set_incoming_proc(incoming_processor)

    @property
    def defaultable(self) -> bool:
        """
        The defaultable status of the entry.

        :rtype: bool
        """
        if self.incoming_processor is not None:
            return False
        in_link = self.incoming_link
        if in_link is None:
            return False
        out_links = self.link_ids
        if len(out_links) != 1:
            return False
        if self.processor_ids:
            return False
        out_link = next(iter(out_links))
        return ((in_link + 3) % 6) == out_link

    @staticmethod
    def __merge_none_or_equal(p1, p2, name):
        if p1 is None:
            return p2
        if p2 is None or p2 == p1:
            return p1
        raise PacmanInvalidParameterException(
            name, "invalid merge",
            "The two MulticastRoutingTableByPartitionEntry have "
            "different " + name + "s, and so can't be merged")

    def merge_entry(self, other: MulticastRoutingTableByPartitionEntry) -> \
            MulticastRoutingTableByPartitionEntry:
        """
        Merges the another entry with this one and returns a new
        MulticastRoutingTableByPartitionEntry

        :param MulticastRoutingTableByPartitionEntry other:
            the entry to merge into this one
        :return: a merged MulticastRoutingTableByPartitionEntry
        :raises PacmanInvalidParameterException:
        """
        # pylint:disable=protected-access
        if not isinstance(other, MulticastRoutingTableByPartitionEntry):
            raise PacmanInvalidParameterException(
                "other", "type error",
                "The other parameter is not an instance of "
                "MulticastRoutingTableByPartitionEntry, and therefore cannot "
                "be merged.")

        # validate incoming
        try:
            in_proc = self.__merge_none_or_equal(
                self.incoming_processor, other.incoming_processor,
                "incoming_processor")
            in_link = self.__merge_none_or_equal(
                self.incoming_link, other.incoming_link, "incoming_link")
            if in_proc is not None and in_link is not None:
                raise PacmanInvalidParameterException(
                    "other", "merge error",
                    f"Cannot merge {other} and {self}: both incoming processor"
                    " and link are set")
        except PacmanInvalidParameterException as e:
            log.error("Error merging entry {} into {}", other, self)
            raise e

        # Set the value directly as faster
        entry = MulticastRoutingTableByPartitionEntry(None, None)
        entry._links_and_procs = self._links_and_procs | other._links_and_procs
        return entry

    def __repr__(self) -> str:
        return (f"{self.incoming_link}:{self.incoming_processor}:"
                f"{self.defaultable}:"
                f"{{{', '.join(map(str, self.link_ids))}}}:"
                f"{{{', '.join(map(str, self.processor_ids))}}}")

    def has_same_route(
            self, entry: MulticastRoutingTableByPartitionEntry) -> bool:
        """
        Checks if the two Entries have the same routes after applying mask

        :param  MulticastRoutingTableByPartitionEntry entry:
        :rtype: bool
        """
        # pylint:disable=protected-access
        return ((self._links_and_procs & _COMPARE_MASK) ==
                (entry._links_and_procs & _COMPARE_MASK))

    @property
    def spinnaker_route(self) -> int:
        """
        The masked routes

        :rtype: int
        """
        return self._links_and_procs & _SPINNAKER_ROUTE_MASK

1	# Copyright (c) 2015 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 FrozenSet, Iterable, Optional, Union	1✔
17	from spinn_utilities.log import FormatAdapter	1✔
18	from pacman.exceptions import (	1✔
19	PacmanConfigurationException, PacmanInvalidParameterException)
20
21	log = FormatAdapter(logging.getLogger(__name__))	1✔
22
23	_INCOMING_LINK_MASK = 0x07000000	1✔
24	_INCOMING_LINK_SHIFT = 24	1✔
25	_INCOMING_PROC_MASK = 0xF8000000	1✔
26	_INCOMING_PROC_SHIFT = 27	1✔
27	_OUTGOING_LINKS_MASK = 0x0000003F	1✔
28	_OUTGOING_LINK_1 = 0x00000001	1✔
29	_OUTGOING_PROCS_MASK = 0x00FFFFC0	1✔
30	_OUTGOING_PROC_1 = 0x00000040	1✔
31	_SPINNAKER_ROUTE_MASK = _OUTGOING_LINKS_MASK \| _OUTGOING_PROCS_MASK	1✔
32	_COMPARE_MASK = _INCOMING_LINK_MASK \| _SPINNAKER_ROUTE_MASK	1✔
33	_N_PROCS = 18	1✔
34	_N_LINKS = 6	1✔
35
36
37	class MulticastRoutingTableByPartitionEntry(object):	1✔
38	"""
39	An entry in a path of a multicast route.
40	"""
41
42	__slots__ = (	1✔
43	# pylint: disable=wrong-spelling-in-comment
44	# Entry made up of bits as follows:
45	# \| IL = 6 bits \| IP = 1 bit \| OL = 6 bits \| OP = 18 bits \|
46	# IL = incoming link id
47	# IP = whether the source is a processor or not
48	# OL = outgoing links
49	# OP = outgoing processors
50	"_links_and_procs", )
51
52	def __init__(self, out_going_links: Union[int, Iterable[int], None],	1✔
53	outgoing_processors: Union[int, Iterable[int], None],
54	incoming_processor: Optional[int] = None,
55	incoming_link: Optional[int] = None):
56	"""
57	:param out_going_links:
58	the edges this path entry goes down, each of which is between
59	0 and 5
60	:type out_going_links: int or iterable(int) or None
61	:param outgoing_processors:
62	the processors this path entry goes to, each of which is between
63	0 and 17
64	:type outgoing_processors: int or iterable(int) or None
65	:param int incoming_processor:
66	the direction this entry came from (between 0 and 17)
67	:param int incoming_link:
68	the direction this entry came from in link (between 0 and 5)
69	:raises PacmanInvalidParameterException:
70	"""
71	self._links_and_procs = 0	1✔
72	if isinstance(out_going_links, int):	1✔
73	self.__set_outgoing_links([out_going_links])	1✔
74	elif out_going_links is not None:	1✔
75	self.__set_outgoing_links(out_going_links)	1✔
76
77	if isinstance(outgoing_processors, int):	1✔
78	self.__set_outgoing_procs([outgoing_processors])	1✔
79	elif outgoing_processors is not None:	1✔
80	self.__set_outgoing_procs(outgoing_processors)	1✔
81
82	if incoming_link is not None and incoming_processor is not None:	1✔
83	raise PacmanInvalidParameterException(	1✔
84	"The incoming direction for a path can only be from either "
85	"one link or one processors, not both",
86	str(incoming_link), str(incoming_processor))
87	if incoming_processor is not None:	1✔
88	self.__set_incoming_proc(incoming_processor)	1✔
89	elif incoming_link is not None:	1✔
90	self.__set_incoming_link(incoming_link)	1✔
91
92	def __set_incoming_link(self, link: int):	1✔
93	if link > _N_LINKS:	1!
94	raise ValueError(f"Link {link} > {_N_LINKS}")	×
95	# Add one so that 0 means not set
96	self._links_and_procs \|= (link + 1) << _INCOMING_LINK_SHIFT	1✔
97
98	def __set_incoming_proc(self, proc: int):	1✔
99	if proc > _N_PROCS:	1!
100	raise ValueError(f"Processor {proc} > {_N_PROCS}")	×
101	# Add one so that 0 means not set
102	self._links_and_procs \|= (proc + 1) << _INCOMING_PROC_SHIFT	1✔
103
104	def __set_outgoing_links(self, links: Iterable[int]):	1✔
105	for link in links:	1✔
106	if link > _N_LINKS:	1✔
107	raise ValueError(f"Link {link} > {_N_LINKS}")	1✔
108	self._links_and_procs \|= _OUTGOING_LINK_1 << link	1✔
109
110	def __set_outgoing_procs(self, procs: Iterable[int]):	1✔
111	for proc in procs:	1✔
112	if proc > _N_PROCS:	1✔
113	raise ValueError(f"Processor {proc} > {_N_PROCS}")	1✔
114	self._links_and_procs \|= _OUTGOING_PROC_1 << proc	1✔
115
116	@property	1✔
117	def processor_ids(self) -> FrozenSet[int]:	1✔
118	"""
119	The destination processors of the entry.
120
121	:rtype: frozenset(int)
122	"""
123	return frozenset(i for i in range(_N_PROCS)	1✔
124	if self._links_and_procs & (_OUTGOING_PROC_1 << i))
125
126	@property	1✔
127	def link_ids(self) -> FrozenSet[int]:	1✔
128	"""
129	The destination links of the entry.
130
131	:rtype: frozenset(int)
132	"""
133	return frozenset(i for i in range(_N_LINKS)	1✔
134	if self._links_and_procs & (_OUTGOING_LINK_1 << i))
135
136	@property	1✔
137	def incoming_link(self) -> Optional[int]:	1✔
138	"""
139	The source link for this path entry.
140
141	:rtype: int or None
142	"""
143	link = ((self._links_and_procs & _INCOMING_LINK_MASK) >>	1✔
144	_INCOMING_LINK_SHIFT)
145	if link == 0:	1✔
146	return None	1✔
147	# Subtract 1 as 0 means not set
148	return link - 1	1✔
149
150	@incoming_link.setter	1✔
151	def incoming_link(self, incoming_link: int):	1✔
UNCOV 152	if self.incoming_processor is not None:	×
153	raise PacmanConfigurationException(	×
154	f"Entry already has an incoming processor "
155	f"{self.incoming_processor}")
UNCOV 156	self_link = self.incoming_link	×
UNCOV 157	if self_link is not None and self_link != incoming_link:	×
158	raise PacmanConfigurationException(	×
159	f"Entry already has an incoming link {self_link}")
UNCOV 160	self.__set_incoming_link(incoming_link)	×
161
162	@property	1✔
163	def incoming_processor(self) -> Optional[int]:	1✔
164	"""
165	The source processor.
166
167	:rtype: int or None
168	"""
169	proc = ((self._links_and_procs & _INCOMING_PROC_MASK) >>	1✔
170	_INCOMING_PROC_SHIFT)
171	if proc == 0:	1✔
172	return None	1✔
173	# Subtract 1 as 0 means not set
174	return proc - 1	1✔
175
176	@incoming_processor.setter	1✔
177	def incoming_processor(self, incoming_processor: int):	1✔
UNCOV 178	if self.incoming_link is not None:	×
179	raise PacmanConfigurationException(	×
180	f"Entry already has an incoming link {self.incoming_link}")
UNCOV 181	self_proc = self.incoming_processor	×
UNCOV 182	if self_proc is not None and self_proc != incoming_processor:	×
183	raise PacmanConfigurationException(	×
184	f"Entry already has an incoming processor {self_proc}")
UNCOV 185	self.__set_incoming_proc(incoming_processor)	×
186
187	@property	1✔
188	def defaultable(self) -> bool:	1✔
189	"""
190	The defaultable status of the entry.
191
192	:rtype: bool
193	"""
194	if self.incoming_processor is not None:	1✔
195	return False	1✔
196	in_link = self.incoming_link	1✔
197	if in_link is None:	1✔
198	return False	1✔
199	out_links = self.link_ids	1✔
200	if len(out_links) != 1:	1✔
201	return False	1✔
202	if self.processor_ids:	1✔
203	return False	1✔
204	out_link = next(iter(out_links))	1✔
205	return ((in_link + 3) % 6) == out_link	1✔
206
207	@staticmethod	1✔
208	def __merge_none_or_equal(p1, p2, name):	1✔
209	if p1 is None:	1✔
210	return p2	1✔
211	if p2 is None or p2 == p1:	1!
212	return p1	1✔
213	raise PacmanInvalidParameterException(	×
214	name, "invalid merge",
215	"The two MulticastRoutingTableByPartitionEntry have "
216	"different " + name + "s, and so can't be merged")
217
218	def merge_entry(self, other: MulticastRoutingTableByPartitionEntry) -> \	1✔
219	MulticastRoutingTableByPartitionEntry:
220	"""
221	Merges the another entry with this one and returns a new
222	MulticastRoutingTableByPartitionEntry
223
224	:param MulticastRoutingTableByPartitionEntry other:
225	the entry to merge into this one
226	:return: a merged MulticastRoutingTableByPartitionEntry
227	:raises PacmanInvalidParameterException:
228	"""
229	# pylint:disable=protected-access
230	if not isinstance(other, MulticastRoutingTableByPartitionEntry):	1!
231	raise PacmanInvalidParameterException(	×
232	"other", "type error",
233	"The other parameter is not an instance of "
234	"MulticastRoutingTableByPartitionEntry, and therefore cannot "
235	"be merged.")
236
237	# validate incoming
238	try:	1✔
239	in_proc = self.__merge_none_or_equal(	1✔
240	self.incoming_processor, other.incoming_processor,
241	"incoming_processor")
242	in_link = self.__merge_none_or_equal(	1✔
243	self.incoming_link, other.incoming_link, "incoming_link")
244	if in_proc is not None and in_link is not None:	1✔
245	raise PacmanInvalidParameterException(	1✔
246	"other", "merge error",
247	f"Cannot merge {other} and {self}: both incoming processor"
248	" and link are set")
249	except PacmanInvalidParameterException as e:	1✔
250	log.error("Error merging entry {} into {}", other, self)	1✔
251	raise e	1✔
252
253	# Set the value directly as faster
254	entry = MulticastRoutingTableByPartitionEntry(None, None)	1✔
255	entry._links_and_procs = self._links_and_procs \| other._links_and_procs	1✔
256	return entry	1✔
257
258	def __repr__(self) -> str:	1✔
259	return (f"{self.incoming_link}:{self.incoming_processor}:"	1✔
260	f"{self.defaultable}:"
261	f"{{{', '.join(map(str, self.link_ids))}}}:"
262	f"{{{', '.join(map(str, self.processor_ids))}}}")
263
264	def has_same_route(	1✔
265	self, entry: MulticastRoutingTableByPartitionEntry) -> bool:
266	"""
267	Checks if the two Entries have the same routes after applying mask
268
269	:param MulticastRoutingTableByPartitionEntry entry:
270	:rtype: bool
271	"""
272	# pylint:disable=protected-access
273	return ((self._links_and_procs & _COMPARE_MASK) ==	1✔
274	(entry._links_and_procs & _COMPARE_MASK))
275
276	@property	1✔
277	def spinnaker_route(self) -> int:	1✔
278	"""
279	The masked routes
280
281	:rtype: int
282	"""
283	return self._links_and_procs & _SPINNAKER_ROUTE_MASK	1✔

SpiNNakerManchester / PACMAN / 8448558431

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