def test_resource_container(self): """ tests that creating multiple resoruce containers doesnt cause issues. """ sdram = SDRAMResource(128 * (2**20)) dtcm = DTCMResource(128 * (2**20) + 1) cpu = CPUCyclesPerTickResource(128 * (2**20) + 2) container = ResourceContainer(dtcm, sdram, cpu) self.assertEqual(container.sdram.get_value(), 128 * (2**20)) self.assertEqual(container.dtcm.get_value(), 128 * (2**20) + 1) self.assertEqual(container.cpu_cycles.get_value(), 128 * (2**20) + 2) sdram = SDRAMResource(128 * (2**19)) dtcm = DTCMResource(128 * (2**19) + 1) cpu = CPUCyclesPerTickResource(128 * (2**19) + 2) container = ResourceContainer(dtcm, sdram, cpu) self.assertEqual(container.sdram.get_value(), 128 * (2**19)) self.assertEqual(container.dtcm.get_value(), 128 * (2**19) + 1) self.assertEqual(container.cpu_cycles.get_value(), 128 * (2**19) + 2) sdram = SDRAMResource(128 * (2**21)) dtcm = DTCMResource(128 * (2**21) + 1) cpu = CPUCyclesPerTickResource(128 * (2**21) + 2) container = ResourceContainer(dtcm, sdram, cpu) self.assertEqual(container.sdram.get_value(), 128 * (2**21)) self.assertEqual(container.dtcm.get_value(), 128 * (2**21) + 1) self.assertEqual(container.cpu_cycles.get_value(), 128 * (2**21) + 2)
def test_dtcm(self): """ test that adding a dtcm resource to a resoruce container works correctly """ dtcm = DTCMResource(128 * (2**20)) self.assertEqual(dtcm.get_value(), 128 * (2**20)) dtcm = DTCMResource(128 * (2**19)) self.assertEqual(dtcm.get_value(), 128 * (2**19)) dtcm = DTCMResource(128 * (2**21)) self.assertEqual(dtcm.get_value(), 128 * (2**21))
def get_resources_used_by_atoms(self, vertex_slice, n_machine_time_steps, machine_time_step): # build resources as i currently know container = ResourceContainer( sdram=SDRAMResource(self.get_sdram_usage_for_atoms(vertex_slice)), dtcm=DTCMResource(self.get_dtcm_usage_for_atoms()), cpu_cycles=CPUCyclesPerTickResource( self.get_cpu_usage_for_atoms())) recording_sizes = recording_utilities.get_recording_region_sizes( [ 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), self._N_POPULATION_RECORDING_REGIONS) ], n_machine_time_steps, self._minimum_buffer_sdram, self._maximum_sdram_for_buffering, self._using_auto_pause_and_resume) container.extend( recording_utilities.get_recording_resources( recording_sizes, self._receive_buffer_host, self._receive_buffer_port)) return container
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 get_resources_used_by_atoms(self, vertex_slice): return ResourceContainer( sdram=SDRAMResource( self.get_sdram_usage_for_atoms()), dtcm=DTCMResource(self.get_dtcm_usage_for_atoms(vertex_slice)), cpu_cycles=CPUCyclesPerTickResource( self.get_cpu_usage_for_atoms(vertex_slice)))
def __init__(self, lpg_params, constraints=None, app_vertex=None, label=None): """ :param LivePacketGatherParams lpg_params: :param LivePacketGather app_vertex: :param str label: :param constraints: :type constraints: iterable(~pacman.model.constraints.AbstractConstraint) """ # inheritance super(LivePacketGatherMachineVertex, self).__init__(label or lpg_params.label, constraints=constraints, app_vertex=app_vertex) self._resources_required = ResourceContainer( cpu_cycles=CPUCyclesPerTickResource(self.get_cpu_usage()), dtcm=DTCMResource(self.get_dtcm_usage()), sdram=ConstantSDRAM(self.get_sdram_usage()), iptags=[lpg_params.get_iptag_resource()]) # app specific data items self._lpg_params = lpg_params
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 get_resources_used_by_atoms(self, vertex_slice, graph): out_edges = graph.get_edges_starting_at_vertex(self) return ResourceContainer( sdram=SDRAMResource(self.get_sdram_usage_for_atoms(out_edges)), dtcm=DTCMResource(self.get_dtcm_usage_for_atoms(vertex_slice)), cpu_cycles=CPUCyclesPerTickResource( self.get_cpu_usage_for_atoms(vertex_slice)))
def __get_neuron_resources(self, vertex_slice): """ Gets the resources of the neurons of a slice of atoms from a given app vertex. :param ~pacman.model.graphs.common.Slice vertex_slice: the slice :rtype: ~pacman.model.resources.ResourceContainer """ n_record = len(self._governed_app_vertex.neuron_recordables) variable_sdram = self._governed_app_vertex.get_neuron_variable_sdram( vertex_slice) sdram = MultiRegionSDRAM() sdram.merge(self._governed_app_vertex.get_common_constant_sdram( n_record, NeuronProvenance.N_ITEMS + NeuronMainProvenance.N_ITEMS, PopulationNeuronsMachineVertex.COMMON_REGIONS)) sdram.merge(self._governed_app_vertex.get_neuron_constant_sdram( vertex_slice, PopulationNeuronsMachineVertex.NEURON_REGIONS)) sdram.add_cost( PopulationNeuronsMachineVertex.REGIONS.SDRAM_EDGE_PARAMS.value, NEURONS_SDRAM_PARAMS_SIZE) sdram.nest( len(PopulationNeuronsMachineVertex.REGIONS) + 1, variable_sdram) dtcm = self._governed_app_vertex.get_common_dtcm() dtcm += self._governed_app_vertex.get_neuron_dtcm(vertex_slice) cpu_cycles = self._governed_app_vertex.get_common_cpu() cpu_cycles += self._governed_app_vertex.get_neuron_cpu(vertex_slice) # set resources required from this object container = ResourceContainer( sdram=sdram, dtcm=DTCMResource(dtcm), cpu_cycles=CPUCyclesPerTickResource(cpu_cycles)) # return the total resources. return container
def dtcm_cost(self, vertex_slice): """ returns the dtcm used by the delay extension slice. :param Slice vertex_slice: vertex slice :rtype: DTCMResource """ return DTCMResource(self.WORDS_PER_ATOM * BYTES_PER_WORD * vertex_slice.n_atoms)
def get_resources_used_by_atoms(self, vertex_slice): # @UnusedVariable return ResourceContainer( sdram=ConstantSDRAM( LivePacketGatherMachineVertex.get_sdram_usage()), dtcm=DTCMResource(LivePacketGatherMachineVertex.get_dtcm_usage()), cpu_cycles=CPUCyclesPerTickResource( LivePacketGatherMachineVertex.get_cpu_usage()), iptags=[self._lpg_params.get_iptag_resource()])
def resources_required(self): sdram_required = (constants.SYSTEM_BYTES_REQUIREMENT + self.TRANSMISSION_DATA_SIZE + self.CONFIG_REGION_SIZE) resources = ResourceContainer(cpu_cycles=CPUCyclesPerTickResource(45), dtcm=DTCMResource(100), sdram=SDRAMResource(sdram_required)) return resources
def get_resources_used_by_atoms(self, vertex_slice, graph): # pylint: disable=arguments-differ out_edges = graph.get_edges_starting_at_vertex(self) return ResourceContainer( sdram=ConstantSDRAM( self.get_sdram_usage_for_atoms(out_edges)), dtcm=DTCMResource(self.get_dtcm_usage_for_atoms(vertex_slice)), cpu_cycles=CPUCyclesPerTickResource( self.get_cpu_usage_for_atoms(vertex_slice)))
def get_resources_used_by_atoms(lo_atom, hi_atom, vertex_in_edges): vertex = Vertex(1, None) cpu_cycles = vertex.get_cpu_usage_for_atoms(lo_atom, hi_atom) dtcm_requirement = vertex.get_dtcm_usage_for_atoms(lo_atom, hi_atom) sdram_requirement = vertex.get_sdram_usage_for_atoms( lo_atom, hi_atom, vertex_in_edges) return ResourceContainer(cpu_cycles=CPUCyclesPerTickResource(cpu_cycles), dtcm=DTCMResource(dtcm_requirement), sdram=SDRAMResource(sdram_requirement))
def resources_required(self): resources = ResourceContainer(sdram=SDRAMResource( self._calculate_sdram_requirement()), dtcm=DTCMResource(0), cpu_cycles=CPUCyclesPerTickResource(0)) resources.extend( recording_utilities.get_recording_resources( [MAX_SIZE_OF_BUFFERED_REGION_ON_CHIP], self._receive_buffer_host, self._receive_buffer_port)) return resources
def test_resource_container(self): sdram1 = ConstantSDRAM(128 * (2**20)) dtcm = DTCMResource(128 * (2**20) + 1) cpu = CPUCyclesPerTickResource(128 * (2**20) + 2) r1 = ResourceContainer(dtcm, sdram1, cpu) self.resource_there_and_back(r1) t1 = IPtagResource("1", 2, True) # Minimal args t2 = IPtagResource("1.2.3.4", 2, False, 4, 5) r2 = r1 = ResourceContainer(dtcm, sdram1, cpu, iptags=[t1, t2]) self.resource_there_and_back(r2)
def resource_container_from_json(json_dict): if json_dict is None: return None dtcm = DTCMResource(json_dict["dtcm"]) sdram = VariableSDRAM(json_dict["fixed_sdram"], json_dict["per_timestep_sdram"]) cpu_cycles = CPUCyclesPerTickResource(json_dict["cpu_cycles"]) iptags = iptag_resources_from_json(json_dict["iptags"]) reverse_iptags = iptag_resources_from_json(json_dict["reverse_iptags"]) return ResourceContainer(dtcm, sdram, cpu_cycles, iptags, reverse_iptags)
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_dtcm_cost(self, vertex_slice): """ get the dtcm cost for the slice of atoms :param Slice vertex_slice: atom slice for dtcm calc. :rtype: DTCMResource """ return DTCMResource( self._governed_app_vertex.get_common_dtcm() + self._governed_app_vertex.get_neuron_dtcm(vertex_slice) + self._governed_app_vertex.get_synapse_dtcm(vertex_slice))
def get_resources_used_by_atoms(self, vertex_slice): return ResourceContainer( sdram=SDRAMResource( LivePacketGatherMachineVertex.get_sdram_usage()), dtcm=DTCMResource(LivePacketGatherMachineVertex.get_dtcm_usage()), cpu_cycles=CPUCyclesPerTickResource( LivePacketGatherMachineVertex.get_cpu_usage()), iptags=[IPtagResource( ip_address=self._ip_address, port=self._port, strip_sdp=self._strip_sdp, tag=self._tag, traffic_identifier="LPG_EVENT_STREAM")])
def resources_required(self): resources = ResourceContainer( cpu_cycles=CPUCyclesPerTickResource(45), dtcm=DTCMResource(100), sdram=SDRAMResource(constants.SYSTEM_BYTES_REQUIREMENT + self.TRANSMISSION_REGION_N_BYTES)) resources.extend( recording_utilities.get_recording_resources( [self._recording_size], self._receive_buffer_host, self._receive_buffer_port)) return resources
def resources_required(self): resources = ResourceContainer(cpu_cycles=CPUCyclesPerTickResource(45), dtcm=DTCMResource(100), sdram=SDRAMResource(100)) resources.extend( recording_utilities.get_recording_resources( [self._string_data_size], self._receive_buffer_host, self._receive_buffer_port)) return resources
def get_resourced_machine_vertex(lo_atom, hi_atom, label=None): cpu_cycles = 10 * (hi_atom - lo_atom) dtcm_requirement = 200 * (hi_atom - lo_atom) sdram_requirement = 4000 + 50 * (hi_atom - lo_atom) resources = ResourceContainer( cpu_cycles=CPUCyclesPerTickResource(cpu_cycles), dtcm=DTCMResource(dtcm_requirement), sdram=ConstantSDRAM(sdram_requirement)) return SimpleMachineVertex(resources, label=label, vertex_slice=Slice(lo_atom, hi_atom))
def test_place_vertex_too_big_with_vertex(self): cpu_cycles = 1000 dtcm_requirement = 1000 sdram_requirement = self.machine.get_chip_at(0, 0).sdram.size * 20 rc = ResourceContainer(cpu_cycles=CPUCyclesPerTickResource(cpu_cycles), dtcm=DTCMResource(dtcm_requirement), sdram=ConstantSDRAM(sdram_requirement)) large_machine_vertex = T_MachineVertex(0, 499, rc, "Second vertex") self.mach_graph.add_vertex(large_machine_vertex) with self.assertRaises(PacmanValueError): ConnectiveBasedPlacer()(self.mach_graph, self.machine, 100)
def resources_required(self): sim = globals_variables.get_simulator() sdram = self.get_sdram_usage(self._send_buffer_times, self._is_recording, sim.machine_time_step, self._receive_rate, self._n_keys) resources = ResourceContainer(dtcm=DTCMResource(self.get_dtcm_usage()), sdram=sdram, cpu_cycles=CPUCyclesPerTickResource( self.get_cpu_usage()), reverse_iptags=self._reverse_iptags) return resources
def get_resources_used_by_atoms(self, vertex_slice): """ standard method call to get the sdram, cpu and dtcm usage of a collection of atoms :param vertex_slice: the collection of atoms """ return ResourceContainer( sdram=ConstantSDRAM(self.get_sdram_usage_for_atoms(vertex_slice)), cpu_cycles=CPUCyclesPerTickResource( self.get_cpu_usage_for_atoms(vertex_slice)), dtcm=DTCMResource(self.get_dtcm_usage_for_atoms(vertex_slice)))
def get_resources(n_machine_time_steps, 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 # get config config = globals_variables.get_simulator().config # get recording params minimum_buffer_sdram = config.getint("Buffers", "minimum_buffer_sdram") using_auto_pause_and_resume = config.getboolean( "Buffers", "use_auto_pause_and_resume") receive_buffer_host = config.get("Buffers", "receive_buffer_host") receive_buffer_port = read_config_int(config, "Buffers", "receive_buffer_port") # figure recording size for max run if not using_auto_pause_and_resume and n_machine_time_steps is None: raise Exception( "You cannot use the chip power montiors without auto pause " "and resume and not allocating a n_machine_time_steps") # figure max buffer size max_buffer_size = 0 if config.getboolean("Buffers", "enable_buffered_recording"): max_buffer_size = config.getint("Buffers", "chip_power_monitor_buffer") maximum_sdram_for_buffering = [max_buffer_size] n_recording_entries = (math.ceil( (sampling_frequency / (time_step * time_scale_factor))) / n_samples_per_recording) recording_size = ( ChipPowerMonitorMachineVertex.RECORDING_SIZE_PER_ENTRY * n_recording_entries) container = ResourceContainer(sdram=SDRAMResource( ChipPowerMonitorMachineVertex.sdram_calculation()), cpu_cycles=CPUCyclesPerTickResource(100), dtcm=DTCMResource(100)) recording_sizes = recording_utilities.get_recording_region_sizes( [int(recording_size) * n_machine_time_steps], minimum_buffer_sdram, maximum_sdram_for_buffering, using_auto_pause_and_resume) container.extend( recording_utilities.get_recording_resources( recording_sizes, receive_buffer_host, receive_buffer_port)) return container
def test_place_vertex_too_big_with_vertex(self): cpu_cycles = 1000 dtcm_requirement = 1000 sdram_requirement = self.machine.get_chip_at(0, 0).sdram.size * 20 rc = ResourceContainer(cpu_cycles=CPUCyclesPerTickResource(cpu_cycles), dtcm=DTCMResource(dtcm_requirement), sdram=ConstantSDRAM(sdram_requirement)) large_machine_vertex = SimpleMachineVertex(rc, vertex_slice=Slice(0, 499), label="Second vertex") self.mach_graph.add_vertex(large_machine_vertex) with self.assertRaises(PacmanValueError): radial_placer(self.mach_graph, self.machine, 100)
def __init__(self, label, use_prefix=False, key_prefix=None, prefix_type=None, message_type=EIEIOType.KEY_32_BIT, right_shift=0, payload_as_time_stamps=True, use_payload_prefix=True, payload_prefix=None, payload_right_shift=0, number_of_packets_sent_per_time_step=0, hostname=None, port=None, strip_sdp=None, board_address=None, tag=None, constraints=None): # pylint: disable=too-many-arguments, too-many-locals # inheritance super(LivePacketGatherMachineVertex, self).__init__(label, constraints=constraints) self._resources_required = ResourceContainer( cpu_cycles=CPUCyclesPerTickResource(self.get_cpu_usage()), dtcm=DTCMResource(self.get_dtcm_usage()), sdram=SDRAMResource(self.get_sdram_usage()), iptags=[ IPtagResource(ip_address=hostname, port=port, strip_sdp=strip_sdp, tag=tag, traffic_identifier=self.TRAFFIC_IDENTIFIER) ]) # app specific data items self._use_prefix = use_prefix self._key_prefix = key_prefix self._prefix_type = prefix_type self._message_type = message_type self._right_shift = right_shift self._payload_as_time_stamps = payload_as_time_stamps self._use_payload_prefix = use_payload_prefix self._payload_prefix = payload_prefix self._payload_right_shift = payload_right_shift self._number_of_packets_sent_per_time_step = \ number_of_packets_sent_per_time_step
def resources_required(self): sdram_required = (constants.SYSTEM_BYTES_REQUIREMENT + self.TRANSMISSION_DATA_SIZE + self.CONFIG_PARAM_SIZE) sdram_required += \ app_constants.MACHINE_STEPS * self.RECORD_BYTES_PER_STEP resources = ResourceContainer(cpu_cycles=CPUCyclesPerTickResource(45), dtcm=DTCMResource(100), sdram=SDRAMResource(sdram_required)) # resources.extend(recording_utilities.get_recording_resources( # [app_constants.MACHINE_STEPS * self.RECORD_BYTES_PER_STEP], # self._receive_buffer_host, self._receive_buffer_port)) return resources
def test_dtcm(self): """ test that adding a DTCM resource to a resource container works correctly """ dtcm = DTCMResource(128 * (2**20)) self.assertEqual(dtcm.get_value(), 128 * (2**20)) dtcm = DTCMResource(128 * (2**19)) self.assertEqual(dtcm.get_value(), 128 * (2**19)) dtcm = DTCMResource(128 * (2**21)) self.assertEqual(dtcm.get_value(), 128 * (2**21))