def _load_executables(self):
""" Loads the router compressor onto the chips.
:return:
the executable targets that represent all cores/chips which have
active routing tables
:rtype: ExecutableTargets
"""
# build core subsets
core_subsets = CoreSubsets()
for routing_table in self._routing_tables:
# get the first none monitor core
chip = self._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(self._binary_path, core_subsets,
ExecutableType.SYSTEM)
return executable_targets
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 _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 filter_targets(targets, filt):
"""
:param ExecutableTargets executable_targets:
:param callable(ExecutableType,bool) filt:
:rtype: tuple(list(str), ExecutableTargets)
"""
binaries = []
cores = ExecutableTargets()
for exe_type in targets.executable_types_in_binary_set():
if filt(exe_type):
for aplx in targets.get_binaries_of_executable_type(exe_type):
binaries.append(aplx)
cores.add_subsets(
aplx, targets.get_cores_for_binary(aplx), exe_type)
return binaries, cores
def _load_executables(self, routing_tables, compressor_app_id, transceiver,
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 transceiver: 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 binary path
binary_path = os.path.join(
os.path.dirname(on_chip_router_table_compression.__file__),
"rt_minimise.aplx")
# build executable targets
executable_targets = ExecutableTargets()
executable_targets.add_subsets(binary_path, core_subsets)
transceiver.execute_application(executable_targets, compressor_app_id)
return executable_targets
def add_subsets(self, binary, subsets, executable_type=None):
SuperExecTargets.add_subsets(self, binary, subsets)
if executable_type is not None:
self._binary_type_map[executable_type].add(binary)
def mock_aplx(id):
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):
folder = tempfile.mkdtemp()
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 run_system_application(
executable_cores, app_id, transceiver, provenance_file_path,
executable_finder, read_algorithm_iobuf, check_for_success_function,
cpu_end_states, needs_sync_barrier, filename_template,
binaries_to_track=None, progress_bar=None):
""" Executes the given _system_ application. \
Used for on-chip expanders, compressors, etc.
:param ~.ExecutableTargets executable_cores:
the cores to run the executable on
:param int app_id: the app-id for the executable
:param ~.Transceiver transceiver: the SpiNNMan instance
:param str provenance_file_path:
the path for where provenance data is stored
:param ExecutableFinder executable_finder: finder for executable paths
:param bool read_algorithm_iobuf: whether to report IOBUFs
:param callable check_for_success_function:
function used to check success;
expects `executable_cores`, `transceiver` as inputs
:param set(~.CPUState) cpu_end_states:
the states that a successful run is expected to terminate in
:param bool needs_sync_barrier: whether a sync barrier is needed
:param str filename_template: the IOBUF filename template.
:param list(str) binaries_to_track:
A list of binary names to check for exit state.
Or `None` for all binaries
:param progress_bar: Possible progress bar to update.
end() will be called after state checked
:type progress_bar: ~spinn_utilities.progress_bar.ProgressBar or None
"""
# load the executable
transceiver.execute_application(executable_cores, app_id)
if needs_sync_barrier:
# fire all signals as required
transceiver.send_signal(app_id, Signal.SYNC0)
error = None
binary_start_types = dict()
if binaries_to_track is None:
check_targets = executable_cores
else:
check_targets = ExecutableTargets()
for binary_name in binaries_to_track:
check_targets.add_subsets(
binary_name,
executable_cores.get_cores_for_binary(binary_name))
for binary_name in executable_cores.binaries:
binary_start_types[binary_name] = ExecutableType.SYSTEM
# Wait for the executable to finish
try:
transceiver.wait_for_cores_to_be_in_state(
check_targets.all_core_subsets, app_id, cpu_end_states,
progress_bar=progress_bar)
if progress_bar is not None:
progress_bar.end()
succeeded = True
except (SpinnmanTimeoutException, SpinnmanException) as ex:
succeeded = False
# Delay the exception until iobuff is ready
error = ex
if progress_bar is not None:
progress_bar.end()
# Check if any cores have not completed successfully
if succeeded and check_for_success_function is not None:
succeeded = check_for_success_function(executable_cores, transceiver)
# if doing iobuf, read iobuf
if read_algorithm_iobuf or not succeeded:
iobuf_reader = ChipIOBufExtractor(
filename_template=filename_template,
suppress_progress=False)
iobuf_reader(
transceiver, executable_cores, executable_finder,
system_provenance_file_path=provenance_file_path)
# stop anything that's associated with the compressor binary
transceiver.stop_application(app_id)
transceiver.app_id_tracker.free_id(app_id)
if error is not None:
raise error # pylint: disable=raising-bad-type
return succeeded
