8322667110

Committed 18 Mar 2024 07:15AM UTC coverage: 86.14% (+2.1%) from 84.006%

Build # 8322667110

Build Type

push

github

Committed by

Christian-B

Commit Message

uncomment for spell checker

Run Details

2684 of 3183 branches covered (84.32%)

Branch coverage included in aggregate %.

0 of 3 new or added lines in 1 file covered. (0.0%)

311 existing lines in 32 files now uncovered.

5178 of 5944 relevant lines covered (87.11%)

0.87 hits per line

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

93.15

/pacman/model/graphs/application/application_spinnaker_link_vertex.py

# Copyright (c) 2016 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.

import math
from typing import Optional
from spinn_utilities.overrides import overrides
from spinn_machine import Machine
from spinn_machine.link_data_objects import SpinnakerLinkData
from pacman.model.graphs.common.slice import Slice
from .application_virtual_vertex import ApplicationVirtualVertex


class ApplicationSpiNNakerLinkVertex(ApplicationVirtualVertex):
    """
    A virtual application vertex on a SpiNNaker Link.
    """

    __slots__ = (
        "_n_atoms",
        "_spinnaker_link_id",
        "_board_address",
        "_n_machine_vertices",
        "_incoming",
        "_outgoing")

    def __init__(
            self, n_atoms: int, spinnaker_link_id: int,
            board_address: Optional[str] = None, label: Optional[str] = None,
            n_machine_vertices: int = 1,
            incoming: bool = True, outgoing: bool = True):
        """
        :param int n_atoms: The number of atoms in the vertex
        :param int spinnaker_link_id:
            The index of the spinnaker link to which the device is connected
        :param str board_address:
            The optional IP address of the board to which the device is
            connected e.g. in a multi-board system
        :param str label: The optional name of the vertex.
        :param bool incoming:
        :param bool outgoing:
        """
        super().__init__(label=label)
        self._n_atoms = self.round_n_atoms(n_atoms)
        self._spinnaker_link_id = spinnaker_link_id
        self._board_address = board_address
        self._n_machine_vertices = n_machine_vertices
        self._incoming = incoming
        self._outgoing = outgoing

    @property
    @overrides(ApplicationVirtualVertex.n_atoms)
    def n_atoms(self) -> int:
        return self._n_atoms

    @property
    def spinnaker_link_id(self) -> int:
        """
        The SpiNNaker link to which this device is connected.

        :rtype: int
        """
        return self._spinnaker_link_id

    @property
    def board_address(self) -> Optional[str]:
        """
        The board to which this device is connected, or `None` for the
        default board.

        :rtype: str or None
        """
        return self._board_address

    @property
    def n_machine_vertices(self) -> int:
        """
        The number of machine vertices to create.

        :rtype: int
        """
        return self._n_machine_vertices

    def get_incoming_slice(self, index: int) -> Slice:
        """
        Get the slice to be given to the connection.

        :param int index:
            The index of the connection, for when n_machine_vertices > 1

        :rtype: ~pacman.model.graphs.common.Slice
        """
        atoms_per_slice = int(math.ceil(
            self._n_atoms / self._n_machine_vertices))
        low_atom = atoms_per_slice * index
        hi_atom = (atoms_per_slice * (index + 1)) - 1
        hi_atom = min((hi_atom, self.n_atoms - 1))
        return Slice(low_atom, hi_atom)

    def get_outgoing_slice(self) -> Slice:
        """
        Get the slice to be given to the outgoing connection.

        :rtype: ~pacman.model.graphs.common.Slice
        """
        return Slice(0, self.n_atoms - 1)

    @property
    def incoming(self) -> bool:
        """
        Reports if this vertex supports incoming links

        :rtype: bool
        """
        return self._incoming

    @property
    def outgoing(self) -> bool:
        """
        Reports if this vertex supports incoming links

        :rtype: bool
        """
        return self._outgoing

    @overrides(ApplicationVirtualVertex.get_outgoing_link_data)
    def get_outgoing_link_data(self, machine: Machine) -> SpinnakerLinkData:
        if not self._outgoing:
            raise NotImplementedError("This vertex doesn't have outgoing data")
        link = machine.get_spinnaker_link_with_id(
            self._spinnaker_link_id, self._board_address)
        assert link is not None, f"no link data for {self} on {machine}"
        return link

    @overrides(ApplicationVirtualVertex.get_max_atoms_per_core)
    def get_max_atoms_per_core(self) -> int:
        return int(math.ceil(self._n_atoms / self._n_machine_vertices))

