7003792688

Committed 27 Nov 2023 10:35AM UTC coverage: 84.279% (+0.6%) from 83.65%

Build # 7003792688

Build Type

Pull #516

github

Committed by

rowleya

Commit Message

Duplicate here

Pull Request Pull Request #516: Interdimensional compatibility

Run Details

1574 of 2046 branches covered (0.0%)

Branch coverage included in aggregate %.

138 of 166 new or added lines in 12 files covered. (83.13%)

12 existing lines in 4 files now uncovered.

5143 of 5924 relevant lines covered (86.82%)

0.87 hits per line

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

53.7

/pacman/model/graphs/application/abstract/abstract_2d_device_vertex.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.
import math
from typing import Tuple
from spinn_utilities.abstract_base import AbstractBase, abstractmethod
from spinn_utilities.overrides import overrides
from spinn_utilities.typing.coords import XY
from pacman.exceptions import PacmanConfigurationException
from pacman.utilities.utility_calls import get_n_bits, is_power_of_2
from pacman.utilities.constants import BITS_IN_KEY
from pacman.model.routing_info.base_key_and_mask import BaseKeyAndMask
from pacman.model.graphs.application import ApplicationVertex
from pacman.model.graphs.common import MDSlice


class Abstract2DDeviceVertex(object, metaclass=AbstractBase):
    """
    A helper for 2D input devices.

    .. note::
        This assumes that
        the input keys will contain a field for each of the X and Y dimensions
        with X field in the LSBs and the Y field in the next adjacent bits.  If
        the fields are in different places, override the methods:
        `_source_x_shift`, `_source_y_shift`, `_source_x_mask` and
        `_source_y_mask`.
        If the key has bits in addition to the X and Y values, you can also
        override `_key_shift`.
    """

    @property
    @abstractmethod
    def width(self) -> int:
        """
        The width of the device.

        :rtype: int
        """
        raise NotImplementedError

    @property
    @abstractmethod
    def height(self) -> int:
        """
        The height of the device.

        :rtype: int
        """
        raise NotImplementedError

    @property
    @abstractmethod
    def sub_width(self) -> int:
        """
        The width of the sub-rectangles to divide the input into.

        :rtype: int
        """
        raise NotImplementedError

    @property
    @abstractmethod
    def sub_height(self) -> int:
        """
        The height of the sub-rectangles to divide the input into.

        :rtype: int
        """
        raise NotImplementedError

    @property
    @abstractmethod
    @overrides(ApplicationVertex.atoms_shape)
    def atoms_shape(self) -> Tuple[int, ...]:
        raise NotImplementedError

    def _verify_sub_size(self) -> None:
        """
        Ensure the sub width and height are within restrictions.
        """
        if not is_power_of_2(self.sub_width):
            raise PacmanConfigurationException(
                f"sub_width ({self.sub_width}) must be a power of 2")
        if not is_power_of_2(self.sub_height):
            raise PacmanConfigurationException(
                f"sub_height ({self.sub_height}) must be a power of 2")
        if self.sub_width > self.width:
            raise PacmanConfigurationException(
                f"sub_width ({self.sub_width}) must not be greater than "
                f"width ({self.width})")
        if self.sub_height > self.height:
            raise PacmanConfigurationException(
                f"sub_height ({self.sub_height}) must not be greater than "
                f"height ({self.height})")

    @property
    def _n_sub_rectangles(self) -> int:
        """
        The number of sub-rectangles the device is made up of.

        :rtype: int
        """
        return (int(math.ceil(self.width / self.sub_width)) *
                int(math.ceil(self.height / self.sub_height)))

    def _sub_square_from_index(self, index: int) -> XY:
        """
        Work out the x and y components of the index.

        :param int index: The index of the sub square
        :rtype: tuple(int, int)
        """
        n_squares_per_row = int(math.ceil(
            self.width / self.sub_width))
        x_index = index % n_squares_per_row
        y_index = index // n_squares_per_row

        # Return the information
        return x_index, y_index

    def _get_slice(self, index: int) -> MDSlice:
        """
        Get the slice for the given machine vertex index.

        :param int index: The machine vertex index
        :rtype: Slice
        """
        x_index, y_index = self._sub_square_from_index(index)
        lo_atom_x = x_index * self.sub_width
        lo_atom_y = y_index * self.sub_height
        n_atoms_per_subsquare = self.sub_width * self.sub_height
        lo_atom = index * n_atoms_per_subsquare
        hi_atom = (lo_atom + n_atoms_per_subsquare) - 1
        return MDSlice(
            lo_atom, hi_atom, (self.sub_width, self.sub_height),
            (lo_atom_x, lo_atom_y), self.atoms_shape)

    def _get_key_and_mask(self, base_key: int, index: int) -> BaseKeyAndMask:
        """
        Get the key and mask of the given machine vertex index.

        :param int base_key: The unshifted key to use
        :param int index: The machine vertex index
        :rtype: BaseKeyAndMask
        """
        x_index, y_index = self._sub_square_from_index(index)
        key_bits = base_key << self._key_shift
        key = (key_bits +
               (y_index << self._y_index_shift) +
               (x_index << self._x_index_shift))
        return BaseKeyAndMask(key, self._mask)

    @property
    def _mask(self) -> int:
        """
        The mask to be used for the key.

        :rtype: int
        """
        n_key_bits = BITS_IN_KEY - self._key_shift
        key_mask = (1 << n_key_bits) - 1
        sub_x_mask = (1 << self._sub_x_bits) - 1
        sub_y_mask = (1 << self._sub_y_bits) - 1
        return ((key_mask << self._key_shift) +
                (sub_y_mask << self._y_index_shift) +
                (sub_x_mask << self._x_index_shift))

    @property
    def _x_bits(self) -> int:
        """
        The number of bits to use for X.

        :rtype: int
        """
        return get_n_bits(self.width)

    @property
    def _y_bits(self) -> int:
        """
        The number of bits to use for Y.

        :rtype: int
        """
        return get_n_bits(self.height)

    @property
    def _sub_x_bits(self) -> int:
        """
        The number of bits to use for the X coordinate of a sub-rectangle.

        :rtype: int
        """
        n_per_row = int(math.ceil(self.width / self.sub_width))
        return get_n_bits(n_per_row)

    @property
    def _sub_y_bits(self) -> int:
        """
        The number of bits to use for the Y coordinate of a sub-rectangle.

        :rtype: int
        """
        n_per_col = int(math.ceil(self.height / self.sub_height))
        return get_n_bits(n_per_col)

    @property
    def _x_index_shift(self) -> int:
        """
        The shift to apply to the key to get the sub-X coordinate.

        :rtype: int
        """
        return self._source_x_shift + (self._x_bits - self._sub_x_bits)

    @property
    def _y_index_shift(self) -> int:
        """
        The shift to apply to the key to get the sub-Y coordinate.

        :rtype: int
        """
        return self._source_y_shift + (self._y_bits - self._sub_y_bits)

    @property
    def _source_x_mask(self) -> int:
        """
        The mask to apply to the key *before* shifting to get the
        X coordinate.

        :rtype: int
        """
        return (1 << self._x_bits) - 1

    @property
    def _source_x_shift(self) -> int:
        """
        The shift to apply to the key *after* masking to get the
        X coordinate.

        :rtype: int
        """
        return 0

    @property
    def _source_y_mask(self) -> int:
        """
        The mask to apply to the key *before* shifting to get the
        Y coordinate.

        :rtype: int
        """
        return ((1 << self._y_bits) - 1) << self._x_bits

    @property
    def _source_y_shift(self) -> int:
        """
        The shift to apply to the key *after* masking to get the
        Y coordinate.

        :rtype: int
        """
        return self._x_bits

    @property
    def _key_shift(self) -> int:
        """
        The shift to apply to the key to get the base key.

        :rtype: int
        """
        return self._y_bits + self._x_bits

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	import math	1✔
15	from typing import Tuple	1✔
16	from spinn_utilities.abstract_base import AbstractBase, abstractmethod	1✔
17	from spinn_utilities.overrides import overrides	1✔
18	from spinn_utilities.typing.coords import XY	1✔
19	from pacman.exceptions import PacmanConfigurationException	1✔
20	from pacman.utilities.utility_calls import get_n_bits, is_power_of_2	1✔
21	from pacman.utilities.constants import BITS_IN_KEY	1✔
22	from pacman.model.routing_info.base_key_and_mask import BaseKeyAndMask	1✔
23	from pacman.model.graphs.application import ApplicationVertex	1✔
24	from pacman.model.graphs.common import MDSlice	1✔
25
26
27	class Abstract2DDeviceVertex(object, metaclass=AbstractBase):	1✔
28	"""
29	A helper for 2D input devices.
30
31	.. note::
32	This assumes that
33	the input keys will contain a field for each of the X and Y dimensions
34	with X field in the LSBs and the Y field in the next adjacent bits. If
35	the fields are in different places, override the methods:
36	`_source_x_shift`, `_source_y_shift`, `_source_x_mask` and
37	`_source_y_mask`.
38	If the key has bits in addition to the X and Y values, you can also
39	override `_key_shift`.
40	"""
41
42	@property	1✔
43	@abstractmethod	1✔
44	def width(self) -> int:	1✔
45	"""
46	The width of the device.
47
48	:rtype: int
49	"""
50	raise NotImplementedError
51
52	@property	1✔
53	@abstractmethod	1✔
54	def height(self) -> int:	1✔
55	"""
56	The height of the device.
57
58	:rtype: int
59	"""
60	raise NotImplementedError
61
62	@property	1✔
63	@abstractmethod	1✔
64	def sub_width(self) -> int:	1✔
65	"""
66	The width of the sub-rectangles to divide the input into.
67
68	:rtype: int
69	"""
70	raise NotImplementedError
71
72	@property	1✔
73	@abstractmethod	1✔
74	def sub_height(self) -> int:	1✔
75	"""
76	The height of the sub-rectangles to divide the input into.
77
78	:rtype: int
79	"""
80	raise NotImplementedError
81
82	@property	1✔
83	@abstractmethod	1✔
84	@overrides(ApplicationVertex.atoms_shape)	1✔
85	def atoms_shape(self) -> Tuple[int, ...]:	1✔
86	raise NotImplementedError
87
88	def _verify_sub_size(self) -> None:	1✔
89	"""
90	Ensure the sub width and height are within restrictions.
91	"""
NEW 92	if not is_power_of_2(self.sub_width):	×
93	raise PacmanConfigurationException(	×
94	f"sub_width ({self.sub_width}) must be a power of 2")
NEW 95	if not is_power_of_2(self.sub_height):	×
UNCOV 96	raise PacmanConfigurationException(	×
97	f"sub_height ({self.sub_height}) must be a power of 2")
NEW 98	if self.sub_width > self.width:	×
UNCOV 99	raise PacmanConfigurationException(	×
100	f"sub_width ({self.sub_width}) must not be greater than "
101	f"width ({self.width})")
NEW 102	if self.sub_height > self.height:	×
UNCOV 103	raise PacmanConfigurationException(	×
104	f"sub_height ({self.sub_height}) must not be greater than "
105	f"height ({self.height})")
106
107	@property	1✔
108	def _n_sub_rectangles(self) -> int:	1✔
109	"""
110	The number of sub-rectangles the device is made up of.
111
112	:rtype: int
113	"""
NEW 114	return (int(math.ceil(self.width / self.sub_width)) *	×
115	int(math.ceil(self.height / self.sub_height)))
116
117	def _sub_square_from_index(self, index: int) -> XY:	1✔
118	"""
119	Work out the x and y components of the index.
120
121	:param int index: The index of the sub square
122	:rtype: tuple(int, int)
123	"""
124	n_squares_per_row = int(math.ceil(	×
125	self.width / self.sub_width))
126	x_index = index % n_squares_per_row	×
127	y_index = index // n_squares_per_row	×
128
129	# Return the information
130	return x_index, y_index	×
131
132	def _get_slice(self, index: int) -> MDSlice:	1✔
133	"""
134	Get the slice for the given machine vertex index.
135
136	:param int index: The machine vertex index
137	:rtype: Slice
138	"""
139	x_index, y_index = self._sub_square_from_index(index)	×
NEW 140	lo_atom_x = x_index * self.sub_width	×
NEW 141	lo_atom_y = y_index * self.sub_height	×
NEW 142	n_atoms_per_subsquare = self.sub_width * self.sub_height	×
143	lo_atom = index * n_atoms_per_subsquare	×
144	hi_atom = (lo_atom + n_atoms_per_subsquare) - 1	×
145	return MDSlice(	×
146	lo_atom, hi_atom, (self.sub_width, self.sub_height),
147	(lo_atom_x, lo_atom_y), self.atoms_shape)
148
149	def _get_key_and_mask(self, base_key: int, index: int) -> BaseKeyAndMask:	1✔
150	"""
151	Get the key and mask of the given machine vertex index.
152
153	:param int base_key: The unshifted key to use
154	:param int index: The machine vertex index
155	:rtype: BaseKeyAndMask
156	"""
157	x_index, y_index = self._sub_square_from_index(index)	×
158	key_bits = base_key << self._key_shift	×
159	key = (key_bits +	×
160	(y_index << self._y_index_shift) +
161	(x_index << self._x_index_shift))
162	return BaseKeyAndMask(key, self._mask)	×
163
164	@property	1✔
165	def _mask(self) -> int:	1✔
166	"""
167	The mask to be used for the key.
168
169	:rtype: int
170	"""
171	n_key_bits = BITS_IN_KEY - self._key_shift	×
172	key_mask = (1 << n_key_bits) - 1	×
173	sub_x_mask = (1 << self._sub_x_bits) - 1	×
174	sub_y_mask = (1 << self._sub_y_bits) - 1	×
175	return ((key_mask << self._key_shift) +	×
176	(sub_y_mask << self._y_index_shift) +
177	(sub_x_mask << self._x_index_shift))
178
179	@property	1✔
180	def _x_bits(self) -> int:	1✔
181	"""
182	The number of bits to use for X.
183
184	:rtype: int
185	"""
NEW 186	return get_n_bits(self.width)	×
187
188	@property	1✔
189	def _y_bits(self) -> int:	1✔
190	"""
191	The number of bits to use for Y.
192
193	:rtype: int
194	"""
NEW 195	return get_n_bits(self.height)	×
196
197	@property	1✔
198	def _sub_x_bits(self) -> int:	1✔
199	"""
200	The number of bits to use for the X coordinate of a sub-rectangle.
201
202	:rtype: int
203	"""
NEW 204	n_per_row = int(math.ceil(self.width / self.sub_width))	×
205	return get_n_bits(n_per_row)	×
206
207	@property	1✔
208	def _sub_y_bits(self) -> int:	1✔
209	"""
210	The number of bits to use for the Y coordinate of a sub-rectangle.
211
212	:rtype: int
213	"""
NEW 214	n_per_col = int(math.ceil(self.height / self.sub_height))	×
215	return get_n_bits(n_per_col)	×
216
217	@property	1✔
218	def _x_index_shift(self) -> int:	1✔
219	"""
220	The shift to apply to the key to get the sub-X coordinate.
221
222	:rtype: int
223	"""
224	return self._source_x_shift + (self._x_bits - self._sub_x_bits)	×
225
226	@property	1✔
227	def _y_index_shift(self) -> int:	1✔
228	"""
229	The shift to apply to the key to get the sub-Y coordinate.
230
231	:rtype: int
232	"""
233	return self._source_y_shift + (self._y_bits - self._sub_y_bits)	×
234
235	@property	1✔
236	def _source_x_mask(self) -> int:	1✔
237	"""
238	The mask to apply to the key before shifting to get the
239	X coordinate.
240
241	:rtype: int
242	"""
243	return (1 << self._x_bits) - 1	×
244
245	@property	1✔
246	def _source_x_shift(self) -> int:	1✔
247	"""
248	The shift to apply to the key after masking to get the
249	X coordinate.
250
251	:rtype: int
252	"""
253	return 0	×
254
255	@property	1✔
256	def _source_y_mask(self) -> int:	1✔
257	"""
258	The mask to apply to the key before shifting to get the
259	Y coordinate.
260
261	:rtype: int
262	"""
263	return ((1 << self._y_bits) - 1) << self._x_bits	×
264
265	@property	1✔
266	def _source_y_shift(self) -> int:	1✔
267	"""
268	The shift to apply to the key after masking to get the
269	Y coordinate.
270
271	:rtype: int
272	"""
273	return self._x_bits	×
274
275	@property	1✔
276	def _key_shift(self) -> int:	1✔
277	"""
278	The shift to apply to the key to get the base key.
279
280	:rtype: int
281	"""
282	return self._y_bits + self._x_bits	×

SpiNNakerManchester / PACMAN / 7003792688

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