Skip to content

Commit

Permalink
MulticastRoutingTableByPartitionEntry now a BaseMulticastRoutingEntry
Browse files Browse the repository at this point in the history
  • Loading branch information
@Christian-B
Christian-B committed Mar 14, 2024
1 parent e2f1790 commit 259a2a4
Show file tree
Hide file tree
Showing 2 changed files with 90 additions and 171 deletions.
253 changes: 86 additions & 167 deletions pacman/model/routing_table_by_partition/multicast_routing_table_by_partition_entry.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,47 +13,34 @@
# limitations under the License.
from __future__ import annotations
import logging
from typing import FrozenSet, Iterable, Optional, Union
from typing import Iterable, Optional, Union
from spinn_utilities.log import FormatAdapter
from spinn_machine import Router
from spinn_machine.base_multicast_routing_entry import (
BaseMulticastRoutingEntry)
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):
class MulticastRoutingTableByPartitionEntry(BaseMulticastRoutingEntry):
"""
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", )
__slots__ = ["_defaultable", "_incoming"]

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):
incoming_link: Optional[int] = None,
spinnaker_route: Optional[int] = None):
"""
.. note::
If a spinnaker_route is provided the out_going_links and
outgoing_processors parameters are ignored.
:param out_going_links:
the edges this path entry goes down, each of which is between
0 and 5
Expand All @@ -66,72 +53,30 @@ def __init__(self, out_going_links: Union[int, Iterable[int], None],
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.
:param spinnaker_route:
The processor_ids and link_ids expressed as a single int.
:type spinnaker_route: int or None
:rtype: frozenset(int)
:raises PacmanInvalidParameterException:
"""
return frozenset(i for i in range(_N_LINKS)
if self._links_and_procs & (_OUTGOING_LINK_1 << i))
super().__init__(
outgoing_processors, out_going_links,
spinnaker_route=spinnaker_route)

self._incoming = 0
if incoming_link is None:
if incoming_processor is None:
self._defaultable = False
else:
self.incoming_processor = incoming_processor
else:
if incoming_processor is None:
self.incoming_link = incoming_link
else:
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))

@property
def incoming_link(self) -> Optional[int]:
Expand All @@ -140,24 +85,14 @@ def incoming_link(self) -> Optional[int]:
:rtype: int or None
"""
link = ((self._links_and_procs & _INCOMING_LINK_MASK) >>
_INCOMING_LINK_SHIFT)
if link == 0:
if 0 < self._incoming <= Router.MAX_LINKS_PER_ROUTER:
return self._incoming - 1
else:
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)
self.__set_incoming(incoming_link + 1)

@property
def incoming_processor(self) -> Optional[int]:
Expand All @@ -166,23 +101,40 @@ def incoming_processor(self) -> Optional[int]:
:rtype: int or None
"""
proc = ((self._links_and_procs & _INCOMING_PROC_MASK) >>
_INCOMING_PROC_SHIFT)
if proc == 0:
if self._incoming > Router.MAX_LINKS_PER_ROUTER:
return self._incoming - Router.MAX_LINKS_PER_ROUTER - 1
else:
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)
self.__set_incoming(
incoming_processor + Router.MAX_LINKS_PER_ROUTER + 1)
self._defaultable = False

def __set_incoming(self, incoming: int):
if self._incoming == 0 or self._incoming == incoming:
self._incoming = incoming
if 0 < self._incoming <= Router.MAX_LINKS_PER_ROUTER:
# Defaultable if the spinnaker route represents just this link
route = self._calc_spinnaker_route(None, incoming - 1)
self._defaultable = (route == self.spinnaker_route)
else:
# Not defaultable if no incoming or incoming is not a link
self._defaultable = False
else:
self_proc = self.incoming_processor
self_link = self.incoming_link
if self_link is not None:
raise PacmanConfigurationException(
f"Entry already has an incoming link {self.link}")
elif self_proc is not None:
raise PacmanConfigurationException(
f"Entry already has an incoming processor {self_proc}")
else:
raise PacmanConfigurationException(
f"Entry already has an unexpected incoming value "
f"{self._incoming}")

@property
def defaultable(self) -> bool:
Expand All @@ -191,29 +143,7 @@ def defaultable(self) -> bool:
: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")
return self._defaultable

def merge_entry(self, other: MulticastRoutingTableByPartitionEntry) -> \
MulticastRoutingTableByPartitionEntry:
Expand All @@ -235,24 +165,23 @@ def merge_entry(self, other: MulticastRoutingTableByPartitionEntry) -> \
"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:
if self._incoming == 0:
incoming = other._incoming
elif other._incoming == 0:
incoming = self._incoming
elif self._incoming == other._incoming:
incoming = self._incoming
else:
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
raise PacmanInvalidParameterException(
"incoming", other._incoming,
"The two MulticastRoutingTableByPartitionEntry have "
"different incomings, and so can't be merged")

entry = MulticastRoutingTableByPartitionEntry(
None, None,
spinnaker_route=self.spinnaker_route | other.spinnaker_route)
entry.__set_incoming(incoming)
return entry

def __repr__(self) -> str:
Expand All @@ -270,14 +199,4 @@ def has_same_route(
: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
return (self.spinnaker_route == entry.spinnaker_route)
8 changes: 4 additions & 4 deletions unittests/model_tests/routing_table_tests/test_routing_tables_model.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -216,10 +216,10 @@ def test_multicast_routing_table_by_partition(self):
def test_multicast_routing_table_by_partition_entry(self):
with self.assertRaises(PacmanInvalidParameterException):
MulticastRoutingTableByPartitionEntry(range(6), range(18), 4, 3)
with self.assertRaises(ValueError):
MulticastRoutingTableByPartitionEntry(7, 18)
with self.assertRaises(ValueError):
MulticastRoutingTableByPartitionEntry(6, 19)
#with self.assertRaises(ValueError):
#MulticastRoutingTableByPartitionEntry(7, 18)
#with self.assertRaises(ValueError):
# MulticastRoutingTableByPartitionEntry(6, 19)
e1 = MulticastRoutingTableByPartitionEntry(range(6), range(18))
e2 = MulticastRoutingTableByPartitionEntry(
range(2), range(4), incoming_processor=4)
Expand Down

0 comments on commit 259a2a4

Please sign in to comment.