def run(self, run_time):
"""
:param run_time:
:return:
"""
# sort out config param to be valid types
width = config.get("Machine", "width")
height = config.get("Machine", "height")
if width == "None":
width = None
else:
width = int(width)
if height == "None":
height = None
else:
height = int(height)
number_of_boards = config.get("Machine", "number_of_boards")
if number_of_boards == "None":
number_of_boards = None
self.setup_interfaces(
hostname=self._hostname,
bmp_details=config.get("Machine", "bmp_names"),
downed_chips=config.get("Machine", "down_chips"),
downed_cores=config.get("Machine", "down_cores"),
board_version=config.getint("Machine", "version"),
number_of_boards=number_of_boards,
width=width,
height=height,
is_virtual=config.getboolean("Machine", "virtual_board"),
virtual_has_wrap_arounds=config.getboolean(
"Machine", "requires_wrap_arounds"),
auto_detect_bmp=config.getboolean("Machine", "auto_detect_bmp"))
# adds extra stuff needed by the reload script which cannot be given
# directly.
if self._reports_states.transciever_report:
self._reload_script.runtime = run_time
self._reload_script.time_scale_factor = self._time_scale_factor
# create network report if needed
if self._reports_states is not None:
reports.network_specification_partitionable_report(
self._report_default_directory, self._partitionable_graph,
self._hostname)
# calculate number of machine time steps
if run_time is not None:
self._no_machine_time_steps =\
int((run_time * 1000.0) / self._machine_time_step)
ceiled_machine_time_steps = \
math.ceil((run_time * 1000.0) / self._machine_time_step)
if self._no_machine_time_steps != ceiled_machine_time_steps:
raise common_exceptions.ConfigurationException(
"The runtime and machine time step combination result in "
"a factional number of machine runable time steps and "
"therefore spinnaker cannot determine how many to run for")
for vertex in self._partitionable_graph.vertices:
if isinstance(vertex, AbstractDataSpecableVertex):
vertex.set_no_machine_time_steps(
self._no_machine_time_steps)
else:
self._no_machine_time_steps = None
logger.warn("You have set a runtime that will never end, this may"
"cause the neural models to fail to partition "
"correctly")
for vertex in self._partitionable_graph.vertices:
if (isinstance(vertex, AbstractPopulationRecordableVertex)
and vertex.record):
raise common_exceptions.ConfigurationException(
"recording a population when set to infinite runtime "
"is not currently supportable in this tool chain."
"watch this space")
do_timing = config.getboolean("Reports", "outputTimesForSections")
if do_timing:
timer = Timer()
else:
timer = None
self.set_runtime(run_time)
logger.info("*** Running Mapper *** ")
if do_timing:
timer.start_timing()
self.map_model()
if do_timing:
timer.take_sample()
# add database generation if requested
needs_database = self._auto_detect_database(self._partitioned_graph)
user_create_database = config.get("Database", "create_database")
if ((user_create_database == "None" and needs_database)
or user_create_database == "True"):
wait_on_confirmation = config.getboolean("Database",
"wait_on_confirmation")
self._database_interface = SpynnakerDataBaseInterface(
self._app_data_runtime_folder, wait_on_confirmation,
self._database_socket_addresses)
self._database_interface.add_system_params(self._time_scale_factor,
self._machine_time_step,
self._runtime)
self._database_interface.add_machine_objects(self._machine)
self._database_interface.add_partitionable_vertices(
self._partitionable_graph)
self._database_interface.add_partitioned_vertices(
self._partitioned_graph, self._graph_mapper,
self._partitionable_graph)
self._database_interface.add_placements(self._placements,
self._partitioned_graph)
self._database_interface.add_routing_infos(self._routing_infos,
self._partitioned_graph)
self._database_interface.add_routing_tables(self._router_tables)
self._database_interface.add_tags(self._partitioned_graph,
self._tags)
execute_mapping = config.getboolean(
"Database", "create_routing_info_to_neuron_id_mapping")
if execute_mapping:
self._database_interface.create_neuron_to_key_mapping(
graph_mapper=self._graph_mapper,
partitionable_graph=self._partitionable_graph,
partitioned_graph=self._partitioned_graph,
routing_infos=self._routing_infos)
# if using a reload script, add if that needs to wait for
# confirmation
if self._reports_states.transciever_report:
self._reload_script.wait_on_confirmation = wait_on_confirmation
for socket_address in self._database_socket_addresses:
self._reload_script.add_socket_address(socket_address)
self._database_interface.send_read_notification()
# execute data spec generation
if do_timing:
timer.start_timing()
logger.info("*** Generating Output *** ")
logger.debug("")
executable_targets = self.generate_data_specifications()
if do_timing:
timer.take_sample()
# execute data spec execution
if do_timing:
timer.start_timing()
processor_to_app_data_base_address = \
self.execute_data_specification_execution(
config.getboolean("SpecExecution", "specExecOnHost"),
self._hostname, self._placements, self._graph_mapper,
write_text_specs=config.getboolean(
"Reports", "writeTextSpecs"),
runtime_application_data_folder=self._app_data_runtime_folder,
machine=self._machine)
if self._reports_states is not None:
reports.write_memory_map_report(
self._report_default_directory,
processor_to_app_data_base_address)
if do_timing:
timer.take_sample()
if (not isinstance(self._machine, VirtualMachine)
and config.getboolean("Execute", "run_simulation")):
if do_timing:
timer.start_timing()
logger.info("*** Loading tags ***")
self.load_tags(self._tags)
if self._do_load is True:
logger.info("*** Loading data ***")
self._load_application_data(
self._placements,
self._graph_mapper,
processor_to_app_data_base_address,
self._hostname,
app_data_folder=self._app_data_runtime_folder,
verify=config.getboolean("Mode", "verify_writes"))
self.load_routing_tables(self._router_tables, self._app_id)
logger.info("*** Loading executables ***")
self.load_executable_images(executable_targets, self._app_id)
logger.info("*** Loading buffers ***")
self.set_up_send_buffering(self._partitioned_graph,
self._placements, self._tags)
# end of entire loading setup
if do_timing:
timer.take_sample()
if self._do_run is True:
logger.info("*** Running simulation... *** ")
if do_timing:
timer.start_timing()
# every thing is in sync0. load the initial buffers
self._send_buffer_manager.load_initial_buffers()
if do_timing:
timer.take_sample()
wait_on_confirmation = config.getboolean(
"Database", "wait_on_confirmation")
send_start_notification = config.getboolean(
"Database", "send_start_notification")
self.wait_for_cores_to_be_ready(executable_targets,
self._app_id)
# wait till external app is ready for us to start if required
if (self._database_interface is not None
and wait_on_confirmation):
self._database_interface.wait_for_confirmation()
self.start_all_cores(executable_targets, self._app_id)
if (self._database_interface is not None
and send_start_notification):
self._database_interface.send_start_notification()
if self._runtime is None:
logger.info("Application is set to run forever - exiting")
else:
self.wait_for_execution_to_complete(
executable_targets, self._app_id, self._runtime,
self._time_scale_factor)
self._has_ran = True
if self._retrieve_provance_data:
progress = ProgressBar(self._placements.n_placements + 1,
"getting provenance data")
# retrieve provence data from central
file_path = os.path.join(self._report_default_directory,
"provance_data")
# check the directory doesnt already exist
if not os.path.exists(file_path):
os.mkdir(file_path)
# write provanence data
self.write_provenance_data_in_xml(file_path, self._txrx)
progress.update()
# retrieve provenance data from any cores that provide data
for placement in self._placements.placements:
if isinstance(placement.subvertex,
AbstractProvidesProvenanceData):
core_file_path = os.path.join(
file_path,
"Provanence_data_for_{}_{}_{}_{}.xml".format(
placement.subvertex.label, placement.x,
placement.y, placement.p))
placement.subvertex.write_provenance_data_in_xml(
core_file_path, self.transceiver, placement)
progress.update()
progress.end()
elif isinstance(self._machine, VirtualMachine):
logger.info(
"*** Using a Virtual Machine so no simulation will occur")
else:
logger.info("*** No simulation requested: Stopping. ***")
