def _handle_internal_algorithm(self, algorithm):
""" Creates the input files for the algorithm
:param algorithm: the algorithm
:return: None
"""
# create algorithm
python_algorithm = self._create_python_object(algorithm)
# create input dictionary
inputs = self._create_input_commands(algorithm)
# set up timer
timer = None
if self._do_timing:
timer = Timer()
timer.start_timing()
# execute algorithm
try:
results = python_algorithm(**inputs)
except Exception as e:
exc_info = sys.exc_info()
if isinstance(e,
exceptions.PacmanAlgorithmFailedToCompleteException):
raise exc_info[0], exc_info[1], exc_info[2]
else:
raise exceptions.PacmanAlgorithmFailedToCompleteException(
algorithm, e, exc_info[2])
# handle_prov_data
if self._do_timing:
self._update_timings(timer, algorithm)
# move outputs into internal data objects
self._map_output_parameters(results, algorithm)
def get_synaptic_list_from_machine(self, graph_mapper, partitioned_graph,
placements, transceiver, routing_infos):
""" Get synaptic data for all connections in this Projection from the\
machine.
"""
if self._stored_synaptic_data_from_machine is None:
timer = None
if conf.config.getboolean("Reports", "display_algorithm_timings"):
timer = Timer()
timer.start_timing()
subedges = \
graph_mapper.get_partitioned_edges_from_partitionable_edge(
self)
if subedges is None:
subedges = list()
synaptic_list = copy.copy(self._synapse_list)
synaptic_list_rows = synaptic_list.get_rows()
progress_bar = ProgressBar(
len(subedges),
"Reading back synaptic matrix for edge between"
" {} and {}".format(self._pre_vertex.label,
self._post_vertex.label))
for subedge in subedges:
n_rows = subedge.get_n_rows(graph_mapper)
pre_vertex_slice = \
graph_mapper.get_subvertex_slice(subedge.pre_subvertex)
post_vertex_slice = \
graph_mapper.get_subvertex_slice(subedge.post_subvertex)
sub_edge_post_vertex = \
graph_mapper.get_vertex_from_subvertex(
subedge.post_subvertex)
rows = sub_edge_post_vertex.get_synaptic_list_from_machine(
placements, transceiver, subedge.pre_subvertex, n_rows,
subedge.post_subvertex,
self._synapse_row_io, partitioned_graph,
routing_infos, subedge.weight_scales).get_rows()
for i in range(len(rows)):
synaptic_list_rows[
i + pre_vertex_slice.lo_atom].set_slice_values(
rows[i], vertex_slice=post_vertex_slice)
progress_bar.update()
progress_bar.end()
self._stored_synaptic_data_from_machine = synaptic_list
if conf.config.getboolean("Reports", "display_algorithm_timings"):
logger.info("Time to read matrix: {}".format(
timer.take_sample()))
return self._stored_synaptic_data_from_machine
def _handle_external_algorithm(self, algorithm):
""" Creates the input files for the algorithm
:param algorithm: the algorithm
:return: None
"""
input_params = self._create_input_commands(algorithm)
inputs = \
[a.format(**input_params) for a in algorithm.command_line_args]
# output debug info in case things go wrong
logger.debug(
"The inputs to the external mapping function are {}".format(
inputs))
# create progress bar for external algorithm
algorithm_progress_bar = ProgressBar(
1, "Running external algorithm {}".format(algorithm.algorithm_id))
timer = None
if self._do_timing:
timer = Timer()
timer.start_timing()
# execute other command
child = subprocess.Popen(inputs,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
stdin=subprocess.PIPE)
child.wait()
algorithm_progress_bar.end()
if self._do_timing:
self._update_timings(timer, algorithm)
# check the return code for a successful execution
if child.returncode != 0:
stdout, stderr = child.communicate()
raise exceptions.\
PacmanExternalAlgorithmFailedToCompleteException(
"Algorithm {} returned a non-zero error code {}\n"
" Inputs: {}\n"
" Output: {}\n"
" Error: {}\n".format(
algorithm.algorithm_id, child.returncode,
inputs, stdout, stderr))
outputs = self._sort_out_external_algorithm_outputs(algorithm)
self._map_output_parameters(outputs, algorithm)
