8843974228

Committed 26 Apr 2024 06:17AM UTC coverage: 60.168% (-0.02%) from 60.185%

Build # 8843974228

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #398 from SpiNNakerManchester/p_list

Chip takes lists of Processors

Run Details

2229 of 3507 branches covered (63.56%)

Branch coverage included in aggregate %.

1 of 8 new or added lines in 2 files covered. (12.5%)

1 existing line in 1 file now uncovered.

4789 of 8157 relevant lines covered (58.71%)

0.59 hits per line

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

17.06

/spinnman/processes/get_machine_process.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 collections import defaultdict
from contextlib import suppress
import logging
import functools
from os.path import join
from typing import Dict, List, Optional, Set, Tuple, cast

from spinn_utilities.config_holder import (
    get_config_bool, get_config_int_or_none, get_config_str_or_none)
from spinn_utilities.data import UtilsDataView
from spinn_utilities.log import FormatAdapter
from spinn_utilities.progress_bar import ProgressBar
from spinn_utilities.typing.coords import XY

from spinn_machine import (Router, Chip, Link, Machine)
from spinn_machine.ignores import IgnoreChip, IgnoreCore, IgnoreLink
from spinn_machine.machine_factory import machine_repair

from spinnman.constants import (
    ROUTER_REGISTER_P2P_ADDRESS, SYSTEM_VARIABLE_BASE_ADDRESS)
from spinnman.data import SpiNNManDataView
from spinnman.exceptions import SpinnmanUnexpectedResponseCodeException
from spinnman.messages.scp.abstract_messages import AbstractSCPRequest
from spinnman.messages.scp.impl import ReadMemory, ReadLink, GetChipInfo
from spinnman.messages.scp.impl.get_chip_info_response import (
    GetChipInfoResponse)
from spinnman.messages.scp.impl.read_memory import Response
from spinnman.messages.spinnaker_boot import (
    SystemVariableDefinition)
from spinnman.model import ChipSummaryInfo, P2PTable
from spinnman.model.enums import CPUState

from .abstract_multi_connection_process import AbstractMultiConnectionProcess
from .abstract_multi_connection_process_connection_selector import \
    ConnectionSelector

logger = FormatAdapter(logging.getLogger(__name__))

REPORT_FILE = "Ignores_report.rpt"

P_TO_V = SystemVariableDefinition.physical_to_virtual_core_map
V_TO_P = SystemVariableDefinition.virtual_to_physical_core_map
P_TO_V_ADDR = SYSTEM_VARIABLE_BASE_ADDRESS + P_TO_V.offset
_P_TO_V_SIZE = cast(int, P_TO_V.array_size)
P_MAPS_SIZE = _P_TO_V_SIZE + cast(int, V_TO_P.array_size)


