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)