def _get_usable_chips(self, chips, board_address, ip_tags, reverse_ip_tags): """ Get all chips that are available on a board given the constraints :param chips: iterable of tuples of (x, y) coordinates of chips to \ look though for usable chips, or None to use all available\ chips :type chips: iterable of (int, int) :param board_address: the board address to check for usable chips on :type board_address: str or None :param ip_tags: list of ip tag constraints :type ip_tags: list of\ :py:class:`pacman.model.constraints.tag_allocator_constraints.tag_allocator_require_iptag_constraint.TagAllocatorRequireIptagConstraint` :param reverse_ip_tags: list of reverse ip tag constraints :type reverse_ip_tags: list of\ :py:class:`pacman.model.constraints.tag_allocator_constraints.tag_allocator_require_reverse_iptag_constraint.TagAllocatorRequireReverseIptagConstraint` :return: iterable of tuples of (x, y) coordinates of usable chips :rtype: iterable of tuple of (x, y) :raise PacmanInvalidParameterException: * If the board address is unknown * When either or both chip coordinates of any chip are none * When a non-existent chip is specified * When all the chips in the specified board have been used """ if chips is not None: chips_to_use = list() area_code = None if board_address is not None: if board_address not in self._ethernet_area_codes: raise exceptions.PacmanInvalidParameterException( "board_address", str(board_address), "Unrecognised board address") area_code = self._ethernet_area_codes[board_address] for (chip_x, chip_y) in chips: if ((chip_x is None and chip_y is not None) or (chip_x is not None and chip_y is None)): raise exceptions.PacmanInvalidParameterException( "chip_x and chip_y", "{} and {}".format(chip_x, chip_y), "Either both or neither must be None") elif self._machine.get_chip_at(chip_x, chip_y) is None: raise exceptions.PacmanInvalidParameterException( "chip_x and chip_y", "{} and {}".format(chip_x, chip_y), "No such chip was found in the machine") elif ((chip_x, chip_y) in self._chips_available and (area_code is None or (chip_x, chip_y) in area_code)): chips_to_use.append((chip_x, chip_y)) if len(chips_to_use) == 0: raise exceptions.PacmanInvalidParameterException( "chips and board_address", "{} and {}".format(chips, board_address), "No valid chips found on the specified board") return chips_to_use elif board_address is not None: return self._ethernet_area_codes[board_address] elif ((ip_tags is not None and len(ip_tags) > 0) or (reverse_ip_tags is not None and len(reverse_ip_tags) > 0)): return self._get_usable_ip_tag_chips() return self._chips_available
def _check_masks_are_correct(partition): """ Check that the masks between a fixed mask constraint\ and a fixed_field constraint. completes if its correct, raises error\ otherwise :param partition: the outgoing_edge_partition to search for these\ constraints :return: """ fixed_mask = utility_calls.locate_constraints_of_type( partition.constraints, KeyAllocatorFixedMaskConstraint)[0] fixed_field = utility_calls.locate_constraints_of_type( partition.constraints, KeyAllocatorFixedFieldConstraint)[0] mask = fixed_mask.mask for field in fixed_field.fields: if field.mask & mask != field.mask: raise exceptions.PacmanInvalidParameterException( "field.mask, mask", "The field mask {} is outside of the mask {}".format( field.mask, mask), "{}:{}".format(field.mask, mask)) for other_field in fixed_field.fields: if (other_field != field and other_field.mask & field.mask != 0): raise exceptions.PacmanInvalidParameterException( "field.mask, mask", "Field masks {} and {} overlap".format( field.mask, other_field.mask), "{}:{}".format(field.mask, mask))
def merge_entry(self, other): """ Merges the another entry with this one and returns a new\ MulticastRoutingTableByPartitionEntry :param other: the MulticastRoutingTableByPartitionEntry to merge into\ this one :return: a merged MulticastRoutingTableByPartitionEntry """ if not isinstance(other, MulticastRoutingTableByPartitionEntry): raise exceptions.PacmanInvalidParameterException( "other", "type error", "The other parameter is not a instance of " "MulticastRoutingTableByPartitionEntry, and therefore cannot " "be merged.") else: # validate fixed things if (self._incoming_processor is None and other.incoming_processor is None): valid_incoming_processor = None elif (self._incoming_processor is not None and other._incoming_processor is None): valid_incoming_processor = self._incoming_processor elif (self._incoming_processor is None and other.incoming_processor is not None): valid_incoming_processor = other.incoming_processor elif self._incoming_processor == other._incoming_processor: valid_incoming_processor = self._incoming_processor else: raise exceptions.PacmanInvalidParameterException( "incoming_processor", "invalid merge", "The two MulticastRoutingTableByPartitionEntry have " "different incoming_processors, and so can't be merged") if (self._incoming_link is None and other.incoming_link is None): valid_incoming_link = None elif (self._incoming_link is not None and other._incoming_link is None): valid_incoming_link = self._incoming_link elif (self._incoming_link is None and other.incoming_link is not None): valid_incoming_link = other.incoming_link elif self._incoming_link == other._incoming_link: valid_incoming_link = self._incoming_link else: raise exceptions.PacmanInvalidParameterException( "incoming_link", "invalid merge", "The two MulticastRoutingTableByPartitionEntry have " "different incoming_links, and so can't be merged") # merge merge-able things merged_outgoing_processors = self._out_going_processors.union( other._out_going_processors) merged_outgoing_links = self._out_going_links.union( other._out_going_links) return MulticastRoutingTableByPartitionEntry( merged_outgoing_links, merged_outgoing_processors, valid_incoming_processor, valid_incoming_link)
def __init__(self, out_going_links, outgoing_processors, incoming_processor=None, incoming_link=None): """ :param out_going_links: the edges this path entry goes down :type out_going_links: iterable of ints between 0 and 5 :param outgoing_processors: the processors this path entry goes to :type outgoing_processors: iterable of ints between 0 and 17 :param incoming_processor: the direction this entry came from :type incoming_processor: int between 0 and 17 :param incoming_link: the direction this entry came from in link :type incoming_link: int between 0 and 5 :return: """ if isinstance(out_going_links, int): self._out_going_links = set() self._out_going_links.add(out_going_links) else: if out_going_links is not None: self._out_going_links = set(out_going_links) else: self._out_going_links = set() if isinstance(outgoing_processors, int): self._out_going_processors = set() self._out_going_processors.add(outgoing_processors) else: if outgoing_processors is not None: self._out_going_processors = set(outgoing_processors) else: self._out_going_processors = set() self._incoming_link = incoming_link self._incoming_processor = incoming_processor if (self._incoming_link is not None and self._incoming_processor is not None): raise exceptions.PacmanInvalidParameterException( "The incoming direction for a path can only be from either " "one link or one processors, not both", str(self._incoming_link), str(self._incoming_processor)) if (self._incoming_link is not None and not isinstance(self._incoming_link, int)): raise exceptions.PacmanInvalidParameterException( "The incoming direction for a path can only be from either " "one link or one processors, not both", str(self._incoming_link), str(self._incoming_processor))
def add_subvertex(self, subvertex): """ Add a subvertex to this partitioned_graph :param subvertex: a subvertex to be added to the partitioned graph :type subvertex:\ :py:class:`pacman.model.partitioned_graph.partitioned_vertex.PartitionedVertex` :return: None :rtype: None :raise pacman.exceptions.PacmanInvalidParameterException: If the\ subvertex is not valid """ if not isinstance(subvertex, PartitionedVertex): raise exceptions.PacmanInvalidParameterException( "subvertex", str(subvertex), "This vertex is not a partitioned vertex, yet you are trying " "to add it to a partitioned graph.") if subvertex not in self._subvertices: self._subvertices.add(subvertex) else: raise exceptions.PacmanAlreadyExistsException( "PartitionedVertex", str(subvertex)) self._outgoing_subedges[subvertex] = dict() self._incoming_subedges[subvertex] = list() # update id mapping self._subvertex_by_id[str(id(subvertex))] = subvertex
def create_subedge(self, pre_subvertex, post_subvertex, label=None): """ Create a partitioned multicast edge :param pre_subvertex: the source partitioned vertex :param post_subvertex: the destination partitioned vertex :param label: the label of this partitioned edge :return: """ if not isinstance(pre_subvertex, PartitionedVertex): raise exceptions.PacmanInvalidParameterException( "pre_subvertex", str(pre_subvertex), "Must be a PartitionedVertex") if not isinstance(post_subvertex, PartitionedVertex): raise exceptions.PacmanInvalidParameterException( "post_subvertex", str(post_subvertex), "PartitionedVertex") if label is None and self.label is not None: label = self.label return MultiCastPartitionedEdge(pre_subvertex, post_subvertex, label)
def create_subedge(self, pre_subvertex, post_subvertex, label=None): """ Create a fixed route partitioned edge :param pre_subvertex: the source subvertex :param post_subvertex: the destination partitioned subvertex :param label: the label associated with the partitioned edge :param constraints: any constraints needed for the partitioned edge :return: the FixedRoutePartitionedEdge """ if not isinstance(pre_subvertex, PartitionedVertex): raise exceptions.PacmanInvalidParameterException( "pre_subvertex", str(pre_subvertex), "Must be a PartitionedVertex") if not isinstance(post_subvertex, PartitionedVertex): raise exceptions.PacmanInvalidParameterException( "post_subvertex", str(post_subvertex), "Must be a PartitionedVertex") if label is None and self.label is not None: label = self.label return FixedRoutePartitionedEdge(pre_subvertex, post_subvertex, label)
def add_subedge(self, subedge, partition_id=None, partition_constraints=None): """ Add a subedge to this partitioned_graph :param subedge: a subedge to be added to the partitioned_graph :type subedge:\ :py:class:`pacman.model.partitioned_graph.abstract_partitioned_edge.AbstractPartitionedEdge` :param partition_id: the id for the outgoing partition that this edge\ is associated with :type partition_id: str :param partition_constraints: list of constraints to put onto the\ partition :type partition_constraints: iterable of :py:class:`pacman.model.constraints.abstract_constraints.abstract_constraint.AbstractConstraint` :return: None :rtype: None :raise pacman.exceptions.PacmanInvalidParameterException: If the\ subedge is not valid """ if not isinstance(subedge, AbstractPartitionedEdge): exceptions.PacmanInvalidParameterException( "subedge", str(subedge), "subedge must be a instance of a abstractPartitionedEdge.") if subedge in self._subedges: raise exceptions.PacmanAlreadyExistsException( "FixedRoutePartitionableEdge", str(subedge)) self._subedges.add(subedge) # if the partition id is none, make a unique one for storage if partition_id is None: partition_id = str(uuid.uuid4()) if subedge.pre_subvertex in self._outgoing_subedges: # if this partition id not been seen before, add a new partition if (partition_id not in self._outgoing_subedges[subedge.pre_subvertex]): partition = OutgoingEdgePartition(partition_id, partition_constraints) self._outgoing_subedges[subedge.pre_subvertex][partition_id] =\ partition self._partition_by_id[str(id(partition))] = partition self._outgoing_subedges[subedge.pre_subvertex][partition_id]\ .add_edge(subedge) self._subedge_to_partition[subedge] = \ self._outgoing_subedges[subedge.pre_subvertex][partition_id] else: raise exceptions.PacmanInvalidParameterException( "FixedRoutePartitionableEdge pre_subvertex", str(subedge.pre_subvertex), " Must exist in the partitioned_graph") if subedge.post_subvertex in self._incoming_subedges: self._incoming_subedges[subedge.post_subvertex].append(subedge) else: raise exceptions.PacmanInvalidParameterException( "FixedRoutePartitionableEdge post_subvertex", str(subedge.post_subvertex), " Must exist in the partitioned_graph")