def __call__(
self,
# Machine information
machine,
machine_name,
version,
bmp_details,
down_chips,
down_cores,
number_of_boards,
height,
width,
auto_detect_bmp,
enable_reinjection,
scamp_connection_data,
boot_port_num,
reset_machine_on_start_up,
max_sdram_per_chip,
# Load data information
router_tables,
tags,
app_data_runtime_folder,
dsg_targets,
exec_dse_on_host,
dse_app_id,
# Buffer information
buffer_manager,
placements,
# Database notification information
wait_for_read_confirmation,
database_socket_addresses,
database_file_path,
send_start_notification,
# Execute information
executable_targets,
app_id,
runtime,
time_scale_factor,
total_machine_timesteps,
executable_finder,
time_threshold):
reload_script = ReloadScript(
machine_name, version, bmp_details, down_chips, down_cores,
number_of_boards, height, width, auto_detect_bmp,
enable_reinjection, scamp_connection_data, boot_port_num,
reset_machine_on_start_up, max_sdram_per_chip,
app_data_runtime_folder, exec_dse_on_host, dse_app_id,
wait_for_read_confirmation, database_file_path,
send_start_notification, app_id, runtime, time_scale_factor,
total_machine_timesteps, time_threshold)
for ip_tag in tags.ip_tags:
reload_script.add_ip_tag(ip_tag)
for reverse_ip_tag in tags.reverse_ip_tags:
reload_script.add_reverse_ip_tag(reverse_ip_tag)
for router_table in router_tables.routing_tables:
if not machine.get_chip_at(router_table.x, router_table.y).virtual:
if len(router_table.multicast_routing_entries) > 0:
reload_script.add_routing_table(router_table)
for socket_address in database_socket_addresses:
reload_script.add_socket_address(socket_address)
buffered_vertices_regions_file_paths = \
buffer_manager.reload_buffer_files
for buffered_vertex in buffer_manager.sender_vertices:
tag = tags.get_ip_tags_for_vertex(buffered_vertex)[0]
placement = placements.get_placement_of_subvertex(buffered_vertex)
reload_script.add_buffered_vertex(
buffered_vertex, tag, placement,
buffered_vertices_regions_file_paths[buffered_vertex])
for ((x, y, p), file_path) in dsg_targets.iteritems():
reload_script.add_dsg_target(x, y, p, file_path)
for binary in executable_targets.binaries:
reload_script.add_executable_target(
executable_finder.get_executable_path(binary),
executable_targets.get_cores_for_binary(binary))
# end reload script
reload_script.close()
return {"ReloadToken": True}
class FrontEndCommonInterfaceFunctions(object):
"""
the front end common interface which supports functions such as :
setting up the python spinnMachine
writing data to spinnaker machine
loading tags
etc
"""
def __init__(self, reports_states, report_default_directory, app_data_folder):
self._reports_states = reports_states
self._report_default_directory = report_default_directory
self._machine = None
self._app_data_folder = app_data_folder
self._reload_script = None
self._send_buffer_manager = None
def _auto_detect_database(self, partitioned_graph):
"""
autodetects if there is a need to activate the database system
:param partitioned_graph: the partitioned graph of the application
problem space.
:return: a bool which represents if the database is needed
"""
for vertex in partitioned_graph.subvertices:
if isinstance(vertex, LivePacketGather) or isinstance(vertex, ReverseIpTagMultiCastSource):
return True
else:
return False
def setup_interfaces(
self,
hostname,
bmp_details,
downed_chips,
downed_cores,
board_version,
number_of_boards,
width,
height,
is_virtual,
virtual_has_wrap_arounds,
auto_detect_bmp=True,
enable_reinjection=True,
):
"""
Set up the interfaces for communicating with the SpiNNaker board
:param hostname: the hostname or ip address of the spinnaker machine
:param bmp_details: the details of the BMP connections
:param downed_chips: the chips that are down which sark thinks are\
alive
:param downed_cores: the cores that are down which sark thinks are\
alive
:param board_version: the version of the boards being used within the\
machine (1, 2, 3, 4 or 5)
:param number_of_boards: the number of boards within the machine
:param width: The width of the machine in chips
:param height: The height of the machine in chips
:param is_virtual: True of the machine is virtual, False otherwise; if\
True, the width and height are used as the machine dimensions
:param virtual_has_wrap_arounds: True if the machine is virtual and\
should be created with wrap_arounds
:param auto_detect_bmp: boolean which determines if the bmp should
be automatically determined
:param enable_reinjection: True if dropped packet reinjection is to be\
enabled
:return: None
"""
if not is_virtual:
# sort out down chips and down cores if needed
ignored_chips, ignored_cores = self._sort_out_downed_chips_cores(downed_chips, downed_cores)
# sort out bmp connections into list of strings
bmp_connection_data = self._sort_out_bmp_string(bmp_details)
self._txrx = create_transceiver_from_hostname(
hostname=hostname,
bmp_connection_data=bmp_connection_data,
version=board_version,
ignore_chips=ignored_chips,
ignore_cores=ignored_cores,
number_of_boards=number_of_boards,
auto_detect_bmp=auto_detect_bmp,
)
# update number of boards from machine
if number_of_boards is None:
number_of_boards = self._txrx.number_of_boards_located
# do autoboot if possible
if board_version is None:
raise exceptions.ConfigurationException(
"Please set a machine version number in the configuration " "file (spynnaker.cfg or pacman.cfg)"
)
self._txrx.ensure_board_is_ready(number_of_boards, width, height, enable_reinjector=enable_reinjection)
self._txrx.discover_scamp_connections()
self._machine = self._txrx.get_machine_details()
if self._reports_states.transciever_report:
self._reload_script = ReloadScript(
self._app_data_folder,
hostname,
board_version,
bmp_details,
downed_chips,
downed_cores,
number_of_boards,
height,
width,
auto_detect_bmp,
enable_reinjection,
)
else:
self._machine = VirtualMachine(width=width, height=height, with_wrap_arounds=virtual_has_wrap_arounds)
@staticmethod
def _sort_out_bmp_cabinet_and_frame_string(bmp_cabinet_and_frame):
split_string = bmp_cabinet_and_frame.split(";", 2)
if len(split_string) == 1:
return [0, 0, split_string[0]]
if len(split_string) == 2:
return [0, split_string[0], split_string[1]]
return [split_string[0], split_string[1], split_string[2]]
@staticmethod
def _sort_out_bmp_boards_string(bmp_boards):
# If the string is a range of boards, get the range
range_match = re.match("(\d+)-(\d+)", bmp_boards)
if range_match is not None:
return range(int(range_match.group(1)), int(range_match.group(2)) + 1)
# Otherwise, assume a list of boards
return [int(board) for board in bmp_boards.split(",")]
@staticmethod
def _sort_out_bmp_string(bmp_string):
""" Take a BMP line and split it into the BMP connection data
:param bmp_string: the BMP string to be converted
:return: the BMP connection data
"""
bmp_details = list()
if bmp_string == "None":
return bmp_details
for bmp_detail in bmp_string.split(":"):
bmp_string_split = bmp_detail.split("/")
(cabinet, frame, hostname) = FrontEndCommonInterfaceFunctions._sort_out_bmp_cabinet_and_frame_string(
bmp_string_split[0]
)
if len(bmp_string_split) == 1:
# if there is no split, then assume its one board,
# located at position 0
bmp_details.append(BMPConnectionData(cabinet, frame, hostname, [0]))
else:
boards = FrontEndCommonInterfaceFunctions._sort_out_bmp_boards_string(bmp_string_split[1])
bmp_details.append(BMPConnectionData(cabinet, frame, hostname, boards))
return bmp_details
@staticmethod
def _sort_out_downed_chips_cores(downed_chips, downed_cores):
"""
translates the down cores and down chips string into stuff spinnman
can understand
:param downed_cores: string representing down cores
:type downed_cores: str
:param downed_chips: string representing down chips
:type: downed_chips: str
:return: a list of down cores and down chips in processor and coreset
format
"""
ignored_chips = None
ignored_cores = None
if downed_chips is not None and downed_chips != "None":
ignored_chips = CoreSubsets()
for downed_chip in downed_chips.split(":"):
x, y = downed_chip.split(",")
ignored_chips.add_core_subset(CoreSubset(int(x), int(y), []))
if downed_cores is not None and downed_cores != "None":
ignored_cores = CoreSubsets()
for downed_core in downed_cores.split(":"):
x, y, processor_id = downed_core.split(",")
ignored_cores.add_processor(int(x), int(y), int(processor_id))
return ignored_chips, ignored_cores
def set_up_send_buffering(self, partitioned_graph, placements, tags):
"""
interface for buffered vertices
:param partitioned_graph: the partitioned graph object
:param placements: the placements object
:param tags: the tags object
:return: None
"""
progress_bar = ProgressBar(len(partitioned_graph.subvertices), "Initialising buffers")
# Create the buffer manager
self._send_buffer_manager = BufferManager(
placements, tags, self._txrx, self._reports_states, self._app_data_folder, self._reload_script
)
for partitioned_vertex in partitioned_graph.subvertices:
if isinstance(partitioned_vertex, AbstractSendsBuffersFromHostPartitionedVertex):
# Add the vertex to the managed vertices
self._send_buffer_manager.add_sender_vertex(partitioned_vertex)
progress_bar.update()
progress_bar.end()
def load_tags(self, tags):
""" loads all the tags onto all the boards
:param tags: the tags object which contains ip and reverse ip tags.
:return none
"""
# clear all the tags from the ethernet connection, as nothing should
# be allowed to use it (no two sims should use the same etiehrnet
# connection at the same time
for tag_id in range(spinnman_constants.MAX_TAG_ID):
self._txrx.clear_ip_tag(tag_id)
self.load_iptags(tags.ip_tags)
self.load_reverse_iptags(tags.reverse_ip_tags)
def load_iptags(self, iptags):
"""
loads all the iptags individually.
:param iptags: the iptags to be loaded.
:return: none
"""
for ip_tag in iptags:
self._txrx.set_ip_tag(ip_tag)
if self._reports_states.transciever_report:
self._reload_script.add_ip_tag(ip_tag)
def load_reverse_iptags(self, reverse_ip_tags):
"""
loads all the reverse iptags individually.
:param reverse_ip_tags: the reverse iptags to be loaded
:return: None
"""
for reverse_ip_tag in reverse_ip_tags:
self._txrx.set_reverse_ip_tag(reverse_ip_tag)
if self._reports_states.transciever_report:
self._reload_script.add_reverse_ip_tag(reverse_ip_tag)
def execute_data_specification_execution(
self,
host_based_execution,
hostname,
placements,
graph_mapper,
write_text_specs,
runtime_application_data_folder,
machine,
):
"""
:param host_based_execution:
:param hostname:
:param placements:
:param graph_mapper:
:param write_text_specs:
:param runtime_application_data_folder:
:param machine:
:return:
"""
if host_based_execution:
return self.host_based_data_specification_execution(
hostname, placements, graph_mapper, write_text_specs, runtime_application_data_folder, machine
)
else:
return self._chip_based_data_specification_execution(hostname)
def _chip_based_data_specification_execution(self, hostname):
raise NotImplementedError
def host_based_data_specification_execution(
self, hostname, placements, graph_mapper, write_text_specs, application_data_runtime_folder, machine
):
"""
:param hostname:
:param placements:
:param graph_mapper:
:param write_text_specs:
:param application_data_runtime_folder:
:param machine:
:return:
"""
next_position_tracker = dict()
space_available_tracker = dict()
processor_to_app_data_base_address = dict()
# create a progress bar for end users
progress_bar = ProgressBar(len(list(placements.placements)), "Executing data specifications")
for placement in placements.placements:
associated_vertex = graph_mapper.get_vertex_from_subvertex(placement.subvertex)
# if the vertex can generate a DSG, call it
if isinstance(associated_vertex, AbstractDataSpecableVertex):
data_spec_file_path = associated_vertex.get_data_spec_file_path(
placement.x, placement.y, placement.p, hostname, application_data_runtime_folder
)
app_data_file_path = associated_vertex.get_application_data_file_path(
placement.x, placement.y, placement.p, hostname, application_data_runtime_folder
)
data_spec_reader = FileDataReader(data_spec_file_path)
data_writer = FileDataWriter(app_data_file_path)
# locate current memory requirement
chip = machine.get_chip_at(placement.x, placement.y)
next_position = chip.sdram.user_base_address
space_available = chip.sdram.size
placement_key = (placement.x, placement.y)
if placement_key in next_position_tracker:
next_position = next_position_tracker[placement_key]
space_available = space_available_tracker[placement_key]
# generate a file writer for dse report (app pointer table)
report_writer = None
if write_text_specs:
new_report_directory = os.path.join(self._report_default_directory, "data_spec_text_files")
if not os.path.exists(new_report_directory):
os.mkdir(new_report_directory)
file_name = "{}_DSE_report_for_{}_{}_{}.txt".format(hostname, placement.x, placement.y, placement.p)
report_file_path = os.path.join(new_report_directory, file_name)
report_writer = FileDataWriter(report_file_path)
# generate data spec executor
host_based_data_spec_executor = DataSpecificationExecutor(
data_spec_reader, data_writer, space_available, report_writer
)
# update memory calc and run data spec executor
bytes_used_by_spec = 0
bytes_written_by_spec = 0
try:
bytes_used_by_spec, bytes_written_by_spec = host_based_data_spec_executor.execute()
except DataSpecificationException as e:
logger.error("Error executing data specification for {}".format(associated_vertex))
raise e
# update base address mapper
processor_mapping_key = (placement.x, placement.y, placement.p)
processor_to_app_data_base_address[processor_mapping_key] = {
"start_address": next_position,
"memory_used": bytes_used_by_spec,
"memory_written": bytes_written_by_spec,
}
next_position_tracker[placement_key] = next_position + bytes_used_by_spec
space_available_tracker[placement_key] = space_available - bytes_used_by_spec
# update the progress bar
progress_bar.update()
# close the progress bar
progress_bar.end()
return processor_to_app_data_base_address
def wait_for_cores_to_be_ready(self, executable_targets, app_id):
total_processors = executable_targets.total_processors
all_core_subsets = executable_targets.all_core_subsets
processor_c_main = self._txrx.get_core_state_count(app_id, CPUState.C_MAIN)
# check that everything has gone though c main to reach sync0 or
# failing for some unknown reason
while processor_c_main != 0:
time.sleep(0.1)
processor_c_main = self._txrx.get_core_state_count(app_id, CPUState.C_MAIN)
# check that the right number of processors are in sync0
processors_ready = self._txrx.get_core_state_count(app_id, CPUState.SYNC0)
if processors_ready != total_processors:
unsuccessful_cores = self._get_cores_not_in_state(all_core_subsets, CPUState.SYNC0)
# last chance to slip out of error check
if len(unsuccessful_cores) != 0:
break_down = self._get_core_status_string(unsuccessful_cores)
raise exceptions.ExecutableFailedToStartException(
"Only {} processors out of {} have successfully reached "
"SYNC0:{}".format(processors_ready, total_processors, break_down)
)
def start_all_cores(self, executable_targets, app_id):
"""
:param executable_targets:
:param app_id:
:return:
"""
total_processors = executable_targets.total_processors
all_core_subsets = executable_targets.all_core_subsets
# if correct, start applications
logger.info("Starting application")
self._txrx.send_signal(app_id, SCPSignal.SYNC0)
# check all apps have gone into run state
logger.info("Checking that the application has started")
processors_running = self._txrx.get_core_state_count(app_id, CPUState.RUNNING)
if processors_running < total_processors:
processors_finished = self._txrx.get_core_state_count(app_id, CPUState.FINISHED)
if processors_running + processors_finished >= total_processors:
logger.warn("some processors finished between signal " "transmissions. Could be a sign of an error")
else:
unsuccessful_cores = self._get_cores_not_in_state(all_core_subsets, CPUState.RUNNING)
break_down = self._get_core_status_string(unsuccessful_cores)
raise exceptions.ExecutableFailedToStartException(
"Only {} of {} processors started:{}".format(processors_running, total_processors, break_down)
)
def wait_for_execution_to_complete(self, executable_targets, app_id, runtime, time_scaling):
"""
:param executable_targets:
:param app_id:
:param runtime:
:param time_scaling:
:return:
"""
total_processors = executable_targets.total_processors
all_core_subsets = executable_targets.all_core_subsets
time_to_wait = ((runtime * time_scaling) / 1000.0) + 1.0
logger.info("Application started - waiting {} seconds for it to" " stop".format(time_to_wait))
time.sleep(time_to_wait)
processors_not_finished = total_processors
while processors_not_finished != 0:
processors_rte = self._txrx.get_core_state_count(app_id, CPUState.RUN_TIME_EXCEPTION)
if processors_rte > 0:
rte_cores = self._get_cores_in_state(all_core_subsets, CPUState.RUN_TIME_EXCEPTION)
break_down = self._get_core_status_string(rte_cores)
raise exceptions.ExecutableFailedToStopException(
"{} cores have gone into a run time error state:" "{}".format(processors_rte, break_down)
)
processors_not_finished = self._txrx.get_core_state_count(app_id, CPUState.RUNNING)
if processors_not_finished > 0:
logger.info("Simulation still not finished or failed - " "waiting a bit longer...")
time.sleep(0.5)
processors_exited = self._txrx.get_core_state_count(app_id, CPUState.FINISHED)
if processors_exited < total_processors:
unsuccessful_cores = self._get_cores_not_in_state(all_core_subsets, CPUState.FINISHED)
break_down = self._get_core_status_string(unsuccessful_cores)
raise exceptions.ExecutableFailedToStopException(
"{} of {} processors failed to exit successfully:"
"{}".format(total_processors - processors_exited, total_processors, break_down)
)
if self._reports_states.transciever_report:
self._reload_script.close()
if self._send_buffer_manager is not None:
self._send_buffer_manager.stop()
logger.info("Application has run to completion")
def _get_cores_in_state(self, all_core_subsets, state):
core_infos = self._txrx.get_cpu_information(all_core_subsets)
cores_in_state = OrderedDict()
for core_info in core_infos:
if core_info.state == state:
cores_in_state[(core_info.x, core_info.y, core_info.p)] = core_info
return cores_in_state
def _get_cores_not_in_state(self, all_core_subsets, state):
core_infos = self._txrx.get_cpu_information(all_core_subsets)
cores_not_in_state = OrderedDict()
for core_info in core_infos:
if core_info.state != state:
cores_not_in_state[(core_info.x, core_info.y, core_info.p)] = core_info
return cores_not_in_state
@staticmethod
def _get_core_status_string(core_infos):
break_down = "\n"
for ((x, y, p), core_info) in core_infos.iteritems():
if core_info.state == CPUState.RUN_TIME_EXCEPTION:
break_down += " {}:{}:{} in state {}:{}\n".format(
x, y, p, core_info.state.name, core_info.run_time_error.name
)
else:
break_down += " {}:{}:{} in state {}\n".format(x, y, p, core_info.state.name)
return break_down
def _load_application_data(
self,
placements,
vertex_to_subvertex_mapper,
processor_to_app_data_base_address,
hostname,
app_data_folder,
verify=False,
):
# go through the placements and see if there's any application data to
# load
progress_bar = ProgressBar(len(list(placements.placements)), "Loading application data onto the machine")
for placement in placements.placements:
associated_vertex = vertex_to_subvertex_mapper.get_vertex_from_subvertex(placement.subvertex)
if isinstance(associated_vertex, AbstractDataSpecableVertex):
logger.debug("loading application data for vertex {}".format(associated_vertex.label))
key = (placement.x, placement.y, placement.p)
start_address = processor_to_app_data_base_address[key]["start_address"]
memory_written = processor_to_app_data_base_address[key]["memory_written"]
file_path_for_application_data = associated_vertex.get_application_data_file_path(
placement.x, placement.y, placement.p, hostname, app_data_folder
)
application_data_file_reader = SpinnmanFileDataReader(file_path_for_application_data)
logger.debug("writing application data for vertex {}".format(associated_vertex.label))
self._txrx.write_memory(
placement.x, placement.y, start_address, application_data_file_reader, memory_written
)
application_data_file_reader.close()
if verify:
application_data_file_reader = SpinnmanFileDataReader(file_path_for_application_data)
all_data = application_data_file_reader.readall()
read_data = self._txrx.read_memory(placement.x, placement.y, start_address, memory_written)
if read_data != all_data:
raise Exception(
"Miswrite of {}, {}, {}, {}".format(placement.x, placement.y, placement.p, start_address)
)
application_data_file_reader.close()
# update user 0 so that it points to the start of the
# applications data region on sdram
logger.debug("writing user 0 address for vertex {}".format(associated_vertex.label))
user_o_register_address = self._txrx.get_user_0_register_address_from_core(
placement.x, placement.y, placement.p
)
self._txrx.write_memory(placement.x, placement.y, user_o_register_address, start_address)
# add lines to rerun_script if requested
if self._reports_states.transciever_report:
self._reload_script.add_application_data(file_path_for_application_data, placement, start_address)
progress_bar.update()
progress_bar.end()
def load_routing_tables(self, router_tables, app_id):
progress_bar = ProgressBar(len(list(router_tables.routing_tables)), "Loading routing data onto the machine")
# load each router table that is needed for the application to run into
# the chips sdram
for router_table in router_tables.routing_tables:
if not self._machine.get_chip_at(router_table.x, router_table.y).virtual:
self._txrx.clear_multicast_routes(router_table.x, router_table.y)
self._txrx.clear_router_diagnostic_counters(router_table.x, router_table.y)
if len(router_table.multicast_routing_entries) > 0:
self._txrx.load_multicast_routes(
router_table.x, router_table.y, router_table.multicast_routing_entries, app_id=app_id
)
if self._reports_states.transciever_report:
self._reload_script.add_routing_table(router_table)
progress_bar.update()
progress_bar.end()
def load_executable_images(self, executable_targets, app_id):
""" Go through the executable targets and load each binary to \
everywhere and then send a start request to the cores that \
actually use it
"""
progress_bar = ProgressBar(executable_targets.total_processors, "Loading executables onto the machine")
for executable_target_key in executable_targets.binary_paths():
file_reader = SpinnmanFileDataReader(executable_target_key)
core_subset = executable_targets.retrieve_cores_for_a_executable_target(executable_target_key)
statinfo = os.stat(executable_target_key)
size = statinfo.st_size
# TODO there is a need to parse the binary and see if its
# ITCM and DTCM requirements are within acceptable params for
# operating on spinnaker. Currnently there jsut a few safety
# checks which may not be accurate enough.
if size > constants.MAX_SAFE_BINARY_SIZE:
logger.warn(
"The size of this binary is large enough that its"
" possible that the binary may be larger than what is"
" supported by spinnaker currently. Please reduce the"
" binary size if it starts to behave strangely, or goes"
" into the wdog state before starting."
)
if size > constants.MAX_POSSIBLE_BINARY_SIZE:
raise exceptions.ConfigurationException(
"The size of the binary is too large and therefore"
" will very likely cause a WDOG state. Until a more"
" precise measurement of ITCM and DTCM can be produced"
" this is deemed as an error state. Please reduce the"
" size of your binary or circumvent this error check."
)
self._txrx.execute_flood(core_subset, file_reader, app_id, size)
if self._reports_states.transciever_report:
self._reload_script.add_binary(executable_target_key, core_subset)
acutal_cores_loaded = 0
for chip_based in core_subset.core_subsets:
for _ in chip_based.processor_ids:
acutal_cores_loaded += 1
progress_bar.update(amount_to_add=acutal_cores_loaded)
progress_bar.end()
def setup_interfaces(
self,
hostname,
bmp_details,
downed_chips,
downed_cores,
board_version,
number_of_boards,
width,
height,
is_virtual,
virtual_has_wrap_arounds,
auto_detect_bmp=True,
enable_reinjection=True,
):
"""
Set up the interfaces for communicating with the SpiNNaker board
:param hostname: the hostname or ip address of the spinnaker machine
:param bmp_details: the details of the BMP connections
:param downed_chips: the chips that are down which sark thinks are\
alive
:param downed_cores: the cores that are down which sark thinks are\
alive
:param board_version: the version of the boards being used within the\
machine (1, 2, 3, 4 or 5)
:param number_of_boards: the number of boards within the machine
:param width: The width of the machine in chips
:param height: The height of the machine in chips
:param is_virtual: True of the machine is virtual, False otherwise; if\
True, the width and height are used as the machine dimensions
:param virtual_has_wrap_arounds: True if the machine is virtual and\
should be created with wrap_arounds
:param auto_detect_bmp: boolean which determines if the bmp should
be automatically determined
:param enable_reinjection: True if dropped packet reinjection is to be\
enabled
:return: None
"""
if not is_virtual:
# sort out down chips and down cores if needed
ignored_chips, ignored_cores = self._sort_out_downed_chips_cores(downed_chips, downed_cores)
# sort out bmp connections into list of strings
bmp_connection_data = self._sort_out_bmp_string(bmp_details)
self._txrx = create_transceiver_from_hostname(
hostname=hostname,
bmp_connection_data=bmp_connection_data,
version=board_version,
ignore_chips=ignored_chips,
ignore_cores=ignored_cores,
number_of_boards=number_of_boards,
auto_detect_bmp=auto_detect_bmp,
)
# update number of boards from machine
if number_of_boards is None:
number_of_boards = self._txrx.number_of_boards_located
# do autoboot if possible
if board_version is None:
raise exceptions.ConfigurationException(
"Please set a machine version number in the configuration " "file (spynnaker.cfg or pacman.cfg)"
)
self._txrx.ensure_board_is_ready(number_of_boards, width, height, enable_reinjector=enable_reinjection)
self._txrx.discover_scamp_connections()
self._machine = self._txrx.get_machine_details()
if self._reports_states.transciever_report:
self._reload_script = ReloadScript(
self._app_data_folder,
hostname,
board_version,
bmp_details,
downed_chips,
downed_cores,
number_of_boards,
height,
width,
auto_detect_bmp,
enable_reinjection,
)
else:
self._machine = VirtualMachine(width=width, height=height, with_wrap_arounds=virtual_has_wrap_arounds)
def __call__(
self,
tags,
app_data_folder,
hostname,
board_version,
bmp_details,
downed_chips,
downed_cores,
number_of_boards,
height,
width,
auto_detect_bmp,
enable_reinjection,
processor_to_app_data_base_address,
placements,
router_tables,
machine,
executable_targets,
run_time,
time_scale_factor,
database_socket_addresses,
wait_on_confirmation,
placement_to_app_data_files,
buffer_manager,
scamp_connection_data,
boot_port_num,
verify,
database_file_path,
send_start_notification,
reset_machine_on_start_up,
):
reload_script = ReloadScript(
app_data_folder,
hostname,
board_version,
bmp_details,
downed_chips,
downed_cores,
number_of_boards,
height,
width,
auto_detect_bmp,
enable_reinjection,
scamp_connection_data,
boot_port_num,
placement_to_app_data_files,
verify,
processor_to_app_data_base_address,
executable_targets,
wait_on_confirmation,
database_file_path,
run_time,
time_scale_factor,
send_start_notification,
reset_machine_on_start_up,
)
for ip_tag in tags.ip_tags:
reload_script.add_ip_tag(ip_tag)
for reverse_ip_tag in tags.reverse_ip_tags:
reload_script.add_reverse_ip_tag(reverse_ip_tag)
for router_table in router_tables.routing_tables:
if not machine.get_chip_at(router_table.x, router_table.y).virtual:
if len(router_table.multicast_routing_entries) > 0:
reload_script.add_routing_table(router_table)
for socket_address in database_socket_addresses:
reload_script.add_socket_address(socket_address)
buffered_vertices_regions_file_paths = buffer_manager.reload_buffer_files
for buffered_vertex in buffer_manager.sender_vertices:
tag = tags.get_ip_tags_for_vertex(buffered_vertex)[0]
placement = placements.get_placement_of_subvertex(buffered_vertex)
reload_script.add_buffered_vertex(
buffered_vertex, tag, placement, buffered_vertices_regions_file_paths[buffered_vertex]
)
# end reload script
reload_script.close()
return {"ReloadToken": True}