1	# Copyright (c) 2016 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
15	import math	1✔
16	from typing import Optional	1✔
17	from spinn_utilities.overrides import overrides	1✔
18	from spinn_machine import Machine	1✔
19	from spinn_machine.link_data_objects import SpinnakerLinkData	1✔
20	from pacman.model.graphs.common.slice import Slice	1✔
21	from .application_virtual_vertex import ApplicationVirtualVertex	1✔
22
23
24	class ApplicationSpiNNakerLinkVertex(ApplicationVirtualVertex):	1✔
25	"""
26	A virtual application vertex on a SpiNNaker Link.
27	"""
28
29	__slots__ = (	1✔
30	"_n_atoms",
31	"_spinnaker_link_id",
32	"_board_address",
33	"_n_machine_vertices",
34	"_incoming",
35	"_outgoing")
36
37	def __init__(	1✔
38	self, n_atoms: int, spinnaker_link_id: int,
39	board_address: Optional[str] = None, label: Optional[str] = None,
40	n_machine_vertices: int = 1,
41	incoming: bool = True, outgoing: bool = True):
42	"""
43	:param int n_atoms: The number of atoms in the vertex
44	:param int spinnaker_link_id:
45	The index of the spinnaker link to which the device is connected
46	:param str board_address:
47	The optional IP address of the board to which the device is
48	connected e.g. in a multi-board system
49	:param str label: The optional name of the vertex.
50	:param bool incoming:
51	:param bool outgoing:
52	"""
53	super().__init__(label=label)	1✔
54	self._n_atoms = self.round_n_atoms(n_atoms)	1✔
55	self._spinnaker_link_id = spinnaker_link_id	1✔
56	self._board_address = board_address	1✔
57	self._n_machine_vertices = n_machine_vertices	1✔
58	self._incoming = incoming	1✔
59	self._outgoing = outgoing	1✔
60
61	@property	1✔
62	@overrides(ApplicationVirtualVertex.n_atoms)	1✔
63	def n_atoms(self) -> int:	1✔
64	return self._n_atoms	1✔
65
66	@property	1✔
67	def spinnaker_link_id(self) -> int:	1✔
68	"""
69	The SpiNNaker link to which this device is connected.
70
71	:rtype: int
72	"""
73	return self._spinnaker_link_id	1✔
74
75	@property	1✔
76	def board_address(self) -> Optional[str]:	1✔
77	"""
78	The board to which this device is connected, or `None` for the
79	default board.
80
81	:rtype: str or None
82	"""
83	return self._board_address	1✔
84
85	@property	1✔
86	def n_machine_vertices(self) -> int:	1✔
87	"""
88	The number of machine vertices to create.
89
90	:rtype: int
91	"""
92	return self._n_machine_vertices	1✔
93
94	def get_incoming_slice(self, index: int) -> Slice:	1✔
95	"""
96	Get the slice to be given to the connection.
97
98	:param int index:
99	The index of the connection, for when n_machine_vertices > 1
100
101	:rtype: ~pacman.model.graphs.common.Slice
102	"""
103	atoms_per_slice = int(math.ceil(	1✔
104	self._n_atoms / self._n_machine_vertices))
105	low_atom = atoms_per_slice * index	1✔
106	hi_atom = (atoms_per_slice * (index + 1)) - 1	1✔
107	hi_atom = min((hi_atom, self.n_atoms - 1))	1✔
108	return Slice(low_atom, hi_atom)	1✔
109
110	def get_outgoing_slice(self) -> Slice:	1✔
111	"""
112	Get the slice to be given to the outgoing connection.
113
114	:rtype: ~pacman.model.graphs.common.Slice
115	"""
116	return Slice(0, self.n_atoms - 1)	1✔
117
118	@property	1✔
119	def incoming(self) -> bool:	1✔
120	"""
121	Reports if this vertex supports incoming links
122
123	:rtype: bool
124	"""
125	return self._incoming	1✔
126
127	@property	1✔
128	def outgoing(self) -> bool:	1✔
129	"""
130	Reports if this vertex supports incoming links
131
132	:rtype: bool
133	"""
134	return self._outgoing	1✔
135
136	@overrides(ApplicationVirtualVertex.get_outgoing_link_data)	1✔
137	def get_outgoing_link_data(self, machine: Machine) -> SpinnakerLinkData:	1✔
UNCOV 138	if not self._outgoing:	×
139	raise NotImplementedError("This vertex doesn't have outgoing data")
UNCOV 140	link = machine.get_spinnaker_link_with_id(	×
141	self._spinnaker_link_id, self._board_address)
UNCOV 142	assert link is not None, f"no link data for {self} on {machine}"	×
UNCOV 143	return link	×
144
145	@overrides(ApplicationVirtualVertex.get_max_atoms_per_core)	1✔
146	def get_max_atoms_per_core(self) -> int:	1✔
UNCOV 147	return int(math.ceil(self._n_atoms / self._n_machine_vertices))	×

SpiNNakerManchester / PACMAN / 8322667110

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