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 SDRAM space for memory areas:
# Create the data regions for hello world
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 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]))
# End-of-Spec:
spec.end_specification()
def reserve_memory_regions(self, spec, placement, graph_mapper):
""" Reserve memory regions for poisson source parameters and output\
buffer.
:param spec: the data specification writer
:param placement: the location this vertex resides on in the machine
:param graph_mapper: the mapping between app and machine graphs
:return: None
"""
spec.comment("\nReserving memory space for data regions:\n\n")
# Reserve memory:
spec.reserve_memory_region(
region=(SpikeSourcePoissonMachineVertex.
POISSON_SPIKE_SOURCE_REGIONS.SYSTEM_REGION.value),
size=front_end_common_constants.SYSTEM_BYTES_REQUIREMENT,
label='setup')
# reserve poisson params dsg region
self._reserve_poisson_params_region(placement, graph_mapper, spec)
spec.reserve_memory_region(
region=(SpikeSourcePoissonMachineVertex.
POISSON_SPIKE_SOURCE_REGIONS.SPIKE_HISTORY_REGION.value),
size=recording_utilities.get_recording_header_size(1),
label="Recording")
placement.vertex.reserve_provenance_data_region(spec)
def resources_required(self):
resources = ResourceContainer(sdram=ConstantSDRAM(
SYSTEM_BYTES_REQUIREMENT +
recording_utilities.get_recording_header_size(1) +
self._string_data_size))
return resources
def reserve_memory_regions(self, spec, placement, graph_mapper):
""" Reserve memory regions for Poisson source parameters and output\
buffer.
:param spec: the data specification writer
:param placement: the location this vertex resides on in the machine
:param graph_mapper: the mapping between app and machine graphs
:return: None
"""
spec.comment("\nReserving memory space for data regions:\n\n")
# Reserve memory:
spec.reserve_memory_region(region=_REGIONS.SYSTEM_REGION.value,
size=SIMULATION_N_BYTES,
label='setup')
# reserve poisson parameters and rates DSG region
self._reserve_poisson_params_rates_region(placement, graph_mapper,
spec)
spec.reserve_memory_region(
region=_REGIONS.SPIKE_HISTORY_REGION.value,
size=recording_utilities.get_recording_header_size(1),
label="Recording")
profile_utils.reserve_profile_region(spec,
_REGIONS.PROFILER_REGION.value,
self.__n_profile_samples)
placement.vertex.reserve_provenance_data_region(spec)
def resources_required(self):
resources = ResourceContainer(
sdram=ConstantSDRAM(SYSTEM_BYTES_REQUIREMENT +
get_recording_header_size(len(Channels)) +
self._string_data_size))
return resources
def _reserve_regions(self, spec):
# Reserve system and configuration memory regions:
spec.reserve_memory_region(region=self._REGIONS.SYSTEM.value,
size=constants.SYSTEM_BYTES_REQUIREMENT,
label='SYSTEM')
spec.reserve_memory_region(region=self._REGIONS.CONFIGURATION.value,
size=self._CONFIGURATION_REGION_SIZE,
label='CONFIGURATION')
# Reserve recording buffer regions if required
spec.reserve_memory_region(
region=self._REGIONS.RECORDING.value,
size=recording_utilities.get_recording_header_size(1),
label="RECORDING")
# Reserve send buffer region if required
if self._send_buffer_times is not None:
max_buffer_size = self.get_max_buffer_size_possible(
self._REGIONS.SEND_BUFFER.value)
spec.reserve_memory_region(region=self._REGIONS.SEND_BUFFER.value,
size=max_buffer_size,
label="SEND_BUFFER",
empty=True)
self.reserve_provenance_data_region(spec)
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 get_resources(time_step, time_scale_factor, n_samples_per_recording,
sampling_frequency):
""" Get the resources used by this vertex
:return: Resource container
"""
# pylint: disable=too-many-locals
step_in_microseconds = (time_step * time_scale_factor)
# The number of sample per step CB believes does not have to be an int
samples_per_step = (step_in_microseconds / sampling_frequency)
recording_per_step = (samples_per_step / n_samples_per_recording)
max_recording_per_step = math.ceil(recording_per_step)
overflow_recordings = max_recording_per_step - recording_per_step
system = SYSTEM_BYTES_REQUIREMENT
config = CONFIG_SIZE_IN_BYTES
recording = recording_utilities.get_recording_header_size(1)
recording += recording_utilities.get_recording_data_constant_size(1)
fixed_sdram = system + config + recording
with_overflow = (fixed_sdram +
overflow_recordings * RECORDING_SIZE_PER_ENTRY)
per_timestep = recording_per_step * RECORDING_SIZE_PER_ENTRY
container = ResourceContainer(sdram=VariableSDRAM(
with_overflow, per_timestep),
cpu_cycles=CPUCyclesPerTickResource(100),
dtcm=DTCMResource(100))
return container
def resources_required(self):
fixed = (
SYSTEM_BYTES_REQUIREMENT +
recording_utilities.get_recording_header_size(len(Channels)) +
self.PARAMS_BASE_SIZE + len(self._text))
variable = len(self._text)
return ResourceContainer(sdram=VariableSDRAM(fixed, variable))
def reserve_memory_regions(self, spec, placement):
""" Reserve memory regions for Poisson source parameters and output\
buffer.
:param ~data_specification.DataSpecification spec:
the data specification writer
:param ~pacman.models.placements.Placement placement:
the location this vertex resides on in the machine
:return: None
"""
spec.comment("\nReserving memory space for data regions:\n\n")
# Reserve memory:
spec.reserve_memory_region(region=_REGIONS.SYSTEM_REGION.value,
size=SIMULATION_N_BYTES,
label='setup')
# reserve poisson parameters and rates DSG region
self._reserve_poisson_params_rates_region(placement, spec)
spec.reserve_memory_region(
region=_REGIONS.SPIKE_HISTORY_REGION.value,
size=recording_utilities.get_recording_header_size(1),
label="Recording")
profile_utils.reserve_profile_region(spec,
_REGIONS.PROFILER_REGION.value,
self.__n_profile_samples)
spec.reserve_memory_region(region=_REGIONS.TDMA_REGION.value,
label="tdma_region",
size=self.tdma_sdram_size_in_bytes)
placement.vertex.reserve_provenance_data_region(spec)
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 _reserve_regions(self, spec):
# Reserve system and configuration memory regions:
spec.reserve_memory_region(
region=self._REGIONS.SYSTEM.value,
size=SYSTEM_BYTES_REQUIREMENT, label='SYSTEM')
spec.reserve_memory_region(
region=self._REGIONS.CONFIGURATION.value,
size=self._CONFIGURATION_REGION_SIZE, label='CONFIGURATION')
# Reserve recording buffer regions if required
spec.reserve_memory_region(
region=self._REGIONS.RECORDING.value,
size=get_recording_header_size(1),
label="RECORDING")
# Reserve send buffer region if required
if self._send_buffer_times is not None:
max_buffer_size = self.get_max_buffer_size_possible(
self._REGIONS.SEND_BUFFER.value)
spec.reserve_memory_region(
region=self._REGIONS.SEND_BUFFER.value,
size=max_buffer_size, label="SEND_BUFFER", empty=True)
self.reserve_provenance_data_region(spec)
def get_resources_used_by_atoms(self, vertex_slice, machine_time_step):
"""
:param ~pacman.model.graphs.common.Slice vertex_slice:
:param int machine_time_step:
"""
# pylint: disable=arguments-differ
poisson_params_sz = self.get_rates_bytes(vertex_slice)
other = ConstantSDRAM(
SYSTEM_BYTES_REQUIREMENT +
SpikeSourcePoissonMachineVertex.get_provenance_data_size(0) +
poisson_params_sz + self.tdma_sdram_size_in_bytes +
recording_utilities.get_recording_header_size(1) +
recording_utilities.get_recording_data_constant_size(1) +
profile_utils.get_profile_region_size(self.__n_profile_samples))
recording = self.get_recording_sdram_usage(vertex_slice,
machine_time_step)
# build resources as i currently know
container = ResourceContainer(sdram=recording + other,
dtcm=DTCMResource(
self.get_dtcm_usage_for_atoms()),
cpu_cycles=CPUCyclesPerTickResource(
self.get_cpu_usage_for_atoms()))
return container
def reserve_memory_regions(self, spec, placement, graph_mapper):
""" Reserve memory regions for poisson source parameters and output\
buffer.
:param spec: the data specification writer
:param placement: the location this vertex resides on in the machine
:param graph_mapper: the mapping between app and machine graphs
:return: None
"""
spec.comment("\nReserving memory space for data regions:\n\n")
# Reserve memory:
spec.reserve_memory_region(
region=_REGIONS.SYSTEM_REGION.value,
size=SIMULATION_N_BYTES,
label='setup')
# reserve poisson params dsg region
self._reserve_poisson_params_region(placement, graph_mapper, spec)
spec.reserve_memory_region(
region=_REGIONS.SPIKE_HISTORY_REGION.value,
size=recording_utilities.get_recording_header_size(1),
label="Recording")
placement.vertex.reserve_provenance_data_region(spec)
def _reverse_memory_regions(self, spec, output_data, machine_graph):
input_n_keys = len(
machine_graph.get_outgoing_edge_partitions_starting_at_vertex(
self))
spec.reserve_memory_region(self.DATA_REGIONS.SYSTEM.value,
fec_constants.SYSTEM_BYTES_REQUIREMENT,
label="system region")
spec.reserve_memory_region(
self.DATA_REGIONS.KEY_REGION.value,
helpful_functions.sdram_size_in_bytes_for_routing_region(
input_n_keys),
label="routing region")
spec.reserve_memory_region(self.DATA_REGIONS.OUTPUT_REGION.value,
output_data.nbytes,
label="output region")
if self._is_recording_output:
spec.reserve_memory_region(
region=self.DATA_REGIONS.RECORDING.value,
size=recording_utilities.get_recording_header_size(
self.N_RECORDING_REGIONS),
label="recording")
spec.reserve_memory_region(
region=self.DATA_REGIONS.NEURON_REGION.value,
size=self.NEURON_REGION_ITEMS * constants.BYTE_TO_WORD_MULTIPLIER,
label="n neurons")
def _reserve_regions(self, spec, n_machine_time_steps):
# Reserve system and configuration memory regions:
spec.reserve_memory_region(region=self._REGIONS.SYSTEM.value,
size=SIMULATION_N_BYTES,
label='SYSTEM')
spec.reserve_memory_region(region=self._REGIONS.CONFIGURATION.value,
size=self._CONFIGURATION_REGION_SIZE,
label='CONFIGURATION')
# Reserve recording buffer regions if required
spec.reserve_memory_region(region=self._REGIONS.RECORDING.value,
size=get_recording_header_size(1),
label="RECORDING")
# Reserve send buffer region if required
if self._send_buffer_times is not None:
self._send_buffer_size = (self.send_buffer_sdram_per_timestep(
self._send_buffer_times, self._n_keys) * n_machine_time_steps)
if self._send_buffer_size:
spec.reserve_memory_region(
region=self._REGIONS.SEND_BUFFER.value,
size=self._send_buffer_size,
label="SEND_BUFFER",
empty=True)
self.reserve_provenance_data_region(spec)
def get_static_sdram_usage(self, vertex_slice):
n_record = len(self.__sampling_rates)
sdram = (
recording_utilities.get_recording_header_size(n_record) +
recording_utilities.get_recording_data_constant_size(n_record) +
self.get_sdram_usage_in_bytes(vertex_slice))
return int(sdram)
def get_sdram_usage(cls, send_buffer_times, recording_enabled,
machine_time_step, receive_rate, n_keys):
"""
:param send_buffer_times: When events will be sent
:type send_buffer_times:
~numpy.ndarray(~numpy.ndarray(numpy.int32)) or
list(~numpy.ndarray(numpy.int32)) or None
:param bool recording_enabled: Whether recording is done
:param int machine_time_step: What the machine timestep is
:param float receive_rate: What the expected message receive rate is
:param int n_keys: How many keys are being sent
:rtype: ~pacman.model.resources.VariableSDRAM
"""
static_usage = (SYSTEM_BYTES_REQUIREMENT +
cls._CONFIGURATION_REGION_SIZE +
get_recording_header_size(1) +
get_recording_data_constant_size(1) +
cls.get_provenance_data_size(0))
per_timestep = (
cls._send_buffer_sdram_per_timestep(send_buffer_times, n_keys) +
cls._recording_sdram_per_timestep(machine_time_step,
recording_enabled, receive_rate,
send_buffer_times, n_keys))
static_usage += per_timestep
return VariableSDRAM(static_usage, per_timestep)
def _reserve_memory_regions(self, spec, system_size):
spec.reserve_memory_region(region=self.DATA_REGIONS.SYSTEM.value,
size=system_size,
label='systemInfo')
spec.reserve_memory_region(
region=self.DATA_REGIONS.STRING_DATA.value,
size=recording_utilities.get_recording_header_size(1),
label="Recording")
def _reserve_app_memory_regions(self, spec):
spec.reserve_memory_region(region=self.DATA_REGIONS.TRANSMISSION.value,
size=self.TRANSMISSION_REGION_N_BYTES,
label="transmission")
spec.reserve_memory_region(
region=self.DATA_REGIONS.RECORDED_DATA.value,
size=recording_utilities.get_recording_header_size(1),
label="recording")
def resources_required(self):
fixed_sdram = (SYSTEM_BYTES_REQUIREMENT + self.TRANSMISSION_DATA_SIZE +
self.STATE_DATA_SIZE +
self.NEIGHBOUR_INITIAL_STATES_SIZE +
get_recording_header_size(len(Channels)) +
get_recording_data_constant_size(len(Channels)))
per_timestep_sdram = self.RECORDING_ELEMENT_SIZE
return ResourceContainer(
sdram=VariableSDRAM(fixed_sdram, per_timestep_sdram))
def resources_required(self):
constant_sdram = (
SYSTEM_BYTES_REQUIREMENT + self.TRANSMISSION_REGION_N_BYTES +
recording_utilities.get_recording_header_size(1) +
recording_utilities.get_recording_data_constant_size(1))
variable_sdram = self.N_RECORDED_PER_TIMESTEP
return ResourceContainer(cpu_cycles=CPUCyclesPerTickResource(45),
dtcm=DTCMResource(100),
sdram=VariableSDRAM(constant_sdram,
variable_sdram))
def get_static_sdram_usage(self, vertex_slice):
"""
:param ~pacman.model.graphs.common.Slice vertex_slice:
:rtype: int
"""
n_record = len(self.__sampling_rates)
sdram = (get_recording_header_size(n_record) +
get_recording_data_constant_size(n_record) +
self.get_sdram_usage_in_bytes(vertex_slice))
return int(sdram)
def _reserve_memory_regions(self, spec):
spec.reserve_memory_region(region=self.DATA_REGIONS.SYSTEM.value,
size=constants.SYSTEM_BYTES_REQUIREMENT,
label='systemInfo')
spec.reserve_memory_region(region=self.DATA_REGIONS.TRANSMISSION.value,
size=self.TRANSMISSION_REGION_N_BYTES,
label="transmission")
spec.reserve_memory_region(
region=self.DATA_REGIONS.RECORDED_DATA.value,
size=recording_utilities.get_recording_header_size(1),
label="recording")
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 resources_required(self, app_graph):
out_edges = app_graph.get_edges_starting_at_vertex(self.app_vertex)
in_edges = app_graph.get_edges_starting_at_vertex(self.app_vertex)
return ResourceContainer(sdram=VariableSDRAM(fixed_sdram=(
SIMULATION_N_BYTES +
(len(out_edges) * self.SDRAM_PARTITION_BASE_DSG_SIZE) +
(len(in_edges) * self.SDRAM_PARTITION_BASE_DSG_SIZE) +
(self.SDRAM_PARTITION_COUNTERS * 2) + SARK_PER_MALLOC_SDRAM_USAGE +
recording_utilities.get_recording_header_size(len(Channels)) +
recording_utilities.get_recording_data_constant_size(len(Channels))
),
per_timestep_sdram=self.
RECORDING_ELEMENT_SIZE))
def resources_required(self):
"""
Reserve resources for data regions
"""
fixed_sdram = (SYSTEM_BYTES_REQUIREMENT + self.TRANSMISSION_DATA_SIZE +
self.POSITION_DATA_SIZE +
self.NEIGHBOUR_KEYS_SIZE +
self.VELOCITY_SIZE +
self.VERTEX_INDEX_SIZE +
recording_utilities.get_recording_header_size(1) +
recording_utilities.get_recording_data_constant_size(1))
per_timestep_sdram = self.RECORDING_ELEMENT_SIZE
return ResourceContainer(
sdram=VariableSDRAM(fixed_sdram, per_timestep_sdram))
def _reserve_memory_regions(self, spec, system_size):
spec.reserve_memory_region(region=self.DATA_REGIONS.SYSTEM.value,
size=system_size,
label='systemInfo')
spec.reserve_memory_region(
region=self.DATA_REGIONS.TRANSMISSION_DATA.value,
size=self.TRANSMISSION_DATA_SIZE,
label="My Key")
spec.reserve_memory_region(region=self.DATA_REGIONS.CONFIG.value,
size=self.CONFIG_PARAM_SIZE,
label="Config x, y, r")
spec.reserve_memory_region(
region=self.DATA_REGIONS.RECORDING.value,
size=recording_utilities.get_recording_header_size(1),
label="Recording Region")
def _get_sdram_usage_for_atoms(self, vertex_slice, graph,
machine_time_step):
n_record = len(self.__neuron_impl.get_recordable_variables()) + 1
sdram_requirement = (
common_constants.SYSTEM_BYTES_REQUIREMENT +
self._get_sdram_usage_for_neuron_params(vertex_slice) +
recording_utilities.get_recording_header_size(n_record) +
recording_utilities.get_recording_data_constant_size(n_record) +
PopulationMachineVertex.get_provenance_data_size(
PopulationMachineVertex.N_ADDITIONAL_PROVENANCE_DATA_ITEMS) +
self.__synapse_manager.get_sdram_usage_in_bytes(
vertex_slice, graph.get_edges_ending_at_vertex(self),
machine_time_step) +
profile_utils.get_profile_region_size(self.__n_profile_samples))
return sdram_requirement
def get_sdram_usage_for_atoms(self, vertex_slice, graph,
machine_time_step):
sdram_requirement = (
common_constants.SYSTEM_BYTES_REQUIREMENT +
self._get_sdram_usage_for_neuron_params(vertex_slice) +
recording_utilities.get_recording_header_size(
self.N_RECORDING_REGIONS) +
PopulationMachineVertex.get_provenance_data_size(
PopulationMachineVertex.N_ADDITIONAL_PROVENANCE_DATA_ITEMS) +
self._synapse_manager.get_sdram_usage_in_bytes(
vertex_slice, graph.get_edges_ending_at_vertex(self),
machine_time_step) +
(self._get_number_of_mallocs_used_by_dsg() *
common_constants.SARK_PER_MALLOC_SDRAM_USAGE) +
profile_utils.get_profile_region_size(self._n_profile_samples))
return sdram_requirement
def _get_sdram_usage_for_atoms(
self, vertex_slice, graph, machine_time_step):
n_record = len(self._neuron_impl.get_recordable_variables()) + 1
sdram_requirement = (
common_constants.SYSTEM_BYTES_REQUIREMENT +
self._get_sdram_usage_for_neuron_params(vertex_slice) +
recording_utilities.get_recording_header_size(n_record) +
recording_utilities.get_recording_data_constant_size(n_record) +
PopulationMachineVertex.get_provenance_data_size(
PopulationMachineVertex.N_ADDITIONAL_PROVENANCE_DATA_ITEMS) +
self._synapse_manager.get_sdram_usage_in_bytes(
vertex_slice, graph.get_edges_ending_at_vertex(self),
machine_time_step) +
profile_utils.get_profile_region_size(
self._n_profile_samples))
return sdram_requirement
def get_sdram_usage(send_buffer_times, recording_enabled,
machine_time_step, receive_rate, n_keys):
static_usage = (SYSTEM_BYTES_REQUIREMENT +
(ReverseIPTagMulticastSourceMachineVertex.
_CONFIGURATION_REGION_SIZE) +
get_recording_header_size(1) +
get_recording_data_constant_size(1) +
(ReverseIPTagMulticastSourceMachineVertex.
get_provenance_data_size(0)))
per_timestep = (
ReverseIPTagMulticastSourceMachineVertex.
send_buffer_sdram_per_timestep(send_buffer_times, n_keys) +
ReverseIPTagMulticastSourceMachineVertex.
recording_sdram_per_timestep(machine_time_step, recording_enabled,
receive_rate, send_buffer_times,
n_keys))
static_usage += per_timestep
return VariableSDRAM(static_usage, per_timestep)
def _reserve_memory_regions(self, spec):
""" Reserve the DSG memory regions as required
:param spec: the DSG specification to reserve in
:rtype: None
"""
spec.comment("\nReserving memory space for data regions:\n\n")
# Reserve memory:
spec.reserve_memory_region(
region=self.CHIP_POWER_MONITOR_REGIONS.SYSTEM.value,
size=SYSTEM_BYTES_REQUIREMENT,
label='system')
spec.reserve_memory_region(
region=self.CHIP_POWER_MONITOR_REGIONS.CONFIG.value,
size=self.CONFIG_SIZE_IN_BYTES, label='config')
spec.reserve_memory_region(
region=self.CHIP_POWER_MONITOR_REGIONS.RECORDING.value,
size=recording_utilities.get_recording_header_size(1),
label="Recording")
def get_resources_used_by_atoms(self, vertex_slice, machine_time_step):
# pylint: disable=arguments-differ
poisson_params_sz = self.get_params_bytes(vertex_slice)
other = ConstantSDRAM(
SYSTEM_BYTES_REQUIREMENT +
SpikeSourcePoissonMachineVertex.get_provenance_data_size(0) +
poisson_params_sz +
recording_utilities.get_recording_header_size(1) +
recording_utilities.get_recording_data_constant_size(1))
recording = self.get_recording_sdram_usage(
vertex_slice, machine_time_step)
# build resources as i currently know
container = ResourceContainer(
sdram=recording + other,
dtcm=DTCMResource(self.get_dtcm_usage_for_atoms()),
cpu_cycles=CPUCyclesPerTickResource(
self.get_cpu_usage_for_atoms()))
return container
def _reserve_memory_regions(self, spec, vertex_slice, vertex):
spec.comment("\nReserving memory space for data regions:\n\n")
# Reserve memory:
spec.reserve_memory_region(
region=constants.POPULATION_BASED_REGIONS.SYSTEM.value,
size=common_constants.SIMULATION_N_BYTES,
label='System')
self._reserve_neuron_params_data_region(spec, vertex_slice)
spec.reserve_memory_region(
region=constants.POPULATION_BASED_REGIONS.RECORDING.value,
size=recording_utilities.get_recording_header_size(
len(self._neuron_impl.get_recordable_variables()) + 1))
profile_utils.reserve_profile_region(
spec, constants.POPULATION_BASED_REGIONS.PROFILING.value,
self._n_profile_samples)
vertex.reserve_provenance_data_region(spec)
