def __call__(self, machine_graph, machine, plan_n_timesteps): """ Place a machine_graph so that each vertex is placed on a core :param machine_graph: The machine_graph to place :type machine_graph:\ :py:class:`pacman.model.graphs.machine.MachineGraph` :param machine:\ The machine with respect to which to partition the application\ graph :type machine: :py:class:`spinn_machine.Machine` :param plan_n_timesteps: number of timesteps to plan for :type plan_n_timesteps: int :return: A set of placements :rtype: :py:class:`pacman.model.placements.Placements` :raise pacman.exceptions.PacmanPlaceException: \ If something goes wrong with the placement """ # check that the algorithm can handle the constraints ResourceTracker.check_constraints(machine_graph.vertices) placements = Placements() vertices = sort_vertices_by_known_constraints(machine_graph.vertices) # Iterate over vertices and generate placements progress = ProgressBar(vertices, "Placing graph vertices") resource_tracker = ResourceTracker(machine, plan_n_timesteps) for vertex in progress.over(vertices): # Create and store a new placement anywhere on the board (x, y, p, _, _) = resource_tracker.allocate_constrained_resources( vertex.resources_required, vertex.constraints, None) placement = Placement(vertex, x, y, p) placements.add_placement(placement) return placements
def __call__(self, machine_graph, machine, plan_n_timesteps): """ Place each vertex in a machine graph on a core in the machine. :param MachineGraph machine_graph: The machine_graph to place :param ~spinn_machine.Machine machine: A SpiNNaker machine object. :param int plan_n_timesteps: number of timesteps to plan for :return placements: Placements of vertices on the machine :rtype: Placements """ # check that the algorithm can handle the constraints ResourceTracker.check_constraints(machine_graph.vertices) placements = Placements() vertices = sort_vertices_by_known_constraints(machine_graph.vertices) # Iterate over vertices and generate placements progress = ProgressBar(machine_graph.n_vertices, "Placing graph vertices") resource_tracker = ResourceTracker( machine, plan_n_timesteps, self._generate_random_chips(machine)) vertices_on_same_chip = get_same_chip_vertex_groups(machine_graph) vertices_placed = set() for vertex in progress.over(vertices): if vertex not in vertices_placed: vertices_placed.update( self._place_vertex(vertex, resource_tracker, machine, placements, vertices_on_same_chip)) return placements
def __call__(self, machine_graph, machine): """ Place a machine_graph so that each vertex is placed on a core :param machine_graph: The machine_graph to place :type machine_graph:\ :py:class:`pacman.model.graphs.machine.MachineGraph` :return: A set of placements :rtype: :py:class:`pacman.model.placements.Placements` :raise pacman.exceptions.PacmanPlaceException: \ If something goes wrong with the placement """ # check that the algorithm can handle the constraints ResourceTracker.check_constraints(machine_graph.vertices) placements = Placements() vertices = sort_vertices_by_known_constraints(machine_graph.vertices) # Iterate over vertices and generate placements progress = ProgressBar(vertices, "Placing graph vertices") resource_tracker = ResourceTracker(machine) for vertex in progress.over(vertices): # Create and store a new placement anywhere on the board (x, y, p, _, _) = resource_tracker.allocate_constrained_resources( vertex.resources_required, vertex.constraints, None) placement = Placement(vertex, x, y, p) placements.add_placement(placement) return placements
def __call__(self, machine_graph, machine, plan_n_timesteps): """ Place each vertex in a machine graph on a core in the machine. :param machine_graph: The machine_graph to place :type machine_graph:\ :py:class:`pacman.model.graphs.machine.MachineGraph` :param machine: A SpiNNaker machine object. :type machine: :py:class:`spinn_machine.Machine` :param plan_n_timesteps: number of timesteps to plan for :type plan_n_timesteps: int :return placements: Placements of vertices on the machine :rtype :py:class:`pacman.model.placements.Placements` """ # check that the algorithm can handle the constraints ResourceTracker.check_constraints(machine_graph.vertices) placements = Placements() vertices = sort_vertices_by_known_constraints(machine_graph.vertices) # Iterate over vertices and generate placements progress = ProgressBar(machine_graph.n_vertices, "Placing graph vertices") resource_tracker = ResourceTracker( machine, plan_n_timesteps, self._generate_random_chips(machine)) vertices_on_same_chip = get_same_chip_vertex_groups(machine_graph) vertices_placed = set() for vertex in progress.over(vertices): if vertex not in vertices_placed: vertices_placed.update(self._place_vertex( vertex, resource_tracker, machine, placements, vertices_on_same_chip)) return placements
def _check_constraints( self, vertices, additional_placement_constraints=None): placement_constraints = { RadialPlacementFromChipConstraint, SameChipAsConstraint } if additional_placement_constraints is not None: placement_constraints.update(additional_placement_constraints) ResourceTracker.check_constraints( vertices, additional_placement_constraints=placement_constraints)
def _check_constraints(self, vertices, additional_placement_constraints=None): if additional_placement_constraints is not None: placement_constraints = additional_placement_constraints else: placement_constraints = {} ResourceTracker.check_constraints( vertices, additional_placement_constraints=placement_constraints)
def __gather_placements_with_tags(placement, collector): """ :param Placement placement: :param list(Placement) collector: """ requires = placement.vertex.resources_required if requires.iptags or requires.reverse_iptags: ResourceTracker.check_constraints([placement.vertex]) collector.append(placement)
def _check_constraints(self, vertices, additional_placement_constraints=None): placement_constraints = { RadialPlacementFromChipConstraint, SameChipAsConstraint } if additional_placement_constraints is not None: placement_constraints.update(additional_placement_constraints) ResourceTracker.check_constraints( vertices, additional_placement_constraints=placement_constraints)
def _check_constraints( self, vertices, additional_placement_constraints=None): """ Ensure that the algorithm conforms to any required constraints. :param list(AbstractVertex) vertices: The vertices for which to check the constraints :param set(AbstractPlacerConstraint) additional_placement_constraints: Additional placement constraints supported by the algorithm doing this check """ placement_constraints = {SameChipAsConstraint} if additional_placement_constraints is not None: placement_constraints.update(additional_placement_constraints) ResourceTracker.check_constraints( vertices, additional_placement_constraints=placement_constraints)
def __call__(self, app_graph, machine, plan_n_time_steps, pre_allocated_resources=None): """ :param ApplicationGraph app_graph: The application_graph to partition :param ~spinn_machine.Machine machine: The machine with respect to which to partition the application graph :param plan_n_time_steps: the number of time steps to plan to run for :type plan_n_time_steps: int or None :param pre_allocated_resources: res needed to be preallocated before making new machine vertices :type pre_allocated_resources: PreAllocatedResourceContainer or None :return: A machine_graph of partitioned vertices and partitioned edges, and the number of chips needed to satisfy this partitioning. :rtype: tuple(MachineGraph, int) :raise PacmanPartitionException: If something goes wrong with the partitioning """ # check resource tracker can handle constraints ResourceTracker.check_constraints(app_graph.vertices) # get the setup objects (machine_graph, resource_tracker, vertices, progress) = (self.__setup_objects(app_graph, machine, plan_n_time_steps, pre_allocated_resources)) self.__set_max_atoms_to_splitters(app_graph) # Partition one vertex at a time for vertex in progress.over(vertices): vertex.splitter.split(resource_tracker, machine_graph) # process edges self.__process_machine_edges(app_graph, machine_graph, resource_tracker) # return the accepted things return machine_graph, resource_tracker.chips_used
def _check_constraints( self, vertices, additional_placement_constraints=None): """ Ensure that the algorithm conforms to any required constraints. :param vertices: The vertices for which to check the constraints :type vertices: dict() :param additional_placement_constraints:\ Additional placement constraints supported by the algorithm doing\ this check :type additional_placement_constraints: set of \ :py:class:`pacman.model.constraints.placer_constraints.AbstractPlacerConstraint` """ placement_constraints = {SameChipAsConstraint} if additional_placement_constraints is not None: placement_constraints.update(additional_placement_constraints) ResourceTracker.check_constraints( vertices, additional_placement_constraints=placement_constraints)
def __call__(self, machine_graph, machine): # check that the algorithm can handle the constraints ResourceTracker.check_constraints(machine_graph.vertices) placements = Placements() vertices = sort_vertices_by_known_constraints(machine_graph.vertices) # Iterate over vertices and generate placements progress = ProgressBar(machine_graph.n_vertices, "Placing graph vertices") resource_tracker = ResourceTracker( machine, self._generate_random_chips(machine)) vertices_on_same_chip = get_same_chip_vertex_groups(machine_graph) vertices_placed = set() for vertex in progress.over(vertices): if vertex not in vertices_placed: vertices_placed.update( self._place_vertex(vertex, resource_tracker, machine, placements, vertices_on_same_chip)) return placements
def __call__(self, machine_graph, machine): """ :param machine_graph: The machine_graph to measure :type machine_graph:\ :py:class:`pacman.model.graph.machine.MachineGraph` :return: The size of the graph in number of chips :rtype: int """ # check that the algorithm can handle the constraints ResourceTracker.check_constraints(machine_graph.vertices) ordered_vertices = sort_vertices_by_known_constraints( machine_graph.vertices) # Iterate over vertices and allocate progress = ProgressBar(machine_graph.n_vertices, "Measuring the graph") resource_tracker = ResourceTracker(machine) for vertex in progress.over(ordered_vertices): resource_tracker.allocate_constrained_resources( vertex.resources_required, vertex.constraints) return len(resource_tracker.keys)
def __call__(self, machine_graph, machine): """ :param machine_graph: The machine_graph to measure :type machine_graph:\ :py:class:`pacman.model.graph.machine.MachineGraph` :return: The size of the graph in number of chips :rtype: int """ # check that the algorithm can handle the constraints ResourceTracker.check_constraints(machine_graph.vertices) ordered_vertices = sort_vertices_by_known_constraints( machine_graph.vertices) # Iterate over vertices and allocate progress = ProgressBar(machine_graph.n_vertices, "Measuring the graph") resource_tracker = ResourceTracker(machine) for vertex in progress.over(ordered_vertices): resource_tracker.allocate_constrained_resources( vertex.resources_required, vertex.constraints) return len(resource_tracker.keys)
def __call__(self, graph, machine, plan_n_timesteps): """ :param graph: The application_graph to partition :type graph:\ :py:class:`pacman.model.graphs.application.ApplicationGraph` :param machine:\ The machine with respect to which to partition the application\ graph :type machine: :py:class:`spinn_machine.Machine` :param plan_n_timesteps: number of timesteps to plan for :type plan_n_timesteps: int :return: A machine graph :rtype:\ :py:class:`pacman.model.graphs.machine.MachineGraph` :raise pacman.exceptions.PacmanPartitionException:\ If something goes wrong with the partitioning """ ResourceTracker.check_constraints(graph.vertices) utility_calls.check_algorithm_can_support_constraints( constrained_vertices=graph.vertices, supported_constraints=[ MaxVertexAtomsConstraint, FixedVertexAtomsConstraint], abstract_constraint_type=AbstractPartitionerConstraint) # start progress bar progress = ProgressBar(graph.n_vertices, "Partitioning graph vertices") machine_graph = MachineGraph("Machine graph for " + graph.label) graph_mapper = GraphMapper() resource_tracker = ResourceTracker(machine, plan_n_timesteps) # Partition one vertex at a time for vertex in progress.over(graph.vertices): self._partition_one_application_vertex( vertex, resource_tracker, machine_graph, graph_mapper, plan_n_timesteps) generate_machine_edges(machine_graph, graph_mapper, graph) return machine_graph, graph_mapper, resource_tracker.chips_used
def __call__(self, machine_graph, machine, plan_n_timesteps): """ :param ~.MachineGraph machine_graph: :param ~.Machine machine: :param int plan_n_timesteps: :rtype: int """ # check that the algorithm can handle the constraints ResourceTracker.check_constraints(machine_graph.vertices) ordered_vertices = sort_vertices_by_known_constraints( machine_graph.vertices) # Iterate over vertices and allocate progress = ProgressBar(machine_graph.n_vertices, "Measuring the graph") resource_tracker = ResourceTracker(machine, plan_n_timesteps) for vertex in progress.over(ordered_vertices): resource_tracker.allocate_constrained_resources( vertex.resources_required, vertex.constraints) return len(resource_tracker.keys)
def __call__(self, graph, machine): """ :param graph: The application_graph to partition :type graph:\ :py:class:`pacman.model.graphs.application.ApplicationGraph` :param machine:\ The machine with respect to which to partition the application\ graph :type machine: :py:class:`spinn_machine.Machine` :return: A machine graph :rtype:\ :py:class:`pacman.model.graphs.machine.MachineGraph` :raise pacman.exceptions.PacmanPartitionException:\ If something goes wrong with the partitioning """ ResourceTracker.check_constraints(graph.vertices) utility_calls.check_algorithm_can_support_constraints( constrained_vertices=graph.vertices, supported_constraints=[ MaxVertexAtomsConstraint, FixedVertexAtomsConstraint ], abstract_constraint_type=AbstractPartitionerConstraint) # start progress bar progress = ProgressBar(graph.n_vertices, "Partitioning graph vertices") machine_graph = MachineGraph("Machine graph for " + graph.label) graph_mapper = GraphMapper() resource_tracker = ResourceTracker(machine) # Partition one vertex at a time for vertex in progress.over(graph.vertices): self._partition_one_application_vertex(vertex, resource_tracker, machine_graph, graph_mapper) utils.generate_machine_edges(machine_graph, graph_mapper, graph) return machine_graph, graph_mapper, resource_tracker.chips_used
def __call__( self, graph, machine, plan_n_timesteps, preallocated_resources=None): """ :param graph: The application_graph to partition :type graph:\ :py:class:`pacman.model.graph.application.ApplicationGraph` :param machine: The machine with respect to which to partition the\ application_graph :type machine: :py:class:`spinn_machine.Machine` :param plan_n_timesteps: number of timesteps to plan for :type plan_n_timesteps: int :return: \ A machine_graph of partitioned vertices and partitioned edges :rtype:\ :py:class:`pacman.model.graph.machine.MachineGraph` :raise pacman.exceptions.PacmanPartitionException: \ If something goes wrong with the partitioning """ ResourceTracker.check_constraints(graph.vertices) utils.check_algorithm_can_support_constraints( constrained_vertices=graph.vertices, abstract_constraint_type=AbstractPartitionerConstraint, supported_constraints=[MaxVertexAtomsConstraint, SameAtomsAsVertexConstraint, FixedVertexAtomsConstraint]) # Load the vertices and create the machine_graph to fill machine_graph = MachineGraph( label="partitioned graph for {}".format(graph.label)) graph_mapper = GraphMapper() # sort out vertex's by placement constraints vertices = sort_vertices_by_known_constraints(graph.vertices) # Set up the progress n_atoms = 0 for vertex in vertices: n_atoms += vertex.n_atoms progress = ProgressBar(n_atoms, "Partitioning graph vertices") resource_tracker = ResourceTracker( machine, plan_n_timesteps, preallocated_resources=preallocated_resources) # Group vertices that are supposed to be the same size vertex_groups = get_same_size_vertex_groups(vertices) # Partition one vertex at a time for vertex in vertices: # check that the vertex hasn't already been partitioned machine_vertices = graph_mapper.get_machine_vertices(vertex) # if not, partition if machine_vertices is None: self._partition_vertex( vertex, plan_n_timesteps, machine_graph, graph_mapper, resource_tracker, progress, vertex_groups) progress.end() generate_machine_edges(machine_graph, graph_mapper, graph) return machine_graph, graph_mapper, resource_tracker.chips_used
def __call__(self, graph, machine, preallocated_resources=None): """ :param graph: The application_graph to partition :type graph:\ :py:class:`pacman.model.graph.application.ApplicationGraph` :param machine: The machine with respect to which to partition the\ application_graph :type machine: :py:class:`spinn_machine.Machine` :return: \ A machine_graph of partitioned vertices and partitioned edges :rtype:\ :py:class:`pacman.model.graph.machine.MachineGraph` :raise pacman.exceptions.PacmanPartitionException: \ If something goes wrong with the partitioning """ ResourceTracker.check_constraints(graph.vertices) utils.check_algorithm_can_support_constraints( constrained_vertices=graph.vertices, abstract_constraint_type=AbstractPartitionerConstraint, supported_constraints=[MaxVertexAtomsConstraint, SameAtomsAsVertexConstraint, FixedVertexAtomsConstraint]) # Load the vertices and create the machine_graph to fill machine_graph = MachineGraph( label="partitioned graph for {}".format(graph.label)) graph_mapper = GraphMapper() # sort out vertex's by placement constraints vertices = placer_utils.sort_vertices_by_known_constraints( graph.vertices) # Set up the progress n_atoms = 0 for vertex in vertices: n_atoms += vertex.n_atoms progress = ProgressBar(n_atoms, "Partitioning graph vertices") resource_tracker = ResourceTracker( machine, preallocated_resources=preallocated_resources) # Group vertices that are supposed to be the same size vertex_groups = partition_utils.get_same_size_vertex_groups(vertices) # Partition one vertex at a time for vertex in vertices: # check that the vertex hasn't already been partitioned machine_vertices = graph_mapper.get_machine_vertices(vertex) # if not, partition if machine_vertices is None: self._partition_vertex( vertex, machine_graph, graph_mapper, resource_tracker, progress, vertex_groups) progress.end() partition_utils.generate_machine_edges( machine_graph, graph_mapper, graph) return machine_graph, graph_mapper, resource_tracker.chips_used
def _gather_placements_with_tags(self, placement, collector): if (placement.vertex.resources_required.iptags or placement.vertex.resources_required.reverse_iptags): ResourceTracker.check_constraints([placement.vertex]) collector.append(placement)
def _gather_placements_with_tags(self, placement, collector): if (placement.vertex.resources_required.iptags or placement.vertex.resources_required.reverse_iptags): ResourceTracker.check_constraints([placement.vertex]) collector.append(placement)