6617445310

Committed 20 Oct 2023 03:00PM UTC coverage: 83.707% (+0.4%) from 83.276%

Build # 6617445310

Build Type

Pull #513

github

Committed by

Christian-B

Commit Message

merge

Pull Request Pull Request #513: Type Annotations and Checking

Run Details

1551 of 2032 branches covered (0.0%)

Branch coverage included in aggregate %.

1914 of 1914 new or added lines in 95 files covered. (100.0%)

5020 of 5818 relevant lines covered (86.28%)

0.86 hits per line

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

45.59

/pacman/utilities/algorithm_utilities/partition_algorithm_utilities.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.
"""
A collection of methods which support partitioning algorithms.
"""

import math
from typing import List
from pacman.exceptions import PacmanConfigurationException
from pacman.model.graphs.common import MDSlice, Slice
from pacman.model.graphs.application import ApplicationVertex


def get_multidimensional_slices(
        app_vertex: ApplicationVertex) -> List[Slice]:
    """
    Get the multi-dimensional slices of an application vertex
    such that each is sized to the maximum atoms per dimension per core
    except the last, which might be smaller in one or more dimensions.

    :param ApplicationVertex app_vertex: The vertex to get the slices of
    :return: The slices
    :rtype: list(~pacman.model.graphs.common.Slice)
    """
    atoms_per_core = app_vertex.get_max_atoms_per_dimension_per_core()
    n_atoms = app_vertex.atoms_shape
    if len(atoms_per_core) != len(n_atoms):
        raise PacmanConfigurationException(
            "The length of atoms_per_core doesn't match the number of"
            " dimensions")

    if len(app_vertex.atoms_shape) == 1:
        return get_single_dimension_slices(app_vertex)

    # Find out how many vertices we will create, keeping track of the
    # total atoms per core, and the numerator to divide by when working
    # out positions
    n_vertices = 1
    total_atoms_per_core = 1
    dim_numerator = [0] * len(n_atoms)
    total_n_atoms = 1
    for d in range(len(n_atoms)):
        dim_numerator[d] = n_vertices
        n_this_dim = int(math.ceil(n_atoms[d] / atoms_per_core[d]))
        n_vertices *= n_this_dim
        total_atoms_per_core *= atoms_per_core[d]
        total_n_atoms *= n_atoms[d]

    # Run over all the vertices and create slices for them
    slices: List[Slice] = list()
    hi_atom = -1
    for v in range(n_vertices):
        # Work out where in each of the dimensions this vertex starts by
        # dividing the remainder from the previous dimension by the
        # numerator of each dimension
        start = [0] * len(n_atoms)
        n_on_core = [0] * len(n_atoms)
        remainder = v
        total_on_core = 1
        for d in reversed(range(len(n_atoms))):
            start[d] = (remainder // dim_numerator[d]) * atoms_per_core[d]
            remainder = remainder % dim_numerator[d]
            hi_d = min(start[d] + atoms_per_core[d], n_atoms[d])
            n_on_core[d] = hi_d - start[d]
            total_on_core *= n_on_core[d]

        # Make a slice and a vertex
        lo_atom = hi_atom + 1
        hi_atom = (lo_atom + total_on_core) - 1
        vertex_slice = MDSlice(
            lo_atom, hi_atom, tuple(n_on_core), tuple(start),
            app_vertex.atoms_shape)
        slices.append(vertex_slice)

    return slices


def get_single_dimension_slices(app_vertex: ApplicationVertex) -> List[Slice]:
    """ Get the single dimension slices of an application vertex
        such that each is sized to the maximum atoms per dimension per core
        except the last which might be smaller in one or more dimensions

    :param ApplicationVertex app_vertex: The vertex to get the slices of
    """
    # If there is only one slice, get that
    if app_vertex.n_atoms < app_vertex.get_max_atoms_per_core():
        return [Slice(0, app_vertex.n_atoms - 1)]

    total_on_core = app_vertex.get_max_atoms_per_dimension_per_core()[0]

    n_vertices = math.ceil(app_vertex.n_atoms / total_on_core)

    # Run over all the vertices and create slices for them
    slices = list()
    hi_atom = -1
    for _ in range(n_vertices):
        # Make a slice
        lo_atom = hi_atom + 1
        hi_atom = min(app_vertex.n_atoms - 1, (lo_atom + total_on_core) - 1)
        vertex_slice = Slice(lo_atom, hi_atom)
        slices.append(vertex_slice)

    return slices

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	"""	1✔
15	A collection of methods which support partitioning algorithms.
16	"""
17
18	import math	1✔
19	from typing import List	1✔
20	from pacman.exceptions import PacmanConfigurationException	1✔
21	from pacman.model.graphs.common import MDSlice, Slice	1✔
22	from pacman.model.graphs.application import ApplicationVertex	1✔
23
24
25	def get_multidimensional_slices(	1✔
26	app_vertex: ApplicationVertex) -> List[Slice]:
27	"""
28	Get the multi-dimensional slices of an application vertex
29	such that each is sized to the maximum atoms per dimension per core
30	except the last, which might be smaller in one or more dimensions.
31
32	:param ApplicationVertex app_vertex: The vertex to get the slices of
33	:return: The slices
34	:rtype: list(~pacman.model.graphs.common.Slice)
35	"""
36	atoms_per_core = app_vertex.get_max_atoms_per_dimension_per_core()	1✔
37	n_atoms = app_vertex.atoms_shape	1✔
38	if len(atoms_per_core) != len(n_atoms):	1!
39	raise PacmanConfigurationException(	×
40	"The length of atoms_per_core doesn't match the number of"
41	" dimensions")
42
43	if len(app_vertex.atoms_shape) == 1:	1!
44	return get_single_dimension_slices(app_vertex)	1✔
45
46	# Find out how many vertices we will create, keeping track of the
47	# total atoms per core, and the numerator to divide by when working
48	# out positions
49	n_vertices = 1	×
50	total_atoms_per_core = 1	×
51	dim_numerator = [0] * len(n_atoms)	×
52	total_n_atoms = 1	×
53	for d in range(len(n_atoms)):	×
54	dim_numerator[d] = n_vertices	×
55	n_this_dim = int(math.ceil(n_atoms[d] / atoms_per_core[d]))	×
56	n_vertices *= n_this_dim	×
57	total_atoms_per_core *= atoms_per_core[d]	×
58	total_n_atoms *= n_atoms[d]	×
59
60	# Run over all the vertices and create slices for them
61	slices: List[Slice] = list()	×
62	hi_atom = -1	×
63	for v in range(n_vertices):	×
64	# Work out where in each of the dimensions this vertex starts by
65	# dividing the remainder from the previous dimension by the
66	# numerator of each dimension
67	start = [0] * len(n_atoms)	×
68	n_on_core = [0] * len(n_atoms)	×
69	remainder = v	×
70	total_on_core = 1	×
71	for d in reversed(range(len(n_atoms))):	×
72	start[d] = (remainder // dim_numerator[d]) * atoms_per_core[d]	×
73	remainder = remainder % dim_numerator[d]	×
74	hi_d = min(start[d] + atoms_per_core[d], n_atoms[d])	×
75	n_on_core[d] = hi_d - start[d]	×
76	total_on_core *= n_on_core[d]	×
77
78	# Make a slice and a vertex
79	lo_atom = hi_atom + 1	×
80	hi_atom = (lo_atom + total_on_core) - 1	×
81	vertex_slice = MDSlice(	×
82	lo_atom, hi_atom, tuple(n_on_core), tuple(start),
83	app_vertex.atoms_shape)
84	slices.append(vertex_slice)	×
85
86	return slices	×
87
88
89	def get_single_dimension_slices(app_vertex: ApplicationVertex) -> List[Slice]:	1✔
90	""" Get the single dimension slices of an application vertex
91	such that each is sized to the maximum atoms per dimension per core
92	except the last which might be smaller in one or more dimensions
93
94	:param ApplicationVertex app_vertex: The vertex to get the slices of
95	"""
96	# If there is only one slice, get that
97	if app_vertex.n_atoms < app_vertex.get_max_atoms_per_core():	1✔
98	return [Slice(0, app_vertex.n_atoms - 1)]	1✔
99
100	total_on_core = app_vertex.get_max_atoms_per_dimension_per_core()[0]	1✔
101
102	n_vertices = math.ceil(app_vertex.n_atoms / total_on_core)	1✔
103
104	# Run over all the vertices and create slices for them
105	slices = list()	1✔
106	hi_atom = -1	1✔
107	for _ in range(n_vertices):	1✔
108	# Make a slice
109	lo_atom = hi_atom + 1	1✔
110	hi_atom = min(app_vertex.n_atoms - 1, (lo_atom + total_on_core) - 1)	1✔
111	vertex_slice = Slice(lo_atom, hi_atom)	1✔
112	slices.append(vertex_slice)	1✔
113
114	return slices	1✔

SpiNNakerManchester / PACMAN / 6617445310

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