Source code for spinnman.model.p2p_table

# 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 struct
from typing import Dict, List, Tuple
from spinnman.model.enums import P2PTableRoute

_ONE_WORD = struct.Struct("<I")


class P2PTable(object):
    """
    Represents a P2P routing table read from the machine.
    """
    __slots__ = [
        "_height",
        "_routes",
        "_width"]

    def __init__(self, width: int, height: int,
                 column_data: List[Tuple[bytes, int]]):
        """
        :param int width:
        :param int height:
        :param list(tuple(bytes,int)) column_data:
        """
        self._routes: Dict[Tuple[int, int], P2PTableRoute] = dict()
        self._width = width
        self._height = height
        for x, (data, offset) in enumerate(column_data):
            y = 0
            pos = 0
            while y < height:
                next_word, = _ONE_WORD.unpack_from(data, offset + (pos * 4))
                pos += 1
                for entry in range(min(8, height - y)):
                    route = P2PTableRoute((next_word >> (3 * entry)) & 0b111)
                    if route is not P2PTableRoute.NONE:
                        self._routes[x, y] = route
                    y += 1

[docs] @staticmethod def get_n_column_bytes(height: int) -> int: """ Get the number of bytes to be read for each column of the table. :param int height: The height of the machine """ return ((height + 7) // 8) * 4
[docs] @staticmethod def get_column_offset(column: int) -> int: """ Get the offset of the next column in the table from the P2P base address. :param int column: The column to be read """ return (((256 * column) // 8) * 4)
@property def width(self) -> int: """ The width of the machine that this table represents. :rtype: int """ return self._width @property def height(self) -> int: """ The height of the machine that this table represents. :rtype: int """ return self._height
[docs] def iterchips(self): """ Get an iterator of tuples of (x, y) coordinates in the table. :rtype: iterable(tuple(int,int)) """ return iter(self._routes.keys())
[docs] def is_route(self, x, y): """ Determines if there is a route in the P2P table to the given chip. :param int x: The x-coordinate of the chip to look up :param int y: The y-coordinate of the chip to look up :rtype: bool """ return ( (x, y) in self._routes and self._routes[(x, y)] != P2PTableRoute.NONE)
[docs] def get_route(self, x: int, y: int) -> P2PTableRoute: """ Get the route to follow from this chip to the given chip. :param int x: The x-coordinate of the chip to find the route to :param int y: The y-coordinate of the chip to find the route to :rtype: P2PTableRoute """ return self._routes.get((x, y), P2PTableRoute.NONE)
@property def n_routes(self): """ The number of routes in the table :rtype: int """ return len(self._routes)