def test_call(self):
executor = HostExecuteDataSpecification()
transceiver = _MockTransceiver(user_0_addresses={0: 1000})
machine = VirtualMachine(2, 2)
tempdir = tempfile.mkdtemp()
dsg_targets = DataSpecificationTargets(machine, tempdir)
with dsg_targets.create_data_spec(0, 0, 0) as spec_writer:
spec = DataSpecificationGenerator(spec_writer)
spec.reserve_memory_region(0, 100)
spec.reserve_memory_region(1, 100, empty=True)
spec.reserve_memory_region(2, 100)
spec.switch_write_focus(0)
spec.write_value(0)
spec.write_value(1)
spec.write_value(2)
spec.switch_write_focus(2)
spec.write_value(3)
spec.end_specification()
infos = executor.__call__(
transceiver, machine, 30, dsg_targets, tempdir)
# Test regions - although 3 are created, only 2 should be uploaded
# (0 and 2), and only the data written should be uploaded
# The space between regions should be as allocated regardless of
# how much data is written
header_and_table_size = (MAX_MEM_REGIONS + 2) * 4
regions = transceiver.regions_written
self.assertEqual(len(regions), 4)
# Base address for header and table
self.assertEqual(regions[0][0], 0)
# Base address for region 0 (after header and table)
self.assertEqual(regions[1][0], header_and_table_size)
# Base address for region 2
self.assertEqual(regions[2][0], header_and_table_size + 200)
# User 0 write address
self.assertEqual(regions[3][0], 1000)
# Size of header and table
self.assertEqual(len(regions[0][1]), header_and_table_size)
# Size of region 0
self.assertEqual(len(regions[1][1]), 12)
# Size of region 2
self.assertEqual(len(regions[2][1]), 4)
# Size of user 0
self.assertEqual(len(regions[3][1]), 4)
info = infos[(0, 0, 0)]
self.assertEqual(info["memory_used"], 372)
self.assertEqual(info["memory_written"], 88)
def test_call(self):
executor = HostExecuteDataSpecification()
transceiver = _MockTransceiver(user_0_addresses={0: 1000})
machine = VirtualMachine(2, 2)
# Write a data spec to execute
temp_spec = mktemp()
spec_writer = FileDataWriter(temp_spec)
spec = DataSpecificationGenerator(spec_writer)
spec.reserve_memory_region(0, 100)
spec.reserve_memory_region(1, 100, empty=True)
spec.reserve_memory_region(2, 100)
spec.switch_write_focus(0)
spec.write_value(0)
spec.write_value(1)
spec.write_value(2)
spec.switch_write_focus(2)
spec.write_value(3)
spec.end_specification()
# Execute the spec
dsg_targets = {(0, 0, 0): temp_spec}
executor.__call__(transceiver, machine, 30, dsg_targets)
# Test regions - although 3 are created, only 2 should be uploaded
# (0 and 2), and only the data written should be uploaded
# The space between regions should be as allocated regardless of
# how much data is written
header_and_table_size = (constants.MAX_MEM_REGIONS + 2) * 4
regions = transceiver.regions_written
self.assertEqual(len(regions), 4)
# Base address for header and table
self.assertEqual(regions[0][0], 0)
# Base address for region 0 (after header and table)
self.assertEqual(regions[1][0], header_and_table_size)
# Base address for region 2
self.assertEqual(regions[2][0], header_and_table_size + 200)
# User 0 write address
self.assertEqual(regions[3][0], 1000)
# Size of header and table
self.assertEqual(len(regions[0][1]), header_and_table_size)
# Size of region 0
self.assertEqual(len(regions[1][1]), 12)
# Size of region 2
self.assertEqual(len(regions[2][1]), 4)
# Size of user 0
self.assertEqual(len(regions[3][1]), 4)
def test_call(self):
executor = HostExecuteDataSpecification()
transceiver = _MockTransceiver(user_0_addresses={0: 1000})
machine = virtual_machine(2, 2)
tempdir = tempfile.mkdtemp()
dsg_targets = DataSpecificationTargets(machine, tempdir)
with dsg_targets.create_data_spec(0, 0, 0) as spec_writer:
spec = DataSpecificationGenerator(spec_writer)
spec.reserve_memory_region(0, 100)
spec.reserve_memory_region(1, 100, empty=True)
spec.reserve_memory_region(2, 100)
spec.switch_write_focus(0)
spec.write_value(0)
spec.write_value(1)
spec.write_value(2)
spec.switch_write_focus(2)
spec.write_value(3)
spec.end_specification()
region_sizes = dict()
region_sizes[0, 0,
0] = (APP_PTR_TABLE_BYTE_SIZE + sum(spec.region_sizes))
# Execute the spec
targets = ExecutableTargets()
targets.add_processor("text.aplx", 0, 0, 0,
ExecutableType.USES_SIMULATION_INTERFACE)
infos = executor.execute_application_data_specs(
transceiver,
machine,
30,
dsg_targets,
False,
targets,
report_folder=tempdir,
region_sizes=region_sizes)
# Test regions - although 3 are created, only 2 should be uploaded
# (0 and 2), and only the data written should be uploaded
# The space between regions should be as allocated regardless of
# how much data is written
header_and_table_size = (MAX_MEM_REGIONS + 2) * BYTES_PER_WORD
regions = transceiver.regions_written
self.assertEqual(len(regions), 4)
# Base address for header and table
self.assertEqual(regions[1][0], 0)
# Base address for region 0 (after header and table)
self.assertEqual(regions[2][0], header_and_table_size)
# Base address for region 2
self.assertEqual(regions[3][0], header_and_table_size + 200)
# User 0 write address
self.assertEqual(regions[0][0], 1000)
# Size of header and table
self.assertEqual(len(regions[1][1]), header_and_table_size)
# Size of region 0
self.assertEqual(len(regions[2][1]), 12)
# Size of region 2
self.assertEqual(len(regions[3][1]), 4)
# Size of user 0
self.assertEqual(len(regions[0][1]), 4)
info = infos[(0, 0, 0)]
self.assertEqual(info.memory_used, 372)
self.assertEqual(info.memory_written, 88)
def generate_data_spec(self, subvertex, placement, sub_graph, graph,
routing_info, hostname, graph_mapper,
report_folder, ip_tags, reverse_ip_tags,
write_text_specs, application_run_time_folder):
# Create new DataSpec for this processor:
data_writer, report_writer = \
self.get_data_spec_file_writers(
placement.x, placement.y, placement.p, hostname, report_folder,
write_text_specs, application_run_time_folder)
spec = DataSpecificationGenerator(data_writer, report_writer)
spec.comment("\n*** Spec for block of {} neurons ***\n"
.format(self.model_name))
spec.comment("\nReserving memory space for data regions:\n\n")
# Reserve memory regions:
spec.reserve_memory_region(
region=self._REVERSE_IPTAG_MULTICAST_REGIONS.SYSTEM.value,
size=constants.DATA_SPECABLE_BASIC_SETUP_INFO_N_WORDS * 4 + 8,
label='SYSTEM')
spec.reserve_memory_region(
region=self._REVERSE_IPTAG_MULTICAST_REGIONS.CONFIGURATION.value,
size=self._CONFIGURATION_REGION_SIZE, label='CONFIGURATION')
if self._buffer_space is not None and self._buffer_space > 0:
spec.reserve_memory_region(
region=self._REVERSE_IPTAG_MULTICAST_REGIONS.BUFFER.value,
size=self._buffer_space, label="BUFFER", empty=True)
# set up system region writes
self._write_basic_setup_info(
spec, self._REVERSE_IPTAG_MULTICAST_REGIONS.SYSTEM.value)
# TODO this can be removed once buffered out functionality is in place.
# As then live injection can be recorded
spec.write_value(data=0)
spec.write_value(data=0)
# set up configuration region writes
spec.switch_write_focus(
region=self._REVERSE_IPTAG_MULTICAST_REGIONS.CONFIGURATION.value)
if self._virtual_key is None:
subedge_routing_info = \
routing_info.get_subedge_information_from_subedge(
sub_graph.outgoing_subedges_from_subvertex(subvertex)[0])
key_and_mask = subedge_routing_info.keys_and_masks[0]
self._mask = key_and_mask.mask
self._virtual_key = key_and_mask.key
if self._prefix is None:
if self._prefix_type is None:
self._prefix_type = EIEIOPrefix.UPPER_HALF_WORD
self._prefix = self._generate_prefix(self._virtual_key,
self._prefix_type)
# add prefix boolean value
if self._prefix is None:
spec.write_value(data=0)
else:
spec.write_value(data=1)
# add prefix
if self._prefix is None:
spec.write_value(data=0)
else:
if self._prefix_type is EIEIOPrefix.LOWER_HALF_WORD:
spec.write_value(data=self._prefix)
else:
spec.write_value(data=self._prefix << 16)
# key left shift
spec.write_value(data=self._key_left_shift)
# add key check
if self._check_key:
spec.write_value(data=1)
else:
spec.write_value(data=0)
# add key and mask
spec.write_value(data=self._virtual_key)
spec.write_value(data=self._mask)
# Buffering control
spec.write_value(data=self._buffer_space)
spec.write_value(data=self._space_before_notification)
# Notification
if self._notify_buffer_space:
ip_tag = iter(ip_tags).next()
spec.write_value(data=ip_tag.tag)
else:
spec.write_value(data=0)
# close spec
spec.end_specification()
data_writer.close()
def generate_data_spec(
self, subvertex, placement, sub_graph, graph, routing_info,
hostname, graph_mapper, report_folder, ip_tags, reverse_ip_tags,
write_text_specs, application_run_time_folder):
"""
Model-specific construction of the data blocks necessary to build a
single external retina device.
:param subvertex:
:param placement:
:param sub_graph:
:param graph:
:param routing_info:
:param hostname:
:param graph_mapper:
:param report_folder:
:param ip_tags:
:param reverse_ip_tags:
:param write_text_specs:
:param application_run_time_folder:
:return:
"""
data_writer, report_writer = \
self.get_data_spec_file_writers(
placement.x, placement.y, placement.p, hostname, report_folder,
write_text_specs, application_run_time_folder)
spec = DataSpecificationGenerator(data_writer, report_writer)
# reserve region - add a word for the region size
n_command_bytes = self._get_n_command_bytes()
self._reserve_memory_regions(spec, n_command_bytes + 4)
# Write system region
spec.comment("\n*** Spec for multi cast source ***\n\n")
self._write_basic_setup_info(spec, self.SYSTEM_REGION)
# Go through the times and replace negative times with positive ones
new_times = set()
for time in self._times_with_commands:
if time < 0 and self._no_machine_time_steps is not None:
real_time = self._no_machine_time_steps + (time + 1)
if time in self._commands_with_payloads:
if real_time in self._commands_with_payloads:
self._commands_with_payloads[real_time].extend(
self._commands_with_payloads[time])
else:
self._commands_with_payloads[real_time] = \
self._commands_with_payloads[time]
del self._commands_with_payloads[time]
if time in self._commands_without_payloads:
if real_time in self._commands_without_payloads:
self._commands_without_payloads[real_time].extend(
self._commands_without_payloads[time])
else:
self._commands_without_payloads[real_time] = \
self._commands_without_payloads[time]
del self._commands_without_payloads[time]
new_times.add(real_time)
# if runtime is infinite, then theres no point storing end of
# simulation events, as they will never occur
elif time < 0 and self._no_machine_time_steps is None:
if time in self._commands_with_payloads:
del self._commands_with_payloads[time]
if time in self._commands_without_payloads:
del self._commands_without_payloads[time]
else:
new_times.add(time)
# write commands
spec.switch_write_focus(region=self.COMMANDS)
spec.write_value(n_command_bytes)
for time in sorted(new_times):
# Gather the different types of commands
with_payload = list()
if time in self._commands_with_payloads:
with_payload = self._commands_with_payloads[time]
without_payload = list()
if time in self._commands_without_payloads:
without_payload = self._commands_without_payloads[time]
spec.write_value(time)
spec.write_value(len(with_payload))
for command in with_payload:
spec.write_value(self._get_key(command, graph_mapper,
routing_info))
payload = command.get_payload(routing_info, sub_graph,
graph_mapper)
spec.write_value(payload)
spec.write_value(command.repeat << 16 |
command.delay_between_repeats)
spec.write_value(len(without_payload))
for command in without_payload:
spec.write_value(self._get_key(command, graph_mapper,
routing_info))
spec.write_value(command.repeat << 16 |
command.delay_between_repeats)
# End-of-Spec:
spec.end_specification()
data_writer.close()
def generate_data_spec(self, subvertex, placement, partitioned_graph,
graph, routing_info, hostname,
graph_subgraph_mapper, report_folder, ip_tags,
reverse_ip_tags, write_text_specs,
application_run_time_folder):
"""
Model-specific construction of the data blocks necessary to build a
single external retina device.
"""
# Create new DataSpec for this processor:
data_writer, report_writer = \
self.get_data_spec_file_writers(
placement.x, placement.y, placement.p, hostname, report_folder,
write_text_specs, application_run_time_folder)
spec = DataSpecificationGenerator(data_writer, report_writer)
# reserve regions
self.reserve_memory_regions(spec)
# Write the setup region
spec.comment("\n*** Spec for robot motor control ***\n\n")
self._write_basic_setup_info(spec, self.SYSTEM_REGION)
# locate correct subedge for key
edge_key = None
if len(graph.outgoing_edges_from_vertex(self)) != 1:
raise exceptions.SpynnakerException(
"This motor should only have one outgoing edge to the robot")
partitions = partitioned_graph.\
outgoing_edges_partitions_from_vertex(subvertex)
for partition in partitions.values():
edge_keys_and_masks = \
routing_info.get_keys_and_masks_from_partition(partition)
edge_key = edge_keys_and_masks[0].key
# write params to memory
spec.switch_write_focus(region=self.PARAMS_REGION)
spec.write_value(data=edge_key)
spec.write_value(data=self._speed)
spec.write_value(data=self._sample_time)
spec.write_value(data=self._update_time)
spec.write_value(data=self._delay_time)
spec.write_value(data=self._delta_threshold)
if self._continue_if_not_different:
spec.write_value(data=1)
else:
spec.write_value(data=0)
# End-of-Spec:
spec.end_specification()
data_writer.close()
return data_writer.filename
def generate_data_spec(
self, subvertex, placement, partitioned_graph, graph, routing_info,
hostname, graph_mapper, report_folder, ip_tags, reverse_ip_tags,
write_text_specs, application_run_time_folder):
"""
:param subvertex:
:param placement:
:param partitioned_graph:
:param graph:
:param routing_info:
:param hostname:
:param graph_mapper:
:param report_folder:
:param ip_tags:
:param reverse_ip_tags:
:param write_text_specs:
:param application_run_time_folder:
:return:
"""
data_writer, report_writer = \
self.get_data_spec_file_writers(
placement.x, placement.y, placement.p, hostname, report_folder,
write_text_specs, application_run_time_folder)
spec = DataSpecificationGenerator(data_writer, report_writer)
# reserve region - add a word for the region size
n_command_bytes = self._get_n_command_bytes()
self._reserve_memory_regions(spec, n_command_bytes + 4, subvertex)
# Write system region
spec.comment("\n*** Spec for multicast source ***\n\n")
self._write_basic_setup_info(
spec, CommandSenderPartitionedVertex.SYSTEM_REGION)
# Go through the times and replace negative times with positive ones
new_times = set()
for time in self._times_with_commands:
if time < 0 and self._no_machine_time_steps is not None:
real_time = self._no_machine_time_steps + (time + 1)
if time in self._commands_with_payloads:
if real_time in self._commands_with_payloads:
self._commands_with_payloads[real_time].extend(
self._commands_with_payloads[time])
else:
self._commands_with_payloads[real_time] = \
self._commands_with_payloads[time]
del self._commands_with_payloads[time]
if time in self._commands_without_payloads:
if real_time in self._commands_without_payloads:
self._commands_without_payloads[real_time].extend(
self._commands_without_payloads[time])
else:
self._commands_without_payloads[real_time] = \
self._commands_without_payloads[time]
del self._commands_without_payloads[time]
new_times.add(real_time)
# if runtime is infinite, then there's no point storing end of
# simulation events, as they will never occur
elif time < 0 and self._no_machine_time_steps is None:
if time in self._commands_with_payloads:
del self._commands_with_payloads[time]
if time in self._commands_without_payloads:
del self._commands_without_payloads[time]
else:
new_times.add(time)
# write commands
spec.switch_write_focus(region=CommandSenderPartitionedVertex.COMMANDS)
spec.write_value(n_command_bytes)
for time in sorted(new_times):
# Gather the different types of commands
with_payload = list()
if time in self._commands_with_payloads:
with_payload = self._commands_with_payloads[time]
without_payload = list()
if time in self._commands_without_payloads:
without_payload = self._commands_without_payloads[time]
spec.write_value(time)
spec.write_value(len(with_payload))
for command in with_payload:
spec.write_value(self._get_key(
command, graph_mapper, routing_info, partitioned_graph))
payload = command.get_payload(routing_info, partitioned_graph,
graph_mapper)
spec.write_value(payload)
spec.write_value(command.repeat << 16 |
command.delay_between_repeats)
spec.write_value(len(without_payload))
for command in without_payload:
spec.write_value(self._get_key(
command, graph_mapper, routing_info, partitioned_graph))
spec.write_value(command.repeat << 16 |
command.delay_between_repeats)
# End-of-Spec:
spec.end_specification()
data_writer.close()
return data_writer.filename
def generate_data_spec(self, subvertex, placement, subgraph, graph,
routing_info, hostname, graph_subgraph_mapper,
report_folder, ip_tags, reverse_ip_tags,
write_text_specs, application_run_time_folder):
"""
Model-specific construction of the data blocks necessary to build a
single external retina device.
"""
# Create new DataSpec for this processor:
data_writer, report_writer = \
self.get_data_spec_file_writers(
placement.x, placement.y, placement.p, hostname, report_folder,
write_text_specs, application_run_time_folder)
spec = DataSpecificationGenerator(data_writer, report_writer)
# reserve regions
self.reserve_memory_regions(spec)
# Write the setup region
spec.comment("\n*** Spec for robot motor control ***\n\n")
self._write_basic_setup_info(spec, self.SYSTEM_REGION)
# locate correct subedge for key
edge_key = None
if len(graph.outgoing_edges_from_vertex(self)) != 1:
raise exceptions.SpynnakerException(
"This motor should only have one outgoing edge to the robot")
for subedge in subgraph.outgoing_subedges_from_subvertex(subvertex):
edge_keys_and_masks = \
routing_info.get_keys_and_masks_from_subedge(subedge)
edge_key = edge_keys_and_masks[0].key
# write params to memory
spec.switch_write_focus(region=self.PARAMS_REGION)
spec.write_value(data=edge_key)
spec.write_value(data=self._speed)
spec.write_value(data=self._sample_time)
spec.write_value(data=self._update_time)
spec.write_value(data=self._delay_time)
spec.write_value(data=self._delta_threshold)
if self._continue_if_not_different:
spec.write_value(data=1)
else:
spec.write_value(data=0)
# End-of-Spec:
spec.end_specification()
data_writer.close()
return [data_writer.filename]