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 _do_test(self, placer): machine = VirtualMachine(width=8, height=8) graph = MachineGraph("Test") vertices = [ SimpleMachineVertex(ResourceContainer(), label="v{}".format(i)) for i in range(100) ] for vertex in vertices: graph.add_vertex(vertex) same_vertices = [ SimpleMachineVertex(ResourceContainer(), label="same{}".format(i)) for i in range(10) ] random.seed(12345) sdram_edges = list() for vertex in same_vertices: graph.add_vertex(vertex) for i in range(0, random.randint(1, 5)): sdram_edge = MachineEdge( vertex, vertices[random.randint(0, 99)], traffic_type=EdgeTrafficType.SDRAM) sdram_edges.append(sdram_edge) graph.add_edge(sdram_edge, "Test") placements = placer(graph, machine) for edge in sdram_edges: pre_place = placements.get_placement_of_vertex(edge.pre_vertex) post_place = placements.get_placement_of_vertex(edge.post_vertex) self.assert_(pre_place.x == post_place.x) self.assert_(pre_place.y == post_place.y)
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_tags_resources(self): t1 = IPtagResource("1", 2, True) # Minimal args r1 = ResourceContainer(iptags=[t1]) self.resource_there_and_back(r1) t2 = IPtagResource("1.2.3.4", 2, False, 4, 5) r2 = ResourceContainer(reverse_iptags=[t2]) self.resource_there_and_back(r2)
def create_requirement_collections(vertices, machine_graph): """ Get a collection of requirements that includes SDRAM edge resources """ # Get all but the last requirements, keeping the SDRAM edge requirements required_resources = list() to_add_partitions = set() last_resources = None last_constraints = None for vertex in vertices: if last_resources is not None: required_resources.append([last_resources, last_constraints]) last_resources = vertex.resources_required last_constraints = vertex.constraints to_add_partitions.update( machine_graph.get_sdram_edge_partitions_starting_at_vertex(vertex)) # Add up all the SDRAM edge requirements total_sdram = 0 for partition in to_add_partitions: total_sdram += partition.total_sdram_requirements() # Add the SDRAM requirements to the final requirements resources = ResourceContainer(sdram=ConstantSDRAM(total_sdram)) resources.extend(last_resources) required_resources.append([resources, last_constraints]) return required_resources
def _integration_setup(self): machine_graph = MachineGraph(label="test me you git") n_keys_map = DictBasedMachinePartitionNKeysMap() v1 = SimpleMachineVertex(ResourceContainer()) v2 = SimpleMachineVertex(ResourceContainer()) v3 = SimpleMachineVertex(ResourceContainer()) v4 = SimpleMachineVertex(ResourceContainer()) machine_graph.add_vertex(v1) machine_graph.add_vertex(v2) machine_graph.add_vertex(v3) machine_graph.add_vertex(v4) e1 = MachineEdge(v1, v2, label="e1") e2 = MachineEdge(v1, v3, label="e2") e3 = MachineEdge(v2, v3, label="e3") e4 = MachineEdge(v1, v4, label="e4") machine_graph.add_outgoing_edge_partition( MulticastEdgePartition(identifier="part1", pre_vertex=v1)) machine_graph.add_outgoing_edge_partition( MulticastEdgePartition(identifier="part2", pre_vertex=v2)) machine_graph.add_outgoing_edge_partition( MulticastEdgePartition(identifier="part2", pre_vertex=v1)) machine_graph.add_edge(e1, "part1") machine_graph.add_edge(e2, "part1") machine_graph.add_edge(e3, "part2") machine_graph.add_edge(e4, "part2") for partition in machine_graph.outgoing_edge_partitions: n_keys_map.set_n_keys_for_partition(partition, 24) return machine_graph, n_keys_map, v1, v2, v3, v4, e1, e2, e3, e4
def resources_required(self): if self.group.output_grp: resources = ResourceContainer( sdram=VariableSDRAM(self._sdram_fixed, self._sdram_variable)) else: resources = ResourceContainer( sdram=ConstantSDRAM(self._sdram_fixed)) 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 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 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 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 _do_test(self, placer): machine = virtual_machine(width=8, height=8) graph = MachineGraph("Test") vertices = [ SimpleMachineVertex(ResourceContainer(), label="v{}".format(i)) for i in range(100) ] for vertex in vertices: graph.add_vertex(vertex) same_vertices = [ SimpleMachineVertex(ResourceContainer(), label="same{}".format(i)) for i in range(10) ] random.seed(12345) for vertex in same_vertices: graph.add_vertex(vertex) for _i in range(0, random.randint(1, 5)): vertex.add_constraint( SameChipAsConstraint( vertices[random.randint(0, 99)])) n_keys_map = DictBasedMachinePartitionNKeysMap() inputs = { "MemoryExtendedMachine": machine, "MemoryMachine": machine, "MemoryMachineGraph": graph, "PlanNTimeSteps": None, "MemoryMachinePartitionNKeysMap": n_keys_map } algorithms = [placer] xml_paths = [] executor = PACMANAlgorithmExecutor( algorithms, [], inputs, [], [], [], xml_paths) executor.execute_mapping() placements = executor.get_item("MemoryPlacements") for same in same_vertices: print("{0.vertex.label}, {0.x}, {0.y}, {0.p}: {1}".format( placements.get_placement_of_vertex(same), ["{0.vertex.label}, {0.x}, {0.y}, {0.p}".format( placements.get_placement_of_vertex(constraint.vertex)) for constraint in same.constraints])) placement = placements.get_placement_of_vertex(same) for constraint in same.constraints: if isinstance(constraint, SameChipAsConstraint): other_placement = placements.get_placement_of_vertex( constraint.vertex) self.assertTrue( other_placement.x == placement.x and other_placement.y == placement.y, "Vertex was not placed on the same chip as requested")
def _do_test(self, placer): machine = virtual_machine(width=8, height=8) graph = MachineGraph("Test") plan_n_timesteps = 100 vertices = [ SimpleMachineVertex(ResourceContainer(), label="v{}".format(i), sdram_cost=20) for i in range(100) ] for vertex in vertices: graph.add_vertex(vertex) same_vertices = [ SimpleMachineVertex(ResourceContainer(), label="same{}".format(i), sdram_cost=20) for i in range(10) ] random.seed(12345) sdram_edges = list() for vertex in same_vertices: graph.add_vertex(vertex) graph.add_outgoing_edge_partition( ConstantSDRAMMachinePartition(identifier="Test", pre_vertex=vertex, label="bacon")) for _i in range(0, random.randint(1, 5)): sdram_edge = SDRAMMachineEdge(vertex, vertices[random.randint(0, 99)], label="bacon", app_edge=None) sdram_edges.append(sdram_edge) graph.add_edge(sdram_edge, "Test") n_keys_map = DictBasedMachinePartitionNKeysMap() inputs = { "MemoryExtendedMachine": machine, "MemoryMachine": machine, "MemoryMachineGraph": graph, "PlanNTimeSteps": plan_n_timesteps, "MemoryMachinePartitionNKeysMap": n_keys_map } algorithms = [placer] xml_paths = [] executor = PACMANAlgorithmExecutor(algorithms, [], inputs, [], [], [], xml_paths) executor.execute_mapping() placements = executor.get_item("MemoryPlacements") for edge in sdram_edges: pre_place = placements.get_placement_of_vertex(edge.pre_vertex) post_place = placements.get_placement_of_vertex(edge.post_vertex) assert pre_place.x == post_place.x assert pre_place.y == post_place.y
def test_too_many_ip_tags_for_1_board(self): n_extra_vertices = 3 machine = virtual_machine(12, 12) eth_chips = machine.ethernet_connected_chips eth_chip = eth_chips[0] eth_chip_2 = machine.get_chip_at(eth_chip.x + 1, eth_chip.y + 1) eth_procs = [ proc.processor_id for proc in eth_chip.processors if not proc.is_monitor ] procs = [proc for proc in eth_chip_2.processors if not proc.is_monitor] eth2_procs = [proc.processor_id for proc in procs] proc = procs[-1] eth_vertices = [ SimpleMachineVertex(ResourceContainer( iptags=[IPtagResource("127.0.0.1", port=tag, strip_sdp=True)]), label="Ethernet Vertex {}".format(proc)) for tag in eth_chip.tag_ids ] eth2_vertices = [ SimpleMachineVertex(ResourceContainer(iptags=[ IPtagResource("127.0.0.1", port=10000 + tag, strip_sdp=True) ]), label="Ethernet 2 Vertex {}".format(proc)) for tag in range(n_extra_vertices) ] placements = Placements( Placement(vertex, eth_chip.x, eth_chip.y, proc) for proc, vertex in zip(eth_procs, eth_vertices)) placements.add_placements( Placement(vertex, eth_chip_2.x, eth_chip_2.y, proc) for proc, vertex in zip(eth2_procs, eth2_vertices)) allocator = BasicTagAllocator() _, _, tags = allocator(machine, plan_n_timesteps=None, placements=placements) tags_by_board = defaultdict(set) for vertices in (eth_vertices, eth2_vertices): for vertex in vertices: iptags = tags.get_ip_tags_for_vertex(vertex) self.assertEqual(len(iptags), 1, "Incorrect number of tags assigned") placement = placements.get_placement_of_vertex(vertex) print(placement, "has tag", iptags[0]) self.assertFalse( iptags[0].tag in tags_by_board[iptags[0].board_address], "Tag used more than once") tags_by_board[iptags[0].board_address].add(iptags[0].tag) self.assertEqual(len(tags_by_board[eth_chip.ip_address]), len(eth_chip.tag_ids), "Wrong number of tags assigned to first Ethernet")
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 _do_test(self, placer): machine = virtual_machine(width=8, height=8) graph = MachineGraph("Test") vertices = [ SimpleMachineVertex(ResourceContainer(), label="v{}".format(i)) for i in range(100) ] for vertex in vertices: graph.add_vertex(vertex) same_vertices = [ SimpleMachineVertex(ResourceContainer(), label="same{}".format(i)) for i in range(10) ] random.seed(12345) for vertex in same_vertices: graph.add_vertex(vertex) for _i in range(0, random.randint(1, 5)): vertex.add_constraint( SameChipAsConstraint(vertices[random.randint(0, 99)])) n_keys_map = DictBasedMachinePartitionNKeysMap() if placer == "ConnectiveBasedPlacer": placements = connective_based_placer(graph, machine, None) elif placer == "OneToOnePlacer": placements = one_to_one_placer(graph, machine, None) elif placer == "RadialPlacer": placements = radial_placer(graph, machine, None) elif placer == "SpreaderPlacer": placements = spreader_placer(graph, machine, n_keys_map, None) else: raise NotImplementedError(placer) for same in same_vertices: print("{0.vertex.label}, {0.x}, {0.y}, {0.p}: {1}".format( placements.get_placement_of_vertex(same), [ "{0.vertex.label}, {0.x}, {0.y}, {0.p}".format( placements.get_placement_of_vertex(constraint.vertex)) for constraint in same.constraints ])) placement = placements.get_placement_of_vertex(same) for constraint in same.constraints: if isinstance(constraint, SameChipAsConstraint): other_placement = placements.get_placement_of_vertex( constraint.vertex) self.assertTrue( other_placement.x == placement.x and other_placement.y == placement.y, "Vertex was not placed on the same chip as requested")
def _do_test(self, placer): machine = virtual_machine(width=8, height=8) graph = MachineGraph("Test") vertices = [ MockMachineVertex(ResourceContainer(), label="v{}".format(i), sdram_requirement=20) for i in range(100) ] for vertex in vertices: graph.add_vertex(vertex) same_vertices = [ MockMachineVertex(ResourceContainer(), label="same{}".format(i), sdram_requirement=20) for i in range(10) ] random.seed(12345) sdram_edges = list() for vertex in same_vertices: graph.add_vertex(vertex) graph.add_outgoing_edge_partition( ConstantSDRAMMachinePartition(identifier="Test", pre_vertex=vertex, label="bacon")) for _i in range(0, random.randint(1, 5)): sdram_edge = SDRAMMachineEdge(vertex, vertices[random.randint(0, 99)], label="bacon", app_edge=None) sdram_edges.append(sdram_edge) graph.add_edge(sdram_edge, "Test") n_keys_map = DictBasedMachinePartitionNKeysMap() if placer == "ConnectiveBasedPlacer": placements = connective_based_placer(graph, machine, None) elif placer == "OneToOnePlacer": placements = one_to_one_placer(graph, machine, None) elif placer == "RadialPlacer": placements = radial_placer(graph, machine, None) elif placer == "SpreaderPlacer": placements = spreader_placer(graph, machine, n_keys_map, None) else: raise NotImplementedError(placer) for edge in sdram_edges: pre_place = placements.get_placement_of_vertex(edge.pre_vertex) post_place = placements.get_placement_of_vertex(edge.post_vertex) assert pre_place.x == post_place.x assert pre_place.y == post_place.y
def resources_required(self): resources = ResourceContainer( sdram=ConstantSDRAM(SYSTEM_BYTES_REQUIREMENT + get_recording_header_size(len(Channels)) + self._string_data_size)) return resources
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_static_resources(input_filters, n_routing_keys, hostname, n_provenance_items): """ generates resource calculation so that it can eb called from outside and not instantiated :param input_filters: the input filters going into this vertex :param n_routing_keys: the n keys from the input filters :param hostname: The hostname of the host machine we're running on :param n_provenance_items: n provenance data items :return: A resource container containing the resources used by this vertex for those inputs. """ iptags = list() iptags.append( IPtagResource( ip_address=hostname, port=None, strip_sdp=False, tag=None, traffic_identifier=( SDPTransmitterMachineVertex.IPTAG_TRAFFIC_IDENTIFIER))) return ResourceContainer(sdram=SDRAMResource( fec_constants.SYSTEM_BYTES_REQUIREMENT + helpful_functions.sdram_size_in_bytes_for_filter_region( input_filters) + helpful_functions.sdram_size_in_bytes_for_routing_region( n_routing_keys) + ProvidesProvenanceDataFromMachineImpl.get_provenance_data_size( n_provenance_items) + SDPTransmitterMachineVertex._transmitter_region()), iptags=iptags)
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 resources_required(self): resources = ResourceContainer(sdram=ConstantSDRAM( SYSTEM_BYTES_REQUIREMENT + recording_utilities.get_recording_header_size(1) + self._string_data_size)) return resources
def test_ip_tags(self): machine = virtual_machine(12, 12) eth_chips = machine.ethernet_connected_chips vertices = [ SimpleMachineVertex(ResourceContainer( iptags=[IPtagResource("127.0.0.1", port=None, strip_sdp=True) ]), label="Vertex {}".format(i)) for i in range(len(eth_chips)) ] print("Created {} vertices".format(len(vertices))) placements = Placements( Placement(vertex, chip.x, chip.y, 1) for vertex, chip in zip(vertices, eth_chips)) allocator = BasicTagAllocator() _, _, tags = allocator(machine, plan_n_timesteps=None, placements=placements) for vertex, chip in zip(vertices, eth_chips): iptags = tags.get_ip_tags_for_vertex(vertex) self.assertEqual(len(iptags), 1, "Incorrect number of tags assigned") self.assertEqual(iptags[0].destination_x, chip.x, "Destination of tag incorrect") self.assertEqual(iptags[0].destination_y, chip.y, "Destination of tag incorrect") placement = placements.get_placement_of_vertex(vertex) print(placement, "has tag", iptags[0])
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 get_recording_resources( region_sizes, buffering_ip_address=None, buffering_port=None, notification_tag=None): """ Get the resources for recording :param region_sizes:\ A list of the sizes of each region. A size of 0 is acceptable to\ indicate an empty region :type region_sizes: list(int) :param buffering_ip_address:\ The IP address to receive buffering messages on, or None if buffering\ is not in use :type buffering_ip_address: str :param buffering_port:\ The port to receive buffering messages on, or None if a port is to be\ assigned :type buffering_port: int :param notification_tag:\ The tag to send buffering messages with, or None to use a default tag :type notification_tag: int :rtype: :py:class:`pacman.model.resources.ResourceContainer` """ ip_tags = list() if buffering_ip_address is not None: ip_tags.append(IPtagResource( buffering_ip_address, buffering_port, True, notification_tag, TRAFFIC_IDENTIFIER)) # return the resources including the SDRAM requirements return ResourceContainer( iptags=ip_tags, sdram=SDRAMResource( get_recording_header_size(len(region_sizes)) + get_recording_data_size(region_sizes)))
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 __init__(self, vertex_slice, resources_required, constraints, label, app_vertex, truth_table, input_sequence, rate_on, rate_off, score_delay, stochastic, incoming_spike_buffer_size, simulation_duration_ms, rand_seed): # resources required self._resources_required = ResourceContainer( sdram=ConstantSDRAM(resources_required)) # **NOTE** n_neurons currently ignored - width and height will be # specified as additional parameters, forcing their product to be # duplicated in n_neurons seems pointless self._label = label # Pass in variables self._truth_table = truth_table self._rate_on = rate_on self._rate_off = rate_off self._stochastic = stochastic self._input_sequence = input_sequence self._no_inputs = len(input_sequence) self._n_neurons = self._no_inputs self._rand_seed = rand_seed self._score_delay = score_delay # used to define size of recording region self._recording_size = int((simulation_duration_ms / 1000.) * 4) # Superclasses MachineVertex.__init__(self, label, constraints, app_vertex, vertex_slice)
def test_new_graph(self): """ tests that after building a machine graph, all partitined vertices and partitioned edges are in existence """ vertices = list() edges = list() for i in range(10): vertices.append( SimpleMachineVertex(ResourceContainer(), "V{}".format(i))) with self.assertRaises(NotImplementedError): vertices[1].add_constraint(SameAtomsAsVertexConstraint( vertices[4])) vertices[4].add_constraint(SameAtomsAsVertexConstraint( vertices[1])) for i in range(5): edges.append(MachineEdge(vertices[0], vertices[(i + 1)])) for i in range(5, 10): edges.append(MachineEdge(vertices[5], vertices[(i + 1) % 10])) graph = MachineGraph("foo") graph.add_vertices(vertices) graph.add_outgoing_edge_partition( MulticastEdgePartition(identifier="bar", pre_vertex=vertices[0])) graph.add_outgoing_edge_partition( MulticastEdgePartition(identifier="bar", pre_vertex=vertices[5])) graph.add_edges(edges, "bar") self.graph_there_and_back(graph)
def test_deallocation_of_resources(self): machine = virtual_machine(width=2, height=2, n_cpus_per_chip=18) chip_sdram = machine.get_chip_at(1, 1).sdram.size res_sdram = 12345 tracker = ResourceTracker(machine, plan_n_timesteps=None, preallocated_resources=None) sdram_res = ConstantSDRAM(res_sdram) resources = ResourceContainer(sdram=sdram_res) chip_0 = machine.get_chip_at(0, 0) # verify core tracker is empty if (0, 0) in tracker._core_tracker: raise Exception("shouldnt exist") tracker._get_core_tracker(1, 1) # verify core tracker not empty if (1, 1) not in tracker._core_tracker: raise Exception("should exist") # verify sdram tracker # 0, 0 in _sdram_tracker due to the get_core_tracker(0, 0) call if tracker._sdram_tracker[1, 1] != chip_sdram: raise Exception("incorrect sdram of {}".format( tracker._sdram_tracker[1, 1])) # allocate some res chip_x, chip_y, processor_id, ip_tags, reverse_ip_tags = \ tracker.allocate_resources(resources, [(0, 0)]) # verify chips used is updated cores = list(tracker._core_tracker[(0, 0)]._cores) self.assertEqual(len(cores), chip_0.n_user_processors - 1) # verify sdram used is updated sdram = tracker._sdram_tracker[(0, 0)] self.assertEqual(sdram, chip_sdram - res_sdram) if (0, 0) not in tracker._chips_used: raise Exception("should exist") # deallocate res tracker.unallocate_resources(chip_x, chip_y, processor_id, resources, ip_tags, reverse_ip_tags) # verify chips used is updated if tracker._core_tracker[(0, 0)].n_cores_available != \ chip_0.n_user_processors: raise Exception("shouldn't exist or should be right size") # if (0, 0) in tracker._chips_used: # raise Exception("shouldnt exist") # verify sdram tracker if tracker._sdram_tracker[0, 0] != chip_sdram: raise Exception("incorrect sdram of {}".format( tracker._sdram_tracker[0, 0]))
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 resources_required(self): resources = ResourceContainer( dtcm=DTCMResource(self.get_dtcm_usage()), sdram=SDRAMResource(self.get_sdram_usage( self._send_buffer_times, self._send_buffer_max_space, self._record_buffer_size > 0)), cpu_cycles=CPUCyclesPerTickResource(self.get_cpu_usage()), iptags=self._iptags, reverse_iptags=self._reverse_iptags) if self._iptags is None: resources.extend(get_recording_resources( [self._record_buffer_size], self._buffer_notification_ip_address, self._buffer_notification_port, self._buffer_notification_tag)) else: resources.extend(get_recording_resources( [self._record_buffer_size])) return resources