def generate_data_specification(self, spec, placement, data_n_steps):
# Generate the system data region for simulation .c requirements
# Note that the time step and time scale factor are unused here
generate_steps_system_data_region(spec, self.DATA_REGIONS.SYSTEM.value,
self)
# Create the data regions for hello world
spec.reserve_memory_region(region=self.DATA_REGIONS.PARAMS.value,
size=self.PARAMS_BASE_SIZE +
len(self._text))
spec.reserve_memory_region(
region=self.DATA_REGIONS.STRING_DATA.value,
size=recording_utilities.get_recording_header_size(1),
label="Recording")
# write data for the recording
spec.switch_write_focus(self.DATA_REGIONS.STRING_DATA.value)
spec.write_array(
recording_utilities.get_recording_header_array(
[data_n_steps * len(self._text)]))
# write the data
spec.switch_write_focus(self.DATA_REGIONS.PARAMS.value)
spec.write_value(len(self._text))
spec.write_array(
numpy.array(bytearray(self._text, "ascii")).view("uint32"))
# End-of-Spec:
spec.end_specification()
def _write_setup_info(
self, spec, machine_time_step, time_scale_factor,
n_machine_time_steps, ip_tags):
""" Writes the system data as required.
:param spec: the DSG spec writer
:param machine_time_step: the machine time step
:param time_scale_factor: the time scale factor
:rtype: None
"""
# pylint: disable=too-many-arguments
spec.switch_write_focus(
region=self.CHIP_POWER_MONITOR_REGIONS.SYSTEM.value)
spec.write_array(get_simulation_header_array(
self.get_binary_file_name(), machine_time_step, time_scale_factor))
spec.switch_write_focus(
region=self.CHIP_POWER_MONITOR_REGIONS.RECORDING.value)
recorded_region_sizes = recording_utilities.get_recorded_region_sizes(
[self._deduce_sdram_requirements_per_timer_tick(
machine_time_step, time_scale_factor) * n_machine_time_steps],
[self.MAX_BUFFER_SIZE])
spec.write_array(recording_utilities.get_recording_header_array(
recorded_region_sizes,
globals_variables.get_simulator().config.getint(
"Buffers", "time_between_requests"),
None, ip_tags))
def generate_machine_data_specification(self, spec, placement,
machine_graph, routing_info,
iptags, reverse_iptags,
machine_time_step,
time_scale_factor):
# Generate the system data region for simulation .c requirements
generate_system_data_region(spec, self.DATA_REGIONS.SYSTEM.value, self,
machine_time_step, time_scale_factor)
self.placement = placement
# Reserve SDRAM space for memory areas:
# Create the data regions for hello world
self._reserve_memory_regions(spec)
# write data for the simulation data item
spec.switch_write_focus(self.DATA_REGIONS.STRING_DATA.value)
spec.write_array(
recording_utilities.get_recording_header_array(
[self._string_data_size], self._time_between_requests,
self._string_data_size + 256, iptags))
# End-of-Spec:
spec.end_specification()
def generate_machine_data_specification(self, spec, placement,
machine_graph, routing_info,
iptags, reverse_iptags,
machine_time_step,
time_scale_factor):
self.placement = placement
# Setup words + 1 for flags + 1 for recording size
setup_size = constants.SYSTEM_BYTES_REQUIREMENT
# Reserve SDRAM space for memory areas:
# Create the data regions for hello world
self._reserve_memory_regions(spec, setup_size)
# write data for the simulation data item
spec.switch_write_focus(self.DATA_REGIONS.SYSTEM.value)
spec.write_array(
simulation_utilities.get_simulation_header_array(
self.get_binary_file_name(), machine_time_step,
time_scale_factor))
# recording data region
spec.switch_write_focus(self.DATA_REGIONS.STRING_DATA.value)
spec.write_array(
recording_utilities.get_recording_header_array(
[self._string_data_size], self._time_between_requests,
self._string_data_size + 256, iptags))
# End-of-Spec:
spec.end_specification()
def load_data_on_vertices(self, spec, iptags):
# recording data (output) region
spec.switch_write_focus(self.DATA_REGIONS.OUTPUT_DATA.value)
spec.write_array(
recording_utilities.get_recording_header_array(
[self._output_data_size], self._time_between_requests,
self._output_data_size, iptags))
# input data region
spec.switch_write_focus(self.DATA_REGIONS.INPUT_DATA.value)
#write header information - 16bytes of information
spec.write_array([
self.state, self.columns, self.rows, self.string_size,
self.num_string_cols, self.initiate, self.function_id
])
#write the string data entries
for i in range(0, self.num_string_cols):
for j in range(0, self.rows):
spec.write_array(
convert_string_to_integer_parcel(
self.entries[j][i], #-> entry converted to integers
self.string_size)
) #-> number of integers used for string
#write the integer data entries
for i in range(self.num_string_cols, self.columns):
for k in range(0, self.rows):
spec.write_value(
int(self.entries[k]
[i])) #-> those are 32-bit integers by default
def _write_setup_info(self, spec, machine_time_step, time_scale_factor,
n_machine_time_steps, vertex_slice, ip_tags):
""" writes the system data as required
:param spec: the dsg spec writer
:param machine_time_step: the machine time step
:param time_scale_factor: the time scale factor
:rtype: None
"""
spec.switch_write_focus(
region=(ChipPowerMonitorMachineVertex.CHIP_POWER_MONITOR_REGIONS.
SYSTEM.value))
spec.write_array(
simulation_utilities.get_simulation_header_array(
self.get_binary_file_name(), machine_time_step,
time_scale_factor))
spec.switch_write_focus(ChipPowerMonitorMachineVertex.
CHIP_POWER_MONITOR_REGIONS.RECORDING.value)
recorded_region_sizes = recording_utilities.get_recorded_region_sizes(
n_machine_time_steps, [
self._deduce_sdram_requirements_per_timer_tick(
machine_time_step, time_scale_factor)
], [self.MAX_BUFFER_SIZE])
spec.write_array(
recording_utilities.get_recording_header_array(
recorded_region_sizes,
globals_variables.get_simulator().config.getint(
"Buffers", "time_between_requests"), None, ip_tags))
def generate_data_specification(self, spec, placement, machine_time_step,
time_scale_factor, machine_graph,
routing_info, tags,
first_machine_time_step,
n_machine_time_steps):
self._update_virtual_key(routing_info, machine_graph)
self._fill_send_buffer(machine_time_step, first_machine_time_step,
n_machine_time_steps)
# Reserve regions
self._reserve_regions(spec)
# Write the system region
spec.switch_write_focus(self._REGIONS.SYSTEM.value)
spec.write_array(
get_simulation_header_array(self.get_binary_file_name(),
machine_time_step, time_scale_factor))
# Write the additional recording information
iptags = tags.get_ip_tags_for_vertex(self)
spec.switch_write_focus(self._REGIONS.RECORDING.value)
spec.write_array(
recording_utilities.get_recording_header_array(
[self._record_buffer_size], self._time_between_triggers,
self._buffer_size_before_receive, iptags,
self._buffer_notification_tag))
# Write the configuration information
self._write_configuration(spec, iptags)
# End spec
spec.end_specification()
def _write_setup_info(self, spec, machine_time_step, time_scale_factor,
n_machine_time_steps):
""" Writes the system data as required.
:param spec: the DSG spec writer
:param machine_time_step: the machine time step
:param time_scale_factor: the time scale factor
:rtype: None
"""
# pylint: disable=too-many-arguments
spec.switch_write_focus(
region=self.CHIP_POWER_MONITOR_REGIONS.SYSTEM.value)
spec.write_array(
get_simulation_header_array(self.get_binary_file_name(),
machine_time_step, time_scale_factor))
spec.switch_write_focus(
region=self.CHIP_POWER_MONITOR_REGIONS.RECORDING.value)
recorded_region_sizes = [
self._deduce_sdram_requirements_per_timer_tick(
machine_time_step, time_scale_factor) * n_machine_time_steps
]
spec.write_array(
recording_utilities.get_recording_header_array(
recorded_region_sizes))
def _write_setup_info(self, spec, machine_time_step, time_scale_factor,
n_machine_time_steps, ip_tags):
""" Writes the system data as required.
:param spec: the DSG spec writer
:param machine_time_step: the machine time step
:param time_scale_factor: the time scale factor
:rtype: None
"""
# pylint: disable=too-many-arguments
spec.switch_write_focus(
region=self.CHIP_POWER_MONITOR_REGIONS.SYSTEM.value)
spec.write_array(
get_simulation_header_array(self.get_binary_file_name(),
machine_time_step, time_scale_factor))
spec.switch_write_focus(
region=self.CHIP_POWER_MONITOR_REGIONS.RECORDING.value)
recorded_region_sizes = recording_utilities.get_recorded_region_sizes([
self._deduce_sdram_requirements_per_timer_tick(
machine_time_step, time_scale_factor) * n_machine_time_steps
], [self.MAX_BUFFER_SIZE])
spec.write_array(
recording_utilities.get_recording_header_array(
recorded_region_sizes,
globals_variables.get_simulator().config.getint(
"Buffers", "time_between_requests"), None, ip_tags))
def _write_common_data_spec(self, spec, rec_regions):
""" Write the data specification for the common regions
:param ~data_specification.DataSpecificationGenerator spec:
The data specification to write to
:param list(int) rec_regions:
A list of sizes of each recording region (including empty ones)
"""
# Write the setup region
spec.reserve_memory_region(region=self.__regions.system,
size=SIMULATION_N_BYTES,
label='System')
spec.switch_write_focus(self.__regions.system)
spec.write_array(get_simulation_header_array(self.__binary_file_name))
# Reserve memory for provenance
self.reserve_provenance_data_region(spec)
# Write profile data
reserve_profile_region(spec, self.__regions.profile,
self._app_vertex.n_profile_samples)
write_profile_region_data(spec, self.__regions.profile,
self._app_vertex.n_profile_samples)
# Set up for recording
spec.reserve_memory_region(region=self.__regions.recording,
size=get_recording_header_size(
len(rec_regions)),
label="Recording")
spec.switch_write_focus(self.__regions.recording)
spec.write_array(get_recording_header_array(rec_regions))
def generate_data_specification(self, spec, placement, machine_time_step,
time_scale_factor, graph_mapper,
routing_info, data_n_time_steps, graph):
# pylint: disable=too-many-arguments, arguments-differ
self._machine_time_step = machine_time_step
vertex = placement.vertex
vertex_slice = graph_mapper.get_slice(vertex)
spec.comment("\n*** Spec for SpikeSourcePoisson Instance ***\n\n")
# Reserve SDRAM space for memory areas:
self.reserve_memory_regions(spec, placement, graph_mapper)
# write setup data
spec.switch_write_focus(_REGIONS.SYSTEM_REGION.value)
spec.write_array(
simulation_utilities.get_simulation_header_array(
self.get_binary_file_name(), machine_time_step,
time_scale_factor))
# write recording data
spec.switch_write_focus(_REGIONS.SPIKE_HISTORY_REGION.value)
sdram = self.get_recording_sdram_usage(vertex_slice, machine_time_step)
recorded_region_sizes = [sdram.get_total_sdram(data_n_time_steps)]
spec.write_array(
recording_utilities.get_recording_header_array(
recorded_region_sizes))
# write parameters
self._write_poisson_parameters(spec, graph, placement, routing_info,
vertex_slice, machine_time_step,
time_scale_factor)
# End-of-Spec:
spec.end_specification()
def generate_data_specification(
self, spec, placement, # @UnusedVariable
machine_time_step, time_scale_factor, machine_graph, routing_info,
tags, first_machine_time_step, n_machine_time_steps):
# pylint: disable=too-many-arguments, arguments-differ
self._update_virtual_key(routing_info, machine_graph)
self._fill_send_buffer(
machine_time_step, first_machine_time_step, n_machine_time_steps)
# Reserve regions
self._reserve_regions(spec)
# Write the system region
spec.switch_write_focus(self._REGIONS.SYSTEM.value)
spec.write_array(get_simulation_header_array(
self.get_binary_file_name(), machine_time_step,
time_scale_factor))
# Write the additional recording information
iptags = tags.get_ip_tags_for_vertex(self)
spec.switch_write_focus(self._REGIONS.RECORDING.value)
spec.write_array(get_recording_header_array(
[self._record_buffer_size],
self._time_between_triggers, self._buffer_size_before_receive,
iptags, self._buffer_notification_tag))
# Write the configuration information
self._write_configuration(spec, iptags)
# End spec
spec.end_specification()
def generate_data_specification(
self, spec, placement, machine_time_step, time_scale_factor,
graph_mapper, routing_info, data_n_time_steps, graph):
# pylint: disable=too-many-arguments, arguments-differ
self._machine_time_step = machine_time_step
vertex = placement.vertex
vertex_slice = graph_mapper.get_slice(vertex)
spec.comment("\n*** Spec for SpikeSourcePoisson Instance ***\n\n")
# Reserve SDRAM space for memory areas:
self.reserve_memory_regions(spec, placement, graph_mapper)
# write setup data
spec.switch_write_focus(_REGIONS.SYSTEM_REGION.value)
spec.write_array(simulation_utilities.get_simulation_header_array(
self.get_binary_file_name(), machine_time_step,
time_scale_factor))
# write recording data
spec.switch_write_focus(_REGIONS.SPIKE_HISTORY_REGION.value)
sdram = self.get_recording_sdram_usage(
vertex_slice, machine_time_step)
recorded_region_sizes = [sdram.get_total_sdram(data_n_time_steps)]
spec.write_array(recording_utilities.get_recording_header_array(
recorded_region_sizes))
# write parameters
self._write_poisson_parameters(
spec, graph, placement, routing_info, vertex_slice,
machine_time_step, time_scale_factor)
# End-of-Spec:
spec.end_specification()
def generate_data_specification(self, spec, placement, machine_time_step,
time_scale_factor, graph_mapper,
application_graph, machine_graph,
routing_info, tags, n_machine_time_steps):
# pylint: disable=too-many-arguments, arguments-differ
vertex = placement.vertex
spec.comment("\n*** Spec for block of {} neurons ***\n".format(
self._model_name))
vertex_slice = graph_mapper.get_slice(vertex)
# Reserve memory regions
self._reserve_memory_regions(spec, vertex_slice, vertex)
# Declare random number generators and distributions:
# TODO add random distribution stuff
# self.write_random_distribution_declarations(spec)
# Get the key
key = routing_info.get_first_key_from_pre_vertex(
vertex, constants.SPIKE_PARTITION_ID)
# Write the setup region
spec.switch_write_focus(
constants.POPULATION_BASED_REGIONS.SYSTEM.value)
spec.write_array(
simulation_utilities.get_simulation_header_array(
self.get_binary_file_name(), machine_time_step,
time_scale_factor))
# Write the recording region
spec.switch_write_focus(
constants.POPULATION_BASED_REGIONS.RECORDING.value)
ip_tags = tags.get_ip_tags_for_vertex(vertex)
recorded_region_sizes = recording_utilities.get_recorded_region_sizes(
self._get_buffered_sdram(vertex_slice, n_machine_time_steps),
self._maximum_sdram_for_buffering)
spec.write_array(
recording_utilities.get_recording_header_array(
recorded_region_sizes, self._time_between_requests,
self._buffer_size_before_receive, ip_tags))
# Write the neuron parameters
self._write_neuron_parameters(spec, key, vertex_slice,
machine_time_step, time_scale_factor)
# write profile data
profile_utils.write_profile_region_data(
spec, constants.POPULATION_BASED_REGIONS.PROFILING.value,
self._n_profile_samples)
# allow the synaptic matrix to write its data spec-able data
self._synapse_manager.write_data_spec(spec, self, vertex_slice, vertex,
placement, machine_graph,
application_graph, routing_info,
graph_mapper, self._input_type,
machine_time_step)
# End the writing of this specification:
spec.end_specification()
def generate_data_specification(self, spec, placement, machine_time_step,
time_scale_factor, routing_info,
data_n_time_steps, graph,
first_machine_time_step):
"""
:param int machine_time_step:
:param int time_scale_factor:
:param ~pacman.model.routing_info.RoutingInfo routing_info:
:param int data_n_time_steps:
:param ~pacman.model.graphs.machine.MachineGraph graph:
:param int first_machine_time_step:
"""
# pylint: disable=too-many-arguments, arguments-differ
self.__machine_time_step = machine_time_step
vertex_slice = placement.vertex.vertex_slice
spec.comment("\n*** Spec for SpikeSourcePoisson Instance ***\n\n")
# Reserve SDRAM space for memory areas:
self.reserve_memory_regions(spec, placement)
# write setup data
spec.switch_write_focus(_REGIONS.SYSTEM_REGION.value)
spec.write_array(
simulation_utilities.get_simulation_header_array(
placement.vertex.get_binary_file_name(), machine_time_step,
time_scale_factor))
# write recording data
spec.switch_write_focus(_REGIONS.SPIKE_HISTORY_REGION.value)
sdram = self.get_recording_sdram_usage(vertex_slice, machine_time_step)
recorded_region_sizes = [sdram.get_total_sdram(data_n_time_steps)]
spec.write_array(
recording_utilities.get_recording_header_array(
recorded_region_sizes))
# write parameters
self._write_poisson_parameters(spec, graph, placement, routing_info,
vertex_slice, machine_time_step)
# write rates
self._write_poisson_rates(spec, vertex_slice, machine_time_step,
first_machine_time_step)
# write profile data
profile_utils.write_profile_region_data(spec,
_REGIONS.PROFILER_REGION.value,
self.__n_profile_samples)
# write tdma params
spec.switch_write_focus(_REGIONS.TDMA_REGION.value)
spec.write_array(
self.generate_tdma_data_specification_data(
self.vertex_slices.index(vertex_slice)))
# End-of-Spec:
spec.end_specification()
def generate_data_specification(
self, spec, placement, machine_time_step, time_scale_factor,
graph_mapper, application_graph, machine_graph, routing_info,
data_n_time_steps, placements):
# pylint: disable=too-many-arguments, arguments-differ
vertex = placement.vertex
spec.comment("\n*** Spec for block of {} neurons ***\n".format(
self._neuron_impl.model_name))
vertex_slice = graph_mapper.get_slice(vertex)
# Reserve memory regions
self._reserve_memory_regions(spec, vertex_slice, vertex)
# Declare random number generators and distributions:
# TODO add random distribution stuff
# self.write_random_distribution_declarations(spec)
# Get the key
key = routing_info.get_first_key_from_pre_vertex(
vertex, constants.SPIKE_PARTITION_ID)
# Write the setup region
spec.switch_write_focus(
constants.POPULATION_BASED_REGIONS.SYSTEM.value)
spec.write_array(simulation_utilities.get_simulation_header_array(
self.get_binary_file_name(), machine_time_step,
time_scale_factor))
# Write the recording region
spec.switch_write_focus(
constants.POPULATION_BASED_REGIONS.RECORDING.value)
spec.write_array(recording_utilities.get_recording_header_array(
self._get_buffered_sdram(vertex_slice, data_n_time_steps)))
# Write the neuron parameters
self._write_neuron_parameters(
spec, key, vertex_slice, machine_time_step, time_scale_factor)
# write profile data
profile_utils.write_profile_region_data(
spec, constants.POPULATION_BASED_REGIONS.PROFILING.value,
self._n_profile_samples)
# Get the weight_scale value from the appropriate location
weight_scale = self._neuron_impl.get_global_weight_scale()
# allow the synaptic matrix to write its data spec-able data
self._synapse_manager.write_data_spec(
spec, self, vertex_slice, vertex, placement, machine_graph,
application_graph, routing_info, graph_mapper,
weight_scale, machine_time_step, placements)
# End the writing of this specification:
spec.end_specification()
def generate_data_specification(self, spec, placement, routing_info, tags,
placements):
self._placement.append(placement)
# Reserve and write the parameters region
region_size = self._N_PARAMETER_BYTES + self._data_size
spec.reserve_memory_region(0, region_size)
spec.switch_write_focus(0)
# Write the data size in words
spec.write_value(len(self._data) *
(float(self._DATA_ELEMENT_TYPE.size) / 4.0),
data_type=self._DATA_COUNT_TYPE)
# Write the DRNLCoreID
spec.write_value(0, data_type=self._COREID_TYPE)
# Write the CoreID
spec.write_value(placement.p, data_type=self._COREID_TYPE)
#Write the DRNLAppID
spec.write_value(0, data_type=self._COREID_TYPE)
# Write the Acknowledge key
spec.write_value(0)
#Write the spike resample factor
spec.write_value(self._resample_factor, data_type=self._COREID_TYPE)
#Write the sampling frequency
spec.write_value(self._fs, data_type=self._COREID_TYPE)
# Write the data - Arrays must be 32-bit values, so convert
data = numpy.array(self._data, dtype=self._NUMPY_DATA_ELEMENT_TYPE)
spec.write_array(data.view(numpy.uint32))
# Reserve and write the recording regions
spec.reserve_memory_region(
1, recording_utilities.get_recording_header_size(1))
spec.switch_write_focus(1)
ip_tags = tags.get_ip_tags_for_vertex(self) or []
spec.write_array(
recording_utilities.get_recording_header_array(
[self._recording_size], ip_tags=ip_tags))
# print "IHCAN DRNL placement=",DRNL_placement
#print "IHCAN placement=",placement.p
# End the specification
spec.end_specification()
def generate_data_specification(self, spec, placement, machine_time_step,
time_scale_factor, graph_mapper,
routing_info, tags, n_machine_time_steps):
vertex = placement.vertex
vertex_slice = graph_mapper.get_slice(vertex)
spec.comment("\n*** Spec for Bandit Instance ***\n\n")
spec.comment("\nReserving memory space for data regions:\n\n")
# Reserve memory:
spec.reserve_memory_region(
region=BanditMachineVertex._BANDIT_REGIONS.SYSTEM.value,
size=front_end_common_constants.SYSTEM_BYTES_REQUIREMENT,
label='setup')
spec.reserve_memory_region(
region=BanditMachineVertex._BANDIT_REGIONS.BANDIT.value,
size=self.BANDIT_REGION_BYTES,
label='BanditParams')
# vertex.reserve_provenance_data_region(spec)
# reserve recording region
spec.reserve_memory_region(
BanditMachineVertex._BANDIT_REGIONS.RECORDING.value,
recording_utilities.get_recording_header_size(1))
# Write setup region
spec.comment("\nWriting setup region:\n")
spec.switch_write_focus(
BanditMachineVertex._BANDIT_REGIONS.SYSTEM.value)
spec.write_array(
simulation_utilities.get_simulation_header_array(
self.get_binary_file_name(), machine_time_step,
time_scale_factor))
# Write bandit region containing routing key to transmit with
spec.comment("\nWriting bandit region:\n")
spec.switch_write_focus(
BanditMachineVertex._BANDIT_REGIONS.BANDIT.value)
spec.write_value(
routing_info.get_first_key_from_pre_vertex(
vertex, constants.SPIKE_PARTITION_ID))
# Write recording region for score
spec.comment("\nWriting bandit recording region:\n")
spec.switch_write_focus(
BanditMachineVertex._BANDIT_REGIONS.RECORDING.value)
ip_tags = tags.get_ip_tags_for_vertex(self) or []
spec.write_array(
recording_utilities.get_recording_header_array(
[self._recording_size], ip_tags=ip_tags))
# End-of-Spec:
spec.end_specification()
def _write_app_memory_regions(self, spec, routing_info, iptags):
# Get the key, assuming all outgoing edges use the same key
key = routing_info.get_first_key_from_pre_vertex(self, PARTITION_ID)
# Write the transmission region
spec.switch_write_focus(self.DATA_REGIONS.TRANSMISSION.value)
spec.write_value(int(key is not None))
spec.write_value(0 if key is None else key)
# write recording data interface
spec.switch_write_focus(self.DATA_REGIONS.RECORDED_DATA.value)
spec.write_array(
recording_utilities.get_recording_header_array(
[self._recording_size]))
def generate_data_specification(
self,
spec,
placement, # @UnusedVariable
machine_time_step,
time_scale_factor,
machine_graph,
routing_info,
first_machine_time_step,
data_n_time_steps,
run_until_timesteps):
"""
:param int machine_time_step:
:param int time_scale_factor:
:param ~pacman.model.graphs.machine.MachineGraph machine_graph:
:param ~pacman.model.routing_info.RoutingInfo routing_info:
:param int first_machine_time_step:
:param int data_n_time_steps:
:param int run_until_timesteps:
"""
# pylint: disable=too-many-arguments, arguments-differ
self._update_virtual_key(routing_info, machine_graph)
self._fill_send_buffer(first_machine_time_step, run_until_timesteps)
# Reserve regions
self._reserve_regions(spec, data_n_time_steps)
# Write the system region
spec.switch_write_focus(self._REGIONS.SYSTEM)
spec.write_array(
get_simulation_header_array(self.get_binary_file_name(),
machine_time_step, time_scale_factor))
# Write the additional recording information
spec.switch_write_focus(self._REGIONS.RECORDING)
recording_size = 0
if self._is_recording:
per_timestep = self._recording_sdram_per_timestep(
machine_time_step, self._is_recording, self._receive_rate,
self._send_buffer_times, self._n_keys)
recording_size = per_timestep * data_n_time_steps
spec.write_array(get_recording_header_array([recording_size]))
# Write the configuration information
self._write_configuration(spec, machine_time_step, time_scale_factor)
# End spec
spec.end_specification()
def generate_machine_data_specification(self, spec, placement,
machine_graph, routing_info,
iptags, reverse_iptags,
machine_time_step,
time_scale_factor):
""" Generate data
:param placement: the placement object for the dsg
:param machine_graph: the graph object for this dsg
:param routing_info: the routing info object for this dsg
:param iptags: the collection of iptags generated by the tag allocator
:param reverse_iptags: the collection of reverse iptags generated by\
the tag allocator
"""
self.placement = placement
# Create the data regions
self._reserve_memory_regions(spec)
# write simulation interface data
spec.switch_write_focus(self.DATA_REGIONS.SYSTEM.value)
spec.write_array(
simulation_utilities.get_simulation_header_array(
self.get_binary_file_name(), machine_time_step,
time_scale_factor))
# write recording data interface
spec.switch_write_focus(self.DATA_REGIONS.RECORDED_DATA.value)
spec.write_array(
recording_utilities.get_recording_header_array(
[self._recording_size], self._time_between_requests,
self._buffer_size_before_receive, iptags))
# Get the key, assuming all outgoing edges use the same key
has_key = 0
key = routing_info.get_first_key_from_pre_vertex(self, PARTITION_ID)
if key is None:
key = 0
else:
has_key = 1
# Write the transmission region
spec.switch_write_focus(self.DATA_REGIONS.TRANSMISSION.value)
spec.write_value(has_key)
spec.write_value(key)
# End-of-Spec:
spec.end_specification()
def generate_data_specification(self, spec, placement, machine_time_step,
time_scale_factor, graph_mapper,
routing_info, tags, n_machine_time_steps):
self._machine_time_step = machine_time_step
vertex = placement.vertex
vertex_slice = graph_mapper.get_slice(vertex)
spec.comment("\n*** Spec for SpikeSourcePoisson Instance ***\n\n")
# Reserve SDRAM space for memory areas:
self.reserve_memory_regions(spec, placement, graph_mapper)
# write setup data
spec.switch_write_focus(
SpikeSourcePoissonMachineVertex.POISSON_SPIKE_SOURCE_REGIONS.
SYSTEM_REGION.value)
spec.write_array(
simulation_utilities.get_simulation_header_array(
self.get_binary_file_name(), machine_time_step,
time_scale_factor))
# write recording data
ip_tags = tags.get_ip_tags_for_vertex(vertex)
spec.switch_write_focus(
SpikeSourcePoissonMachineVertex.POISSON_SPIKE_SOURCE_REGIONS.
SPIKE_HISTORY_REGION.value)
recorded_region_sizes = recording_utilities.get_recorded_region_sizes(
n_machine_time_steps, [
self._spike_recorder.get_sdram_usage_in_bytes(
vertex_slice.n_atoms,
self._max_spikes_per_ts(vertex_slice, n_machine_time_steps,
machine_time_step), 1)
], self._maximum_sdram_for_buffering)
spec.write_array(
recording_utilities.get_recording_header_array(
recorded_region_sizes, self._time_between_requests,
self._buffer_size_before_receive, ip_tags))
# write parameters
key = routing_info.get_first_key_from_pre_vertex(
vertex, constants.SPIKE_PARTITION_ID)
self._write_poisson_parameters(spec, key, vertex_slice,
machine_time_step, time_scale_factor)
# End-of-Spec:
spec.end_specification()
def generate_machine_data_specification(
self, spec, placement, machine_graph, routing_info, iptags,
reverse_iptags, machine_time_step, time_scale_factor,
n_machine_time_steps, machine_time_step_in_seconds, graph_mapper,
nengo_graph):
print "sink at {}".format(placement)
# reserve the memory region blocks
self._reserve_memory_regions(spec)
# fill in system region
spec.switch_write_focus(self.DATA_REGIONS.SYSTEM.value)
spec.write_array(simulation_utilities.get_simulation_header_array(
self.get_binary_file_name(), machine_time_step,
time_scale_factor))
# fill in recording region
spec.switch_write_focus(self.DATA_REGIONS.RECORDING.value)
recorded_region_sizes = recording_utilities.get_recorded_region_sizes(
self._get_buffered_sdram(self._input_slice, n_machine_time_steps),
[self._maximum_sdram_for_buffering])
spec.write_array(recording_utilities.get_recording_header_array(
recorded_region_sizes, self._time_between_requests,
self._buffer_size_before_receive, iptags))
# data on slice, aka, input slice size and start point
spec.switch_write_focus(self.DATA_REGIONS.SLICE_DATA.value)
spec.write_value(self._input_slice.n_atoms)
spec.write_array(self._input_slice.lo_atom)
# add filer region
spec.switch_write_focus(self.DATA_REGIONS.FILTERS.value)
filter_to_index_map = filter_region_writer.write_filter_region(
spec, machine_time_step_in_seconds, self._input_slice,
self._input_filters)
# add routing region
spec.switch_write_focus(self.DATA_REGIONS.FILTER_ROUTING.value)
helpful_functions.write_routing_region(
spec, routing_info, machine_graph.get_edges_ending_at_vertex(self),
filter_to_index_map, self._input_filters, graph_mapper, nengo_graph)
spec.end_specification()
def generate_recording_region(self, spec, region_id, channel_sizes):
"""
Generate the recording region for the data specification.
:param ~data_specification.DataSpecificationGenerator spec:
The data specification being built
:param int region_id:
Which region is the recording region.
:param list(int) sizes:
The sizes of each of the recording channels.
The length of the list is the number of recording channels.
"""
spec.reserve_memory_region(
region=region_id,
size=recording_utilities.get_recording_header_size(
len(channel_sizes)),
label="Recording")
spec.switch_write_focus(region_id)
spec.write_array(
recording_utilities.get_recording_header_array(channel_sizes))
def _write_recording_region(
self, spec, ip_tags, n_machine_time_steps, app_vertex,
time_between_requests, buffer_size_before_receive):
"""
:param spec:
:param ip_tags:
:param n_machine_time_steps:
:param app_vertex:
:param time_between_requests:
:param buffer_size_before_receive:
:return:
"""
recorded_region_sizes = recording_utilities.get_recorded_region_sizes(
app_vertex.get_buffered_sdram(
self._neuron_slice, n_machine_time_steps),
app_vertex.maximum_sdram_for_buffering)
spec.write_array(recording_utilities.get_recording_header_array(
recorded_region_sizes, time_between_requests,
buffer_size_before_receive, ip_tags))
def _write_setup_info(
self, spec, machine_time_step, time_scale_factor,
n_machine_time_steps):
""" Writes the system data as required.
:param ~data_specification.DataSpecificationGenerator spec:
the DSG spec writer
:param int machine_time_step: the machine time step
:param int time_scale_factor: the time scale factor
"""
# pylint: disable=too-many-arguments
spec.switch_write_focus(region=self._REGIONS.SYSTEM)
spec.write_array(get_simulation_header_array(
self.get_binary_file_name(), machine_time_step, time_scale_factor))
spec.switch_write_focus(region=self._REGIONS.RECORDING)
recorded_region_sizes = [
self._deduce_sdram_requirements_per_timer_tick(
machine_time_step, time_scale_factor) * n_machine_time_steps]
spec.write_array(recording_utilities.get_recording_header_array(
recorded_region_sizes))
def write_neuron_recording_region(
self, spec, neuron_recording_region, vertex_slice,
data_n_time_steps):
""" recording data specification
:param spec: dsg spec
:param neuron_recording_region: the recording region
:param vertex_slice: the vertex slice
:param data_n_time_steps: how many time steps to run this time
:rtype: None
"""
spec.switch_write_focus(neuron_recording_region)
spec.write_array(recording_utilities.get_recording_header_array(
self._get_buffered_sdram(vertex_slice, data_n_time_steps)))
# Write the number of variables and bitfields
n_vars = len(self.__sampling_rates) - len(self.__bitfield_variables)
spec.write_value(data=n_vars)
spec.write_value(data=len(self.__bitfield_variables))
# Write the recording data
recording_data = self._get_data(vertex_slice)
spec.write_array(recording_data)
def write_neuron_recording_region(self, spec, neuron_recording_region,
vertex_slice, data_n_time_steps):
""" recording data specification
:param ~data_specification.DataSpecificationGenerator spec: dsg spec
:param int neuron_recording_region: the recording region
:param ~pacman.model.graphs.commmon.Slice vertex_slice:
the vertex slice
:param int data_n_time_steps: how many time steps to run this time
:rtype: None
"""
spec.switch_write_focus(neuron_recording_region)
spec.write_array(
get_recording_header_array(
self._get_buffered_sdram(vertex_slice, data_n_time_steps)))
# Write the number of variables and bitfields
n_vars = len(self.__sampling_rates) - len(self.__bitfield_variables)
spec.write_value(data=n_vars)
spec.write_value(data=len(self.__bitfield_variables))
# Write the recording data
recording_data = self._get_data(vertex_slice)
spec.write_array(recording_data)
def generate_machine_data_specification(self, spec, placement,
machine_graph, routing_info,
iptags, reverse_iptags,
machine_time_step,
time_scale_factor):
# HAS_KEY = 0, P2P_KEY = 1, FILTER_UPDATE_KEY = 2, OUTPUT_KEY = 3
# X_COORD = 0, Y_COORD = 1, RADIUS = 2, P2P_ID = 3, IS_MAIN = 4, N_PARTICLES = 5
self._placement = placement
# Setup words + 1 for flags + 1 for recording size
setup_size = constants.SYSTEM_BYTES_REQUIREMENT
# Create the data regions for hello world
self._reserve_memory_regions(spec, setup_size)
# write data for the simulation data item
spec.switch_write_focus(self.DATA_REGIONS.SYSTEM.value)
spec.write_array(
simulation_utilities.get_simulation_header_array(
self.get_binary_file_name(), machine_time_step,
time_scale_factor))
# write transmission key
spec.switch_write_focus(self.DATA_REGIONS.TRANSMISSION_DATA.value)
routing_key = routing_info.get_first_key_from_pre_vertex(
self, app_constants.EDGE_PARTITION_PARTICLE_TO_PARTICLE)
if routing_key is None:
raise Exception("Error: the routing key is none!")
else:
#HAS_KEY
spec.write_value(1)
#P2P_KEY
spec.write_value(
routing_info.get_first_key_from_pre_vertex(
self, app_constants.EDGE_PARTITION_PARTICLE_TO_PARTICLE))
if self._main:
#FILTER_UPDATE_KEY
spec.write_value(
routing_info.get_first_key_from_pre_vertex(
self, app_constants.EDGE_PARTITION_MAIN_TO_FILTER))
#OUTPUT_KEY
spec.write_value(
routing_info.get_first_key_from_pre_vertex(
self, app_constants.EDGE_PARTITION_TARGET_POSITION))
else:
spec.write_value(0)
spec.write_value(0)
# write config params
spec.switch_write_focus(self.DATA_REGIONS.CONFIG.value)
spec.write_value(self._x)
spec.write_value(self._y)
spec.write_value(self._r)
spec.write_value(self._part_id)
if self._main:
spec.write_value(1)
else:
spec.write_value(0)
spec.write_value(self._n_particles)
spec.write_value(self._batch_size)
#initialise recording region
spec.switch_write_focus(self.DATA_REGIONS.RECORDING.value)
spec.write_array(
recording_utilities.get_recording_header_array(
[app_constants.MACHINE_STEPS * self.RECORD_BYTES_PER_STEP]))
# End-of-Spec:
spec.end_specification()
def generate_machine_data_specification(self, spec, placement,
machine_graph, routing_info,
iptags, reverse_iptags,
machine_time_step,
time_scale_factor,
data_n_time_steps):
# reserve memory regions
spec.reserve_memory_region(region=DataRegions.SYSTEM,
size=SIMULATION_N_BYTES,
label='systemInfo')
# simulation .c requirements
spec.switch_write_focus(DataRegions.SYSTEM)
spec.write_array(
simulation_utilities.get_simulation_header_array(
self.get_binary_file_name(), machine_time_step,
time_scale_factor))
# TODO use get_sdram_edge_partitions_starting_at_vertex
# get counters
outgoing_partitions = list(
machine_graph.get_sdram_edge_partitions_starting_at_vertex(self))
n_out_sdrams = len(outgoing_partitions)
incoming_partitions = list(
machine_graph.get_sdram_edge_partitions_ending_at_vertex(self))
n_in_sdrams = len(incoming_partitions)
# reserve memory regions
spec.reserve_memory_region(
region=DataRegions.SDRAM_OUT,
size=((n_out_sdrams * self.SDRAM_PARTITION_BASE_DSG_SIZE) +
self.SDRAM_PARTITION_COUNTERS),
label="sdrams_out")
spec.reserve_memory_region(
region=DataRegions.SDRAM_IN,
size=((n_in_sdrams * self.SDRAM_PARTITION_BASE_DSG_SIZE) +
self.SDRAM_PARTITION_COUNTERS),
label="sdrams_in")
# add outs
spec.switch_write_focus(DataRegions.SDRAM_OUT)
spec.write_value(n_out_sdrams)
for outgoing_partition in outgoing_partitions:
spec.write_value(
outgoing_partition.get_sdram_base_address_for(self))
spec.write_value(
outgoing_partition.get_sdram_size_of_region_for(self))
# add ins
spec.switch_write_focus(DataRegions.SDRAM_IN)
spec.write_value(n_in_sdrams)
for incoming_partition in incoming_partitions:
if isinstance(incoming_partition, AbstractSDRAMPartition):
spec.write_value(
incoming_partition.get_sdram_base_address_for(self))
spec.write_value(
incoming_partition.get_sdram_size_of_region_for(self))
spec.reserve_memory_region(
region=DataRegions.RESULTS,
size=recording_utilities.get_recording_header_size(len(Channels)))
# get recorded buffered regions sorted
spec.switch_write_focus(DataRegions.RESULTS)
spec.write_array(
recording_utilities.get_recording_header_array(
[self.RECORDING_ELEMENT_SIZE * data_n_time_steps]))
spec.end_specification()
def generate_data_specification(self, spec, placement, routing_info):
vertex = placement.vertex
spec.comment("\n*** Spec for Logic Instance ***\n\n")
spec.comment("\nReserving memory space for data regions:\n\n")
# Reserve memory:
spec.reserve_memory_region(
region=self._LOGIC_REGIONS.SYSTEM.value,
size=front_end_common_constants.SYSTEM_BYTES_REQUIREMENT,
label='setup')
spec.reserve_memory_region(region=self._LOGIC_REGIONS.LOGIC.value,
size=self.LOGIC_REGION_BYTES,
label='LogicParams')
# reserve recording region
spec.reserve_memory_region(
self._LOGIC_REGIONS.RECORDING.value,
recording_utilities.get_recording_header_size(1))
spec.reserve_memory_region(region=self._LOGIC_REGIONS.DATA.value,
size=self.BASE_DATA_REGION_BYTES +
(self._no_inputs * 4) +
(len(self._truth_table) * 4),
label='LogicArms')
# Write setup region
spec.comment("\nWriting setup region:\n")
spec.switch_write_focus(self._LOGIC_REGIONS.SYSTEM.value)
spec.write_array(
simulation_utilities.get_simulation_header_array(
vertex.get_binary_file_name()))
# Write logic region containing routing key to transmit with
spec.comment("\nWriting logic region:\n")
spec.switch_write_focus(self._LOGIC_REGIONS.LOGIC.value)
spec.write_value(
routing_info.get_first_key_from_pre_vertex(
vertex, constants.SPIKE_PARTITION_ID))
# Write recording region for score
spec.comment("\nWriting logic recording region:\n")
spec.switch_write_focus(self._LOGIC_REGIONS.RECORDING.value)
spec.write_array(
recording_utilities.get_recording_header_array(
[self._recording_size]))
# Write logic data
spec.comment("\nWriting logic data region:\n")
spec.switch_write_focus(self._LOGIC_REGIONS.DATA.value)
spec.write_value(self._score_delay, data_type=DataType.UINT32)
spec.write_value(self._no_inputs, data_type=DataType.UINT32)
spec.write_value(self._rand_seed[0], data_type=DataType.UINT32)
spec.write_value(self._rand_seed[1], data_type=DataType.UINT32)
spec.write_value(self._rand_seed[2], data_type=DataType.UINT32)
spec.write_value(self._rand_seed[3], data_type=DataType.UINT32)
spec.write_value(self._rate_on, data_type=DataType.UINT32)
spec.write_value(self._rate_off, data_type=DataType.UINT32)
spec.write_value(self._stochastic, data_type=DataType.UINT32)
# Write the data - Arrays must be 32-bit values, so convert
data = numpy.array(self._input_sequence, dtype=numpy.uint32)
spec.write_array(data.view(numpy.uint32))
data = numpy.array(self._truth_table, dtype=numpy.uint32)
spec.write_array(data.view(numpy.uint32))
# End-of-Spec:
spec.end_specification()
def generate_machine_data_specification(self, spec, placement,
machine_graph, routing_info,
iptags, reverse_iptags,
machine_time_step,
time_scale_factor):
# Generate the system data region for simulation .c requirements
generate_system_data_region(spec, self.DATA_REGIONS.SYSTEM.value, self,
machine_time_step, time_scale_factor)
# reserve memory regions
spec.reserve_memory_region(
region=self.DATA_REGIONS.TRANSMISSIONS.value,
size=self.TRANSMISSION_DATA_SIZE,
label="inputs")
spec.reserve_memory_region(region=self.DATA_REGIONS.STATE.value,
size=self.STATE_DATA_SIZE,
label="state")
spec.reserve_memory_region(
region=self.DATA_REGIONS.NEIGHBOUR_INITIAL_STATES.value,
size=8,
label="neighour_states")
spec.reserve_memory_region(
region=self.DATA_REGIONS.RESULTS.value,
size=recording_utilities.get_recording_header_size(1))
# get recorded buffered regions sorted
spec.switch_write_focus(self.DATA_REGIONS.RESULTS.value)
spec.write_array(
recording_utilities.get_recording_header_array(
[MAX_SIZE_OF_BUFFERED_REGION_ON_CHIP],
self._time_between_requests, self._buffer_size_before_receive,
iptags))
# check got right number of keys and edges going into me
partitions = \
machine_graph.get_outgoing_edge_partitions_starting_at_vertex(self)
if not is_single(partitions):
raise ConfigurationException(
"Can only handle one type of partition.")
# check for duplicates
edges = list(machine_graph.get_edges_ending_at_vertex(self))
if len(edges) != 8:
raise ConfigurationException(
"I've not got the right number of connections. I have {} "
"instead of 8".format(
len(machine_graph.incoming_subedges_from_vertex(self))))
for edge in edges:
if edge.pre_vertex == self:
raise ConfigurationException(
"I'm connected to myself, this is deemed an error"
" please fix.")
# write key needed to transmit with
key = routing_info.get_first_key_from_pre_vertex(
self, self.PARTITION_ID)
spec.switch_write_focus(region=self.DATA_REGIONS.TRANSMISSIONS.value)
spec.write_value(0 if key is None else 1)
spec.write_value(0 if key is None else key)
# write state value
spec.switch_write_focus(region=self.DATA_REGIONS.STATE.value)
spec.write_value(int(bool(self._state)))
# write neighbours data state
spec.switch_write_focus(
region=self.DATA_REGIONS.NEIGHBOUR_INITIAL_STATES.value)
alive = 0
dead = 0
for edge in edges:
if edge.pre_vertex.state:
alive += 1
else:
dead += 1
spec.write_value(alive)
spec.write_value(dead)
# End-of-Spec:
spec.end_specification()
def generate_data_specification(self, spec, placement, routing_info):
vertex = placement.vertex
spec.comment("\n*** Spec for Breakout Instance ***\n\n")
spec.comment("\nReserving memory space for data regions:\n\n")
# Reserve memory:
spec.reserve_memory_region(
region=BreakoutMachineVertex._BREAKOUT_REGIONS.SYSTEM.value,
size=front_end_common_constants.SYSTEM_BYTES_REQUIREMENT,
label='setup')
spec.reserve_memory_region(
region=BreakoutMachineVertex._BREAKOUT_REGIONS.BREAKOUT.value,
size=self.BREAKOUT_REGION_BYTES,
label='BreakoutKey')
# Reserve recording region
spec.reserve_memory_region(
BreakoutMachineVertex._BREAKOUT_REGIONS.RECORDING.value,
recording_utilities.get_recording_header_size(1))
spec.reserve_memory_region(
region=BreakoutMachineVertex._BREAKOUT_REGIONS.PARAMS.value,
size=self.PARAM_REGION_BYTES,
label='Parameters')
# Write setup region
spec.comment("\nWriting setup region:\n")
spec.switch_write_focus(
BreakoutMachineVertex._BREAKOUT_REGIONS.SYSTEM.value)
spec.write_array(
simulation_utilities.get_simulation_header_array(
vertex.get_binary_file_name()))
# Write breakout region containing routing key to transmit with
spec.comment("\nWriting breakout region:\n")
spec.switch_write_focus(
BreakoutMachineVertex._BREAKOUT_REGIONS.BREAKOUT.value)
spec.write_value(
routing_info.get_first_key_from_pre_vertex(
vertex, constants.SPIKE_PARTITION_ID))
# Write recording region for score
spec.comment("\nWriting breakout recording region:\n")
spec.switch_write_focus(
BreakoutMachineVertex._BREAKOUT_REGIONS.RECORDING.value)
spec.write_array(
recording_utilities.get_recording_header_array(
[self._recording_size]))
spec.comment("\nWriting breakout param region:\n")
spec.switch_write_focus(
BreakoutMachineVertex._BREAKOUT_REGIONS.PARAMS.value)
spec.write_value(self._x_factor, data_type=DataType.UINT32)
spec.write_value(self._y_factor, data_type=DataType.UINT32)
spec.write_value(self._bricking, data_type=DataType.UINT32)
spec.write_value(self._rand_seed[0], data_type=DataType.UINT32)
spec.write_value(self._rand_seed[1], data_type=DataType.UINT32)
spec.write_value(self._rand_seed[2], data_type=DataType.UINT32)
spec.write_value(self._rand_seed[3], data_type=DataType.UINT32)
# End-of-Spec:
spec.end_specification()
def generate_data_specification(self, spec, placement, routing_info):
vertex = placement.vertex
spec.comment("\n*** Spec for Double Pendulum Instance ***\n\n")
spec.comment("\nReserving memory space for data regions:\n\n")
# Reserve memory:
spec.reserve_memory_region(
region=self._DOUBLE_PENDULUM_REGIONS.SYSTEM.value,
size=front_end_common_constants.SYSTEM_BYTES_REQUIREMENT,
label='setup')
spec.reserve_memory_region(
region=self._DOUBLE_PENDULUM_REGIONS.PENDULUM.value,
size=self.PENDULUM_REGION_BYTES,
label='PendulumVertex')
# reserve recording region
spec.reserve_memory_region(
self._DOUBLE_PENDULUM_REGIONS.RECORDING.value,
recording_utilities.get_recording_header_size(1))
spec.reserve_memory_region(
region=self._DOUBLE_PENDULUM_REGIONS.DATA.value,
size=self.DATA_REGION_BYTES,
label='PendulumData')
# Write setup region
spec.comment("\nWriting setup region:\n")
spec.switch_write_focus(self._DOUBLE_PENDULUM_REGIONS.SYSTEM.value)
spec.write_array(
simulation_utilities.get_simulation_header_array(
vertex.get_binary_file_name()))
# Write pendulum region containing routing key to transmit with
spec.comment("\nWriting double pendulum region:\n")
spec.switch_write_focus(self._DOUBLE_PENDULUM_REGIONS.PENDULUM.value)
spec.write_value(
routing_info.get_first_key_from_pre_vertex(
vertex, constants.SPIKE_PARTITION_ID))
# Write recording region for score
spec.comment("\nWriting double pendulum recording region:\n")
spec.switch_write_focus(self._DOUBLE_PENDULUM_REGIONS.RECORDING.value)
spec.write_array(
recording_utilities.get_recording_header_array(
[self._recording_size]))
# Write probabilites for arms
spec.comment("\nWriting double pendulum data region:\n")
spec.switch_write_focus(self._DOUBLE_PENDULUM_REGIONS.DATA.value)
spec.write_value(self._encoding, data_type=DataType.UINT32)
spec.write_value(self._time_increment, data_type=DataType.UINT32)
spec.write_value(self._pole_length, data_type=DataType.S1615)
spec.write_value(self._pole_angle, data_type=DataType.S1615)
spec.write_value(self._pole2_length, data_type=DataType.S1615)
spec.write_value(self._pole2_angle, data_type=DataType.S1615)
spec.write_value(self._reward_based, data_type=DataType.UINT32)
spec.write_value(self._force_increments, data_type=DataType.UINT32)
spec.write_value(self._max_firing_rate, data_type=DataType.UINT32)
spec.write_value(self._number_of_bins, data_type=DataType.UINT32)
spec.write_value(self._central, data_type=DataType.UINT32)
spec.write_value(self._rand_seed[0], data_type=DataType.UINT32)
spec.write_value(self._rand_seed[1], data_type=DataType.UINT32)
spec.write_value(self._rand_seed[2], data_type=DataType.UINT32)
spec.write_value(self._rand_seed[3], data_type=DataType.UINT32)
spec.write_value(self._bin_overlap, data_type=DataType.S1615)
spec.write_value(self._tau_force, data_type=DataType.S1615)
# End-of-Spec:
spec.end_specification()
