def _load_executables(routing_tables, compressor_app_id, txrx, machine):
""" Loads the router compressor onto the chips.
:param routing_tables: the router tables needed to be compressed
:param compressor_app_id: the app ID of the compressor compressor
:param txrx: the spinnman interface
:param machine: the SpiNNaker machine representation
:return:\
the executable targets that represent all cores/chips which have\
active routing tables
"""
# build core subsets
core_subsets = CoreSubsets()
for routing_table in routing_tables:
# get the first none monitor core
chip = machine.get_chip_at(routing_table.x, routing_table.y)
processor = chip.get_first_none_monitor_processor()
# add to the core subsets
core_subsets.add_processor(
routing_table.x, routing_table.y, processor.processor_id)
# build executable targets
executable_targets = ExecutableTargets()
executable_targets.add_subsets(_BINARY_PATH, core_subsets)
txrx.execute_application(executable_targets, compressor_app_id)
return executable_targets
def test_add_processor(self):
proc_list = [0, 1, 2, 3, 5, 8, 13]
cs = CoreSubset(0, 0, proc_list)
css = CoreSubsets()
css.add_core_subset(cs)
self.assertIn(cs, css.core_subsets)
for core_subset in css.core_subsets:
self.assertIn(core_subset, [cs])
def convert_string_into_chip_and_core_subset(cores):
""" Translate a string list of cores into a core subset
:param cores:\
string representing down cores formatted as x,y,p[:x,y,p]*
:type cores: str or None
"""
ignored_cores = CoreSubsets()
if cores is not None and cores != "None":
for downed_core in cores.split(":"):
x, y, processor_id = downed_core.split(",")
ignored_cores.add_processor(int(x), int(y), int(processor_id))
return ignored_cores
def convert_vertices_to_core_subset(vertices, placements):
""" Converts vertices into core subsets.
:param extra_monitor_cores_to_set:\
the vertices to convert to core subsets
:param placements: the placements object
:return: the CoreSubSets of the vertices
"""
core_subsets = CoreSubsets()
for vertex in vertices:
placement = placements.get_placement_of_vertex(vertex)
core_subsets.add_processor(placement.x, placement.y, placement.p)
return core_subsets
class ExecutableTargets(object):
""" Encapsulate the binaries and cores on which to execute them.
"""
__slots__ = [
"_all_core_subsets",
"_targets",
"_total_processors"]
def __init__(self):
self._targets = dict()
self._total_processors = 0
self._all_core_subsets = CoreSubsets()
def add_subsets(self, binary, subsets):
""" Add core subsets to a binary
:param binary: the path to the binary needed to be executed
:param subsets: \
the subset of cores that the binary needs to be loaded on
:return:
"""
for subset in subsets.core_subsets:
for p in subset.processor_ids:
self.add_processor(binary, subset.x, subset.y, p)
def add_processor(self, binary, chip_x, chip_y, chip_p):
""" Add a processor to the executable targets
:param binary: the binary path for executable
:param chip_x: the coordinate on the machine in terms of x for the chip
:param chip_y: the coordinate on the machine in terms of y for the chip
:param chip_p: the processor ID to place this executable on
:return:
"""
if self.known(binary, chip_x, chip_y, chip_p):
return
if binary not in self._targets:
self._targets[binary] = CoreSubsets()
self._targets[binary].add_processor(chip_x, chip_y, chip_p)
self._all_core_subsets.add_processor(chip_x, chip_y, chip_p)
self._total_processors += 1
def get_cores_for_binary(self, binary):
""" Get the cores that a binary is to run on
:param binary: The binary to find the cores for
"""
return self._targets.get(binary)
@property
def binaries(self):
""" The binaries of the executables
"""
return self._targets.keys()
@property
def total_processors(self):
""" The total number of cores to be loaded
"""
return self._total_processors
@property
def all_core_subsets(self):
""" All the core subsets for all the binaries
"""
return self._all_core_subsets
def known(self, binary, chip_x, chip_y, chip_p):
if self._all_core_subsets.is_core(chip_x, chip_y, chip_p):
# OK if and only if the chip is in this binary already
if binary in self._targets:
if self._targets[binary].is_core(chip_x, chip_y, chip_p):
return True
parameter = "x:{} y:{} p:{}".format(chip_x, chip_y, chip_p)
problem = "Already associated with a different binary"
raise SpinnmanInvalidParameterException(parameter, binary, problem)
else:
return False
def __init__(self):
self._targets = dict()
self._total_processors = 0
self._all_core_subsets = CoreSubsets()
class ExecutableTargets(object):
""" Encapsulate the binaries and cores on which to execute them.
"""
__slots__ = [
"_all_core_subsets", "_targets", "_total_processors",
"_binary_type_map"
]
def __init__(self):
self._targets = dict()
self._total_processors = 0
self._all_core_subsets = CoreSubsets()
self._binary_type_map = defaultdict(OrderedSet)
def add_subsets(self, binary, subsets, executable_type=None):
""" Add core subsets to a binary
:param str binary: the path to the binary needed to be executed
:param ~spinn_machine.CoreSubsets subsets:
the subset of cores that the binary needs to be loaded on
:param ~spinn_front_end_common.utilities.utility_objs.ExecutableType \
executable_type:
The type of this executable.
``None`` means don't record it.
"""
try:
for subset in subsets.core_subsets:
for p in subset.processor_ids:
self.add_processor(binary, subset.x, subset.y, p)
except AttributeError:
if subsets is not None:
raise
if executable_type is not None:
self._binary_type_map[executable_type].add(binary)
def add_processor(self,
binary,
chip_x,
chip_y,
chip_p,
executable_type=None):
""" Add a processor to the executable targets
:param str binary: the binary path for executable
:param int chip_x:
the coordinate on the machine in terms of x for the chip
:param int chip_y:
the coordinate on the machine in terms of y for the chip
:param int chip_p: the processor ID to place this executable on
:param ~spinn_front_end_common.utilities.utility_objs.ExecutableType \
executable_type:
the executable type for locating n cores of
"""
if self.known(binary, chip_x, chip_y, chip_p):
return
if binary not in self._targets:
self._targets[binary] = CoreSubsets()
if executable_type is not None:
self._binary_type_map[executable_type].add(binary)
self._targets[binary].add_processor(chip_x, chip_y, chip_p)
self._all_core_subsets.add_processor(chip_x, chip_y, chip_p)
self._total_processors += 1
def get_n_cores_for_executable_type(self, executable_type):
""" get the number of cores that the executable type is using
:param ~spinn_front_end_common.utilities.utility_objs.ExecutableType \
executable_type:
the executable type for locating n cores of
:return: the number of cores using this executable type
:rtype: int
"""
return sum(
len(self.get_cores_for_binary(aplx))
for aplx in self._binary_type_map[executable_type])
def get_binaries_of_executable_type(self, executable_type):
""" get the binaries of a given a executable type
:param ~spinn_front_end_common.utilities.utility_objs.ExecutableType \
executable_type:
the executable type enum value
:return: iterable of binaries with that executable type
:rtype: iterable(str)
"""
return self._binary_type_map[executable_type]
def executable_types_in_binary_set(self):
""" get the executable types in the set of binaries
:return: iterable of the executable types in this binary set.
:rtype:
iterable(~spinn_front_end_common.utilities.utility_objs.ExecutableType)
"""
return self._binary_type_map.keys()
def get_cores_for_binary(self, binary):
""" Get the cores that a binary is to run on
:param str binary: The binary to find the cores for
"""
return self._targets.get(binary)
@property
def binaries(self):
""" The binaries of the executables
:rtype: iterable(str)
"""
return self._targets.keys()
@property
def total_processors(self):
""" The total number of cores to be loaded
:rtype: int
"""
return self._total_processors
@property
def all_core_subsets(self):
""" All the core subsets for all the binaries
:rtype: ~spinn_machine.CoreSubsets
"""
return self._all_core_subsets
def known(self, binary, chip_x, chip_y, chip_p):
"""
:param str binary:
:param int chip_x:
:param int chip_y:
:param int chip_p:
:rtype: bool
"""
if not self._all_core_subsets.is_core(chip_x, chip_y, chip_p):
return False
# OK if and only if the chip is in this binary already
if binary in self._targets:
if self._targets[binary].is_core(chip_x, chip_y, chip_p):
return True
parameter = "x:{} y:{} p:{}".format(chip_x, chip_y, chip_p)
problem = "Already associated with a different binary"
raise SpinnmanInvalidParameterException(parameter, binary, problem)
from spinnman.model.enums import (
DiagnosticFilterDestination, DiagnosticFilterPacketType)
from spinnman.constants import ROUTER_REGISTER_REGISTERS
from board_test_configuration import BoardTestConfiguration
logging.basicConfig(level=logging.INFO)
logging.getLogger("spinnman.transceiver").setLevel(logging.DEBUG)
board_config = BoardTestConfiguration()
board_config.set_up_remote_board()
n_cores = 20
core_subsets = CoreSubsets(core_subsets=[CoreSubset(0, 0, range(1, 11)),
CoreSubset(1, 1, range(1, 11))])
down_cores = CoreSubsets()
down_cores.add_processor(0, 0, 5)
down_chips = CoreSubsets(core_subsets=[CoreSubset(0, 1, [])])
def print_enums(name, enum_list):
string = ""
for enum_value in enum_list:
string += enum_value.name + "; "
print(name, string)
def print_word_as_binary(name, word, start=0, end=32, fields=None):
start_fields = set()
end_fields = set()
if fields is not None:
return os.path.join(path, "mock{}.aplx".format(id))
extractor = ChipIOBufExtractor()
executableFinder = ExecutableFinder([path])
transceiver = _PretendTransceiver([
IOBuffer(0, 0, 1, text001),
IOBuffer(0, 0, 2, text002),
IOBuffer(1, 1, 1, text111),
IOBuffer(1, 1, 2, text112),
IOBuffer(0, 0, 3, text003)
])
executable_targets = ExecutableTargets()
core_subsets = CoreSubsets([CoreSubset(0, 0, [1, 2])])
fooaplx = mock_aplx("foo")
executable_targets.add_subsets(fooaplx, core_subsets)
core_subsets = CoreSubsets([CoreSubset(1, 1, [1, 2])])
baraplx = mock_aplx("bar")
executable_targets.add_subsets(baraplx, core_subsets)
core_subsets = CoreSubsets([CoreSubset(0, 0, [3])])
alphaaplx = mock_aplx("alpha")
executable_targets.add_subsets(alphaaplx, core_subsets)
class TestFrontEndCommonChipIOBufExtractor(unittest.TestCase):
def testExectuableFinder(self):
self.assertIn(fooaplx, executableFinder.get_executable_path(fooaplx))
def testCallSimple(self):
def system_cores(exec_targets):
cores = CoreSubsets()
for binary in exec_targets.get_binaries_of_executable_type(
ExecutableType.SYSTEM):
cores.add_core_subsets(exec_targets.get_cores_for_binary(binary))
return cores
def _generate_core_subsets(
self, routing_tables, executable_finder, machine, progress_bar,
system_executable_targets):
""" generates the core subsets for the binaries
:param ~.MulticastRoutingTables routing_tables: the routing tables
:param ~.ExecutableFinder executable_finder: the executable path finder
:param ~.Machine machine: the spinn machine instance
:param ~.ProgressBar progress_bar: progress bar
:param ExecutableTargets system_executable_targets:
the executables targets to cores
:return: (targets, sorter path, and compressor path)
:rtype: tuple(ExecutableTargets, str, str)
"""
bit_field_sorter_cores = CoreSubsets()
bit_field_compressor_cores = CoreSubsets()
_, cores = LoadExecutableImages.filter_targets(
system_executable_targets, lambda ty: ty is ExecutableType.SYSTEM)
for routing_table in progress_bar.over(routing_tables, False):
# add 1 core to the sorter, and the rest to compressors
sorter = None
for processor in machine.get_chip_at(
routing_table.x, routing_table.y).processors:
if (not processor.is_monitor and
not cores.all_core_subsets.is_core(
routing_table.x, routing_table.y,
processor.processor_id)):
if sorter is None:
sorter = processor
bit_field_sorter_cores.add_processor(
routing_table.x, routing_table.y,
processor.processor_id)
else:
bit_field_compressor_cores.add_processor(
routing_table.x, routing_table.y,
processor.processor_id)
# convert core subsets into executable targets
executable_targets = ExecutableTargets()
# bit field executable paths
bit_field_sorter_executable_path = \
executable_finder.get_executable_path(
self._BIT_FIELD_SORTER_AND_SEARCH_EXECUTOR_APLX)
bit_field_compressor_executable_path = \
executable_finder.get_executable_path(self.compressor_aplx)
# add the sets
executable_targets.add_subsets(
binary=bit_field_sorter_executable_path,
subsets=bit_field_sorter_cores,
executable_type=ExecutableType.SYSTEM)
executable_targets.add_subsets(
binary=bit_field_compressor_executable_path,
subsets=bit_field_compressor_cores,
executable_type=ExecutableType.SYSTEM)
return (executable_targets, bit_field_sorter_executable_path,
bit_field_compressor_executable_path)
def test_add_core_subset_duplicate_core_subset(self):
proc_list = [0, 1, 2, 3, 5, 8, 13]
cs = CoreSubset(0, 0, proc_list)
css = CoreSubsets([cs])
css.add_core_subset(cs)
def test_add_processor_duplicate_processor_different_chip(self):
proc_list = [0, 1, 2, 3, 5, 8, 13]
cs = CoreSubset(0, 0, proc_list)
css = CoreSubsets([cs])
css.add_processor(0, 1, 0)