class GetMachineProcess(AbstractMultiConnectionProcess):
    """
    A process for getting the machine details over a set of connections.
    """
    __slots__ = (
        "_chip_info",
        # Used if there are any ignores with IP addresses
        # Holds a mapping from IP to board root (x,y)
        "_ethernets",
        # Holds a map from x,y to a set of virtual cores to ignores
        "_ignore_cores_map",
        "_p2p_column_data",
        # Holds a mapping from (x,y) to a mapping of physical to virtual core
        "_virtual_to_physical_map",
        # Holds a mapping from (x,y) to a mapping of virtual to physical core
        "_physical_to_virtual_map",
        # Progress bar to fill in as details are received
        "_progress")

    def __init__(self, connection_selector: ConnectionSelector):
        """
        :param ConnectionSelector connection_selector:
        """
        super().__init__(connection_selector)

        self._ignore_cores_map: Dict[XY, Set[int]] = defaultdict(set)

        self._p2p_column_data: List[Tuple[bytes, int]] = list()

        # A dictionary of (x, y) -> ChipInfo
        self._chip_info: Dict[XY, ChipSummaryInfo] = dict()

        # Set to None meaning not computed yet
        self._ethernets: Optional[Dict[str, XY]] = None

        # Maps between virtual and physical cores
        self._virtual_to_physical_map: Dict[XY, bytes] = dict()
        self._physical_to_virtual_map: Dict[XY, bytes] = dict()
        self._progress: Optional[ProgressBar] = None

    def _make_chip(self, chip_info: ChipSummaryInfo, machine: Machine) -> Chip:
        """
        Creates a chip from a ChipSummaryInfo structure.

        :param ChipSummaryInfo chip_info:
            The ChipSummaryInfo structure to create the chip from
        :return: The created chip
        :rtype: ~spinn_machine.Chip
        """
        # Keep track of progress
        self._progress = None
        # Create the down cores set if any
        n_cores = \
            SpiNNManDataView.get_machine_version().max_cores_per_chip
        n_cores = min(chip_info.n_cores, n_cores)
        core_states = chip_info.core_states
        down_cores = self._ignore_cores_map.get(
            (chip_info.x, chip_info.y), set())
        if 0 in down_cores:
            raise NotImplementedError(
                "Declaring scamp core (0) as down is not supported")
        cores = list()
        for i in range(1, n_cores):
            if i in down_cores:
                pass
            elif core_states[i] != CPUState.IDLE:
                self._report_ignore(
                    "Not using core {}, {}, {} in state {}",
                    chip_info.x, chip_info.y, i,  core_states[i])
            else:
                cores.append(i)

        # Create the router
        router = self._make_router(chip_info, machine)

        # Create the chip's SDRAM object
        sdram_size = chip_info.largest_free_sdram_block
        max_sdram_size = get_config_int_or_none(
            "Machine", "max_sdram_allowed_per_chip")
        if (max_sdram_size is not None and
                sdram_size > max_sdram_size):
            sdram_size = max_sdram_size

        # Create the chip
        return Chip(
            x=chip_info.x, y=chip_info.y, scamp_processors=[0],
            placable_processors=cores,
            router=router, sdram=sdram_size,
            ip_address=chip_info.ethernet_ip_address,
            nearest_ethernet_x=chip_info.nearest_ethernet_x,
            nearest_ethernet_y=chip_info.nearest_ethernet_y,
            parent_link=chip_info.parent_link)

    def _make_router(
            self, chip_info: ChipSummaryInfo, machine: Machine) -> Router:
        """
        :param ChipSummaryInfo chip_info:
        :param ~spinn_machine.Machine machine:
        :rtype: ~spinn_machine.Router
        """
        links = list()
        for link in chip_info.working_links:
            dest_xy = machine.xy_over_link(chip_info.x, chip_info.y, link)
            if dest_xy in self._chip_info:
                links.append(Link(
                    chip_info.x, chip_info.y, link, dest_xy[0], dest_xy[1]))
            else:
                logger.warning(
                    "Link {},{}:{} points to {} but that is not included ",
                    chip_info.x, chip_info.y, link, dest_xy)

        return Router(
            links=links,
            n_available_multicast_entries=(
                chip_info.n_free_multicast_routing_entries))

    def __receive_p2p_data(
            self, column: int, scp_read_response: Response):
        """
        :param int column:
        :param Response scp_read_response:
        """
        self._p2p_column_data[column] = (
            scp_read_response.data, scp_read_response.offset)

    def _receive_chip_info(
            self, scp_read_chip_info_response: GetChipInfoResponse):
        """
        :param GetChipInfoResponse scp_read_chip_info_response:
        """
        chip_info = scp_read_chip_info_response.chip_info
        self._chip_info[chip_info.x, chip_info.y] = chip_info
        if self._progress is not None:
            self._progress.update()

    def _receive_p_maps(
            self, x: int, y: int, scp_read_response: Response):
        """
        Receive the physical-to-virtual and virtual-to-physical maps.

        :param Response scp_read_response:
        """
        data = scp_read_response.data
        off = scp_read_response.offset
        self._physical_to_virtual_map[x, y] = data[off:_P_TO_V_SIZE + off]
        off += _P_TO_V_SIZE
        self._virtual_to_physical_map[x, y] = data[off:]

    def _receive_error(
            self, request: AbstractSCPRequest, exception, tb, connection):
        """
        :param AbstractSCPRequest request:
        :param Exception exception:
        """
        # If we get an ReadLink with a
        # SpinnmanUnexpectedResponseCodeException, this is a failed link
        # and so can be ignored
        if isinstance(request, ReadLink):
            if isinstance(exception, SpinnmanUnexpectedResponseCodeException):
                return
        super()._receive_error(request, exception, tb, connection)

    def get_machine_details(
            self, boot_x: int, boot_y: int,
            width: int, height: int) -> Machine:
        """
        :param int boot_x:
        :param int boot_y:
        :param int width:
        :param int height:
        :rtype: ~spinn_machine.Machine
        """
        # Get the P2P table - 8 entries are packed into each 32-bit word
        p2p_column_bytes = P2PTable.get_n_column_bytes(height)
        blank = (b'', 0)
        self._p2p_column_data = [blank] * width
        with self._collect_responses():
            for column in range(width):
                offset = P2PTable.get_column_offset(column)
                self._send_request(
                    ReadMemory(
                        coordinates=(boot_x, boot_y, 0),
                        base_address=(ROUTER_REGISTER_P2P_ADDRESS + offset),
                        size=p2p_column_bytes),
                    functools.partial(self.__receive_p2p_data, column))
        p2p_table = P2PTable(width, height, self._p2p_column_data)

        # Get the chip information for each chip
        self._progress = ProgressBar(
            p2p_table.n_routes,
            f"Reading details from {p2p_table.n_routes} chips")
        with suppress(Exception), self._collect_responses():
            # Ignore errors, as any error here just means that a chip
            # is down that wasn't marked as down
            for (x, y) in p2p_table.iterchips():
                self._send_request(GetChipInfo(x, y), self._receive_chip_info)
                self._send_request(
                    ReadMemory((x, y, 0), P_TO_V_ADDR, P_MAPS_SIZE),
                    functools.partial(self._receive_p_maps, x, y))
        self._progress.end()
        SpiNNManDataView.set_v_to_p_map(self._virtual_to_physical_map)

        # Warn about unexpected missing chips
        for (x, y) in p2p_table.iterchips():
            if (x, y) not in self._chip_info:
                logger.warning(
                    "Chip {}, {} was expected but didn't reply", x, y)

        version = SpiNNManDataView.get_machine_version()
        machine = version.create_machine(width, height)
        self._preprocess_ignore_chips(machine)
        self._process_ignore_links(machine)
        self._preprocess_ignore_cores(machine)

        return self._fill_machine(machine)

    def _fill_machine(self, machine: Machine) -> Machine:
        """
        :param ~spinn_machine.Machine machine:
        :rtype: ~spinn_machine.Machine
        """
        for chip_info in sorted(
                self._chip_info.values(), key=lambda chip: (chip.x, chip.y)):
            if (chip_info.ethernet_ip_address is not None and
                    (chip_info.x != chip_info.nearest_ethernet_x
                     or chip_info.y != chip_info.nearest_ethernet_y)):
                if get_config_bool("Machine", "ignore_bad_ethernets"):
                    logger.warning(
                        "Chip {}:{} claimed it has ip address: {}. "
                        "This ip will not be used.",
                        chip_info.x, chip_info.y,
                        chip_info.ethernet_ip_address)
                    chip_info.clear_ethernet_ip_address()
                else:
                    logger.warning(
                        "Not using chip {}:{} as it has an unexpected "
                        "ip address: {}", chip_info.x, chip_info.y,
                        chip_info.ethernet_ip_address)
                    continue

            # If the above has not continued, add the chip
            machine.add_chip(self._make_chip(chip_info, machine))

        machine.validate()
        return machine_repair(machine)

    # Stuff below here is purely for dealing with ignores

    def _process_ignore_links(self, machine: Machine):
        """
        Processes the collection of ignore links to remove then from chip info.

        Converts any local (x, y, IP address) to global (x, y)

        Discards any ignores which are known to have no
        affect based on the already read chip_info

        Also removes any inverse links

        Logs all actions except for ignores with unused IP addresses

        :param ~spinn_machine.Machine machine:
            An empty machine to handle wrap-arounds
        """
        for ignore in IgnoreLink.parse_string(
                get_config_str_or_none("Machine", "down_links")):
            global_xy = self._ignores_local_to_global(
                ignore.x, ignore.y, ignore.ip_address, machine)
            if global_xy is None:
                continue
            chip_info = self._chip_info.get(global_xy, None)
            if chip_info is None:
                self._report_ignore(
                    "Discarding ignore link on chip {} as it is not/ no longer"
                    " in info", global_xy)
                continue
            link = ignore.link
            if link in chip_info.working_links:
                chip_info.working_links.remove(link)
                self._report_ignore(
                    "On chip {} ignoring link:{}", global_xy, link)
                # ignore the inverse link too
                inv_xy = machine.xy_over_link(global_xy[0], global_xy[1], link)
                if inv_xy in self._chip_info:
                    inv_chip_info = self._chip_info[inv_xy]
                    inv_link = (link + 3) % 6
                    if inv_link in inv_chip_info.working_links:
                        inv_chip_info.working_links.remove(inv_link)
                        self._report_ignore(
                            "On chip {} ignoring link {} as it is the inverse "
                            "of link {} on chip {}", inv_xy, inv_link, link,
                            global_xy)
            else:
                self._report_ignore(
                    "Discarding ignore link {} on chip {} as it is not/"
                    "no longer in info", link, global_xy)

    def _preprocess_ignore_cores(self, machine: Machine):
        """
        Converts the collection of ignore cores into a map of ignore by x,y.

        Converts any local (x, y, IP address) to global (x, y)

        Discards (with log messages) any ignores which are known to have no
        affect based on the already read chip_info

        Converts any physical  cores to virtual ones.
        Core numbers <= 0 are assumed to be 0 - physical_id

        :param ~spinn_machine.Machine machine:
            An empty machine to handle wrap-arounds
        """
        # Convert by IP to global
        for ignore in IgnoreCore.parse_string(
                get_config_str_or_none("Machine", "down_cores")):
            global_xy = self._ignores_local_to_global(
                ignore.x, ignore.y, ignore.ip_address, machine)
            if global_xy is None:
                continue
            p = self._get_virtual_p(global_xy, ignore.p)
            if p is not None:
                self._ignore_cores_map[global_xy].add(p)

    def _preprocess_ignore_chips(self, machine: Machine):
        """
        Processes the collection of ignore chips and discards their chip info.

        Converts any local (x, y IP address) to global (x, y)

        Discards any ignores which are known to have no
        affect based on the already read chip_info

        Logs all actions except for ignores with unused IP addresses

        :param ~spinn_machine.Machine machine:
            An empty machine to handle wrap-arounds
        """
        for ignore in IgnoreChip.parse_string(
                get_config_str_or_none("Machine", "down_chips")):
            # Convert by IP to global
            global_xy = self._ignores_local_to_global(
                ignore.x, ignore.y, ignore.ip_address, machine)
            if global_xy is None:
                continue  # Never on this machine
            chip_info = self._chip_info.pop(global_xy, None)
            if chip_info is None:
                continue  # Already ignored maybe by a dead chip list
            self._report_ignore("Chip {} will be ignored", global_xy)
            for link in chip_info.working_links:
                # ignore the inverse link
                inv_xy = machine.xy_over_link(global_xy[0], global_xy[1], link)
                if inv_xy in self._chip_info:
                    inv_chip_info = self._chip_info[inv_xy]
                    inv_link = (link + 3) % 6
                    if inv_link in inv_chip_info.working_links:
                        inv_chip_info.working_links.remove(inv_link)
                        self._report_ignore(
                            "On chip {} ignoring link {} as it points to "
                            "ignored chip chip {}",
                            inv_xy, inv_link, global_xy)

    def _ignores_local_to_global(
            self, local_x: int, local_y: int, ip_address: Optional[str],
            machine: Machine) -> Optional[XY]:
        """
        :param int local_x:
        :param int local_y:
        :param str ip_address:
        :param ~spinn_machine.Machine machine:
        :rtype: tuple(int,int)
        """
        if ip_address is None:
            global_xy = (local_x, local_y)
        else:
            ethernet = self._ethernet_by_ipaddress(ip_address)
            if ethernet is None:
                self._report_ignore(
                    "Ignore with ip:{} will be discarded as no board with "
                    "that ip in this machine", ip_address)
                return None
            global_xy = machine.get_global_xy(
                local_x, local_y, ethernet[0], ethernet[1])
            self._report_ignore(
                "Ignores for local x:{} y:{} and ip:{} map to global {} with "
                "root {}", local_x, local_y, ip_address, global_xy,
                self._chip_info[(0, 0)].ethernet_ip_address)

        if global_xy in self._chip_info:
            return global_xy
        else:
            self._report_ignore(
                "Ignore for global chip {} will be discarded as no such chip "
                "in this machine", global_xy)
            return None

    def _ethernet_by_ipaddress(self, ip_address: str) -> Optional[XY]:
        """
        :param str ip_address:
        :rtype: tuple(int,int)
        """
        if self._ethernets is None:
            self._ethernets = dict()
            for chip_info in self._chip_info.values():
                if chip_info.ethernet_ip_address is not None:
                    self._ethernets[chip_info.ethernet_ip_address] = \
                        (chip_info.x, chip_info.y)
        return self._ethernets.get(ip_address, None)

    def _get_virtual_p(self, xy: XY, p: int) -> Optional[int]:
        """
        :param tuple(int,int) xy:
        :param int p:
        :rtype: int
        """
        if p > 0:
            self._report_ignore("On chip {} ignoring core {}", xy, p)
            return p
        virtual_map = self._physical_to_virtual_map[xy]
        physical = 0 - p
        if physical >= len(virtual_map) or virtual_map[physical] == 0xFF:
            self._report_ignore(
                "On chip {} physical core {} was not used "
                "so ignore is being discarded.", xy, physical)
            return None
        virtual_p = virtual_map[physical]
        if virtual_p == 0:
            self._report_ignore(
                "On chip {} physical core {} was used as the monitor "
                "so will NOT be ignored", xy, physical)
            return None
        self._report_ignore(
            "On chip {} ignoring core {} as it maps to physical "
            "core {}", xy, virtual_p, physical)
        return virtual_p

    def _report_ignore(self, message: str, *args):
        """
        Writes the ignore message by either creating or appending the report.

        The implementation choice to reopen the file every time is not the
        fastest but is the cleanest and safest for code that in default
        conditions is never run.

        :param str message:
        """
        full_message = message.format(*args) + "\n"
        report_file = join(UtilsDataView.get_run_dir_path(), REPORT_FILE)
        with open(report_file, "a", encoding="utf-8") as r_file:
            r_file.write(full_message)

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
15	from collections import defaultdict	1✔
16	from contextlib import suppress	1✔
17	import logging	1✔
18	import functools	1✔
19	from os.path import join	1✔
20	from typing import Dict, List, Optional, Set, Tuple, cast	1✔
21
22	from spinn_utilities.config_holder import (	1✔
23	get_config_bool, get_config_int_or_none, get_config_str_or_none)
24	from spinn_utilities.data import UtilsDataView	1✔
25	from spinn_utilities.log import FormatAdapter	1✔
26	from spinn_utilities.progress_bar import ProgressBar	1✔
27	from spinn_utilities.typing.coords import XY	1✔
28
29	from spinn_machine import (Router, Chip, Link, Machine)	1✔
30	from spinn_machine.ignores import IgnoreChip, IgnoreCore, IgnoreLink	1✔
31	from spinn_machine.machine_factory import machine_repair	1✔
32
33	from spinnman.constants import (	1✔
34	ROUTER_REGISTER_P2P_ADDRESS, SYSTEM_VARIABLE_BASE_ADDRESS)
35	from spinnman.data import SpiNNManDataView	1✔
36	from spinnman.exceptions import SpinnmanUnexpectedResponseCodeException	1✔
37	from spinnman.messages.scp.abstract_messages import AbstractSCPRequest	1✔
38	from spinnman.messages.scp.impl import ReadMemory, ReadLink, GetChipInfo	1✔
39	from spinnman.messages.scp.impl.get_chip_info_response import (	1✔
40	GetChipInfoResponse)
41	from spinnman.messages.scp.impl.read_memory import Response	1✔
42	from spinnman.messages.spinnaker_boot import (	1✔
43	SystemVariableDefinition)
44	from spinnman.model import ChipSummaryInfo, P2PTable	1✔
45	from spinnman.model.enums import CPUState	1✔
46
47	from .abstract_multi_connection_process import AbstractMultiConnectionProcess	1✔
48	from .abstract_multi_connection_process_connection_selector import \	1✔
49	ConnectionSelector
50
51	logger = FormatAdapter(logging.getLogger(__name__))	1✔
52
53	REPORT_FILE = "Ignores_report.rpt"	1✔
54
55	P_TO_V = SystemVariableDefinition.physical_to_virtual_core_map	1✔
56	V_TO_P = SystemVariableDefinition.virtual_to_physical_core_map	1✔
57	P_TO_V_ADDR = SYSTEM_VARIABLE_BASE_ADDRESS + P_TO_V.offset	1✔
58	_P_TO_V_SIZE = cast(int, P_TO_V.array_size)	1✔
59	P_MAPS_SIZE = _P_TO_V_SIZE + cast(int, V_TO_P.array_size)	1✔
60
61
62	class GetMachineProcess(AbstractMultiConnectionProcess):	1✔
63	"""
64	A process for getting the machine details over a set of connections.
65	"""
66	__slots__ = (	1✔
67	"_chip_info",
68	# Used if there are any ignores with IP addresses
69	# Holds a mapping from IP to board root (x,y)
70	"_ethernets",
71	# Holds a map from x,y to a set of virtual cores to ignores
72	"_ignore_cores_map",
73	"_p2p_column_data",
74	# Holds a mapping from (x,y) to a mapping of physical to virtual core
75	"_virtual_to_physical_map",
76	# Holds a mapping from (x,y) to a mapping of virtual to physical core
77	"_physical_to_virtual_map",
78	# Progress bar to fill in as details are received
79	"_progress")
80
81	def __init__(self, connection_selector: ConnectionSelector):	1✔
82	"""
83	:param ConnectionSelector connection_selector:
84	"""
85	super().__init__(connection_selector)	×
86
87	self._ignore_cores_map: Dict[XY, Set[int]] = defaultdict(set)	×
88
89	self._p2p_column_data: List[Tuple[bytes, int]] = list()	×
90
91	# A dictionary of (x, y) -> ChipInfo
92	self._chip_info: Dict[XY, ChipSummaryInfo] = dict()	×
93
94	# Set to None meaning not computed yet
95	self._ethernets: Optional[Dict[str, XY]] = None	×
96
97	# Maps between virtual and physical cores
98	self._virtual_to_physical_map: Dict[XY, bytes] = dict()	×
99	self._physical_to_virtual_map: Dict[XY, bytes] = dict()	×
100	self._progress: Optional[ProgressBar] = None	×
101
102	def _make_chip(self, chip_info: ChipSummaryInfo, machine: Machine) -> Chip:	1✔
103	"""
104	Creates a chip from a ChipSummaryInfo structure.
105
106	:param ChipSummaryInfo chip_info:
107	The ChipSummaryInfo structure to create the chip from
108	:return: The created chip
109	:rtype: ~spinn_machine.Chip
110	"""
111	# Keep track of progress
112	self._progress = None	×
113	# Create the down cores set if any
114	n_cores = \	×
115	SpiNNManDataView.get_machine_version().max_cores_per_chip
116	n_cores = min(chip_info.n_cores, n_cores)	×
117	core_states = chip_info.core_states	×
118	down_cores = self._ignore_cores_map.get(	×
119	(chip_info.x, chip_info.y), set())
NEW 120	if 0 in down_cores:	×
121	raise NotImplementedError(
122	"Declaring scamp core (0) as down is not supported")
NEW 123	cores = list()	×
124	for i in range(1, n_cores):	×
NEW 125	if i in down_cores:	×
NEW 126	pass	×
NEW 127	elif core_states[i] != CPUState.IDLE:	×
UNCOV 128	self._report_ignore(	×
129	"Not using core {}, {}, {} in state {}",
130	chip_info.x, chip_info.y, i, core_states[i])
131	else:
NEW 132	cores.append(i)	×
133
134	# Create the router
135	router = self._make_router(chip_info, machine)	×
136
137	# Create the chip's SDRAM object
138	sdram_size = chip_info.largest_free_sdram_block	×
139	max_sdram_size = get_config_int_or_none(	×
140	"Machine", "max_sdram_allowed_per_chip")
141	if (max_sdram_size is not None and	×
142	sdram_size > max_sdram_size):
143	sdram_size = max_sdram_size	×
144
145	# Create the chip
146	return Chip(	×
147	x=chip_info.x, y=chip_info.y, scamp_processors=[0],
148	placable_processors=cores,
149	router=router, sdram=sdram_size,
150	ip_address=chip_info.ethernet_ip_address,
151	nearest_ethernet_x=chip_info.nearest_ethernet_x,
152	nearest_ethernet_y=chip_info.nearest_ethernet_y,
153	parent_link=chip_info.parent_link)
154
155	def _make_router(	1✔
156	self, chip_info: ChipSummaryInfo, machine: Machine) -> Router:
157	"""
158	:param ChipSummaryInfo chip_info:
159	:param ~spinn_machine.Machine machine:
160	:rtype: ~spinn_machine.Router
161	"""
162	links = list()	×
163	for link in chip_info.working_links:	×
164	dest_xy = machine.xy_over_link(chip_info.x, chip_info.y, link)	×
165	if dest_xy in self._chip_info:	×
166	links.append(Link(	×
167	chip_info.x, chip_info.y, link, dest_xy[0], dest_xy[1]))
168	else:
169	logger.warning(	×
170	"Link {},{}:{} points to {} but that is not included ",
171	chip_info.x, chip_info.y, link, dest_xy)
172
173	return Router(	×
174	links=links,
175	n_available_multicast_entries=(
176	chip_info.n_free_multicast_routing_entries))
177
178	def __receive_p2p_data(	1✔
179	self, column: int, scp_read_response: Response):
180	"""
181	:param int column:
182	:param Response scp_read_response:
183	"""
184	self._p2p_column_data[column] = (	×
185	scp_read_response.data, scp_read_response.offset)
186
187	def _receive_chip_info(	1✔
188	self, scp_read_chip_info_response: GetChipInfoResponse):
189	"""
190	:param GetChipInfoResponse scp_read_chip_info_response:
191	"""
192	chip_info = scp_read_chip_info_response.chip_info	×
193	self._chip_info[chip_info.x, chip_info.y] = chip_info	×
194	if self._progress is not None:	×
195	self._progress.update()	×
196
197	def _receive_p_maps(	1✔
198	self, x: int, y: int, scp_read_response: Response):
199	"""
200	Receive the physical-to-virtual and virtual-to-physical maps.
201
202	:param Response scp_read_response:
203	"""
204	data = scp_read_response.data	×
205	off = scp_read_response.offset	×
206	self._physical_to_virtual_map[x, y] = data[off:_P_TO_V_SIZE + off]	×
207	off += _P_TO_V_SIZE	×
208	self._virtual_to_physical_map[x, y] = data[off:]	×
209
210	def _receive_error(	1✔
211	self, request: AbstractSCPRequest, exception, tb, connection):
212	"""
213	:param AbstractSCPRequest request:
214	:param Exception exception:
215	"""
216	# If we get an ReadLink with a
217	# SpinnmanUnexpectedResponseCodeException, this is a failed link
218	# and so can be ignored
219	if isinstance(request, ReadLink):	×
220	if isinstance(exception, SpinnmanUnexpectedResponseCodeException):	×
221	return	×
222	super()._receive_error(request, exception, tb, connection)	×
223
224	def get_machine_details(	1✔
225	self, boot_x: int, boot_y: int,
226	width: int, height: int) -> Machine:
227	"""
228	:param int boot_x:
229	:param int boot_y:
230	:param int width:
231	:param int height:
232	:rtype: ~spinn_machine.Machine
233	"""
234	# Get the P2P table - 8 entries are packed into each 32-bit word
235	p2p_column_bytes = P2PTable.get_n_column_bytes(height)	×
236	blank = (b'', 0)	×
237	self._p2p_column_data = [blank] * width	×
238	with self._collect_responses():	×
239	for column in range(width):	×
240	offset = P2PTable.get_column_offset(column)	×
241	self._send_request(	×
242	ReadMemory(
243	coordinates=(boot_x, boot_y, 0),
244	base_address=(ROUTER_REGISTER_P2P_ADDRESS + offset),
245	size=p2p_column_bytes),
246	functools.partial(self.__receive_p2p_data, column))
247	p2p_table = P2PTable(width, height, self._p2p_column_data)	×
248
249	# Get the chip information for each chip
250	self._progress = ProgressBar(	×
251	p2p_table.n_routes,
252	f"Reading details from {p2p_table.n_routes} chips")
253	with suppress(Exception), self._collect_responses():	×
254	# Ignore errors, as any error here just means that a chip
255	# is down that wasn't marked as down
256	for (x, y) in p2p_table.iterchips():	×
257	self._send_request(GetChipInfo(x, y), self._receive_chip_info)	×
258	self._send_request(	×
259	ReadMemory((x, y, 0), P_TO_V_ADDR, P_MAPS_SIZE),
260	functools.partial(self._receive_p_maps, x, y))
261	self._progress.end()	×
NEW 262	SpiNNManDataView.set_v_to_p_map(self._virtual_to_physical_map)	×
263
264	# Warn about unexpected missing chips
265	for (x, y) in p2p_table.iterchips():	×
266	if (x, y) not in self._chip_info:	×
267	logger.warning(	×
268	"Chip {}, {} was expected but didn't reply", x, y)
269
270	version = SpiNNManDataView.get_machine_version()	×
271	machine = version.create_machine(width, height)	×
272	self._preprocess_ignore_chips(machine)	×
273	self._process_ignore_links(machine)	×
274	self._preprocess_ignore_cores(machine)	×
275
276	return self._fill_machine(machine)	×
277
278	def _fill_machine(self, machine: Machine) -> Machine:	1✔
279	"""
280	:param ~spinn_machine.Machine machine:
281	:rtype: ~spinn_machine.Machine
282	"""
283	for chip_info in sorted(	×
284	self._chip_info.values(), key=lambda chip: (chip.x, chip.y)):
285	if (chip_info.ethernet_ip_address is not None and	×
286	(chip_info.x != chip_info.nearest_ethernet_x
287	or chip_info.y != chip_info.nearest_ethernet_y)):
288	if get_config_bool("Machine", "ignore_bad_ethernets"):	×
289	logger.warning(	×
290	"Chip {}:{} claimed it has ip address: {}. "
291	"This ip will not be used.",
292	chip_info.x, chip_info.y,
293	chip_info.ethernet_ip_address)
294	chip_info.clear_ethernet_ip_address()	×
295	else:
296	logger.warning(	×
297	"Not using chip {}:{} as it has an unexpected "
298	"ip address: {}", chip_info.x, chip_info.y,
299	chip_info.ethernet_ip_address)
300	continue	×
301
302	# If the above has not continued, add the chip
303	machine.add_chip(self._make_chip(chip_info, machine))	×
304
305	machine.validate()	×
306	return machine_repair(machine)	×
307
308	# Stuff below here is purely for dealing with ignores
309
310	def _process_ignore_links(self, machine: Machine):	1✔
311	"""
312	Processes the collection of ignore links to remove then from chip info.
313
314	Converts any local (x, y, IP address) to global (x, y)
315
316	Discards any ignores which are known to have no
317	affect based on the already read chip_info
318
319	Also removes any inverse links
320
321	Logs all actions except for ignores with unused IP addresses
322
323	:param ~spinn_machine.Machine machine:
324	An empty machine to handle wrap-arounds
325	"""
326	for ignore in IgnoreLink.parse_string(	×
327	get_config_str_or_none("Machine", "down_links")):
328	global_xy = self._ignores_local_to_global(	×
329	ignore.x, ignore.y, ignore.ip_address, machine)
330	if global_xy is None:	×
331	continue	×
332	chip_info = self._chip_info.get(global_xy, None)	×
333	if chip_info is None:	×
334	self._report_ignore(	×
335	"Discarding ignore link on chip {} as it is not/ no longer"
336	" in info", global_xy)
337	continue	×
338	link = ignore.link	×
339	if link in chip_info.working_links:	×
340	chip_info.working_links.remove(link)	×
341	self._report_ignore(	×
342	"On chip {} ignoring link:{}", global_xy, link)
343	# ignore the inverse link too
344	inv_xy = machine.xy_over_link(global_xy[0], global_xy[1], link)	×
345	if inv_xy in self._chip_info:	×
346	inv_chip_info = self._chip_info[inv_xy]	×
347	inv_link = (link + 3) % 6	×
348	if inv_link in inv_chip_info.working_links:	×
349	inv_chip_info.working_links.remove(inv_link)	×
350	self._report_ignore(	×
351	"On chip {} ignoring link {} as it is the inverse "
352	"of link {} on chip {}", inv_xy, inv_link, link,
353	global_xy)
354	else:
355	self._report_ignore(	×
356	"Discarding ignore link {} on chip {} as it is not/"
357	"no longer in info", link, global_xy)
358
359	def _preprocess_ignore_cores(self, machine: Machine):	1✔
360	"""
361	Converts the collection of ignore cores into a map of ignore by x,y.
362
363	Converts any local (x, y, IP address) to global (x, y)
364
365	Discards (with log messages) any ignores which are known to have no
366	affect based on the already read chip_info
367
368	Converts any physical cores to virtual ones.
369	Core numbers <= 0 are assumed to be 0 - physical_id
370
371	:param ~spinn_machine.Machine machine:
372	An empty machine to handle wrap-arounds
373	"""
374	# Convert by IP to global
375	for ignore in IgnoreCore.parse_string(	×
376	get_config_str_or_none("Machine", "down_cores")):
377	global_xy = self._ignores_local_to_global(	×
378	ignore.x, ignore.y, ignore.ip_address, machine)
379	if global_xy is None:	×
380	continue	×
381	p = self._get_virtual_p(global_xy, ignore.p)	×
382	if p is not None:	×
383	self._ignore_cores_map[global_xy].add(p)	×
384
385	def _preprocess_ignore_chips(self, machine: Machine):	1✔
386	"""
387	Processes the collection of ignore chips and discards their chip info.
388
389	Converts any local (x, y IP address) to global (x, y)
390
391	Discards any ignores which are known to have no
392	affect based on the already read chip_info
393
394	Logs all actions except for ignores with unused IP addresses
395
396	:param ~spinn_machine.Machine machine:
397	An empty machine to handle wrap-arounds
398	"""
399	for ignore in IgnoreChip.parse_string(	×
400	get_config_str_or_none("Machine", "down_chips")):
401	# Convert by IP to global
402	global_xy = self._ignores_local_to_global(	×
403	ignore.x, ignore.y, ignore.ip_address, machine)
404	if global_xy is None:	×
405	continue # Never on this machine	×
406	chip_info = self._chip_info.pop(global_xy, None)	×
407	if chip_info is None:	×
408	continue # Already ignored maybe by a dead chip list	×
409	self._report_ignore("Chip {} will be ignored", global_xy)	×
410	for link in chip_info.working_links:	×
411	# ignore the inverse link
412	inv_xy = machine.xy_over_link(global_xy[0], global_xy[1], link)	×
413	if inv_xy in self._chip_info:	×
414	inv_chip_info = self._chip_info[inv_xy]	×
415	inv_link = (link + 3) % 6	×
416	if inv_link in inv_chip_info.working_links:	×
417	inv_chip_info.working_links.remove(inv_link)	×
418	self._report_ignore(	×
419	"On chip {} ignoring link {} as it points to "
420	"ignored chip chip {}",
421	inv_xy, inv_link, global_xy)
422
423	def _ignores_local_to_global(	1✔
424	self, local_x: int, local_y: int, ip_address: Optional[str],
425	machine: Machine) -> Optional[XY]:
426	"""
427	:param int local_x:
428	:param int local_y:
429	:param str ip_address:
430	:param ~spinn_machine.Machine machine:
431	:rtype: tuple(int,int)
432	"""
433	if ip_address is None:	×
434	global_xy = (local_x, local_y)	×
435	else:
436	ethernet = self._ethernet_by_ipaddress(ip_address)	×
437	if ethernet is None:	×
438	self._report_ignore(	×
439	"Ignore with ip:{} will be discarded as no board with "
440	"that ip in this machine", ip_address)
441	return None	×
442	global_xy = machine.get_global_xy(	×
443	local_x, local_y, ethernet[0], ethernet[1])
444	self._report_ignore(	×
445	"Ignores for local x:{} y:{} and ip:{} map to global {} with "
446	"root {}", local_x, local_y, ip_address, global_xy,
447	self._chip_info[(0, 0)].ethernet_ip_address)
448
449	if global_xy in self._chip_info:	×
450	return global_xy	×
451	else:
452	self._report_ignore(	×
453	"Ignore for global chip {} will be discarded as no such chip "
454	"in this machine", global_xy)
455	return None	×
456
457	def _ethernet_by_ipaddress(self, ip_address: str) -> Optional[XY]:	1✔
458	"""
459	:param str ip_address:
460	:rtype: tuple(int,int)
461	"""
462	if self._ethernets is None:	×
463	self._ethernets = dict()	×
464	for chip_info in self._chip_info.values():	×
465	if chip_info.ethernet_ip_address is not None:	×
466	self._ethernets[chip_info.ethernet_ip_address] = \	×
467	(chip_info.x, chip_info.y)
468	return self._ethernets.get(ip_address, None)	×
469
470	def _get_virtual_p(self, xy: XY, p: int) -> Optional[int]:	1✔
471	"""
472	:param tuple(int,int) xy:
473	:param int p:
474	:rtype: int
475	"""
476	if p > 0:	×
477	self._report_ignore("On chip {} ignoring core {}", xy, p)	×
478	return p	×
479	virtual_map = self._physical_to_virtual_map[xy]	×
480	physical = 0 - p	×
481	if physical >= len(virtual_map) or virtual_map[physical] == 0xFF:	×
482	self._report_ignore(	×
483	"On chip {} physical core {} was not used "
484	"so ignore is being discarded.", xy, physical)
485	return None	×
486	virtual_p = virtual_map[physical]	×
487	if virtual_p == 0:	×
488	self._report_ignore(	×
489	"On chip {} physical core {} was used as the monitor "
490	"so will NOT be ignored", xy, physical)
491	return None	×
492	self._report_ignore(	×
493	"On chip {} ignoring core {} as it maps to physical "
494	"core {}", xy, virtual_p, physical)
495	return virtual_p	×
496
497	def _report_ignore(self, message: str, *args):	1✔
498	"""
499	Writes the ignore message by either creating or appending the report.
500
501	The implementation choice to reopen the file every time is not the
502	fastest but is the cleanest and safest for code that in default
503	conditions is never run.
504
505	:param str message:
506	"""
507	full_message = message.format(*args) + "\n"	×
508	report_file = join(UtilsDataView.get_run_dir_path(), REPORT_FILE)	×
509	with open(report_file, "a", encoding="utf-8") as r_file:	×
510	r_file.write(full_message)	×

SpiNNakerManchester / SpiNNMan / 8843974228

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