def test_cleanup(self): # Make sure that if a child is freed cleanup only occurs when empty # +----+----+ # | | | # +----+ | # | | | # +----+----+ p = PackTree(0, 0, 10, 10) p.vsplit(x=5) p.children[0].hsplit(y=5) p.children[0].children[0].allocated = True p.children[0].children[1].allocated = True p.children[1].allocated = True # If we free one of the grandchildren the tree should remain unchanged p.free(0, 0) assert p.children is not None assert p.children[0].children is not None assert p.children[0].children[0].children is None assert p.children[0].children[1].children is None assert p.children[1].children is None # If we free a top level child the tree should remain unchanged p.free(5, 0) assert p.children is not None assert p.children[0].children is not None assert p.children[0].children[0].children is None assert p.children[0].children[1].children is None assert p.children[1].children is None # If we free the remaining grandchild the whole tree should collapse p.free(0, 5) assert p.children is None
def test_request_everything(self): # Should be able to request every point individually, in a random # order, and get them. w, h = 10, 20 p = PackTree(0, 0, w, h) locations = [(x, y) for x in range(w) for y in range(h)] random.shuffle(locations) # Request every point in some order for x, y in locations: # Should not be able to do this more than once... assert p.request(x, y) == (x, y) assert p.request(x, y) is None # After allocating everything, no spaces should remain assert p.alloc(1, 1) is None # After freeing everything, we should have a full square random.shuffle(locations) for x, y in locations: p.free(x, y) assert p.allocated is False assert p.children is None
def test_exact_match(self, candidate_filter): p = PackTree(1, 2, 3, 4) assert p.alloc(3, 4, candidate_filter) == (1, 2) assert p.allocated is True assert p.children is None if candidate_filter is not None: candidate_filter.assert_called_once_with(1, 2, 3, 4)
def test_smallest_child_first(self): p = PackTree(0, 0, 3, 1) p.vsplit(1) assert p.alloc_area(1) == (0, 0, 1, 1) p = PackTree(0, 0, 3, 1) p.vsplit(2) assert p.alloc_area(1) == (2, 0, 1, 1)
def test_exact_match_blocked(self): # If a candidate filter blocks the only match, we should fail p = PackTree(1, 2, 3, 4) candidate_filter = Mock(return_value=False) assert p.alloc(3, 4, candidate_filter) is None assert p.allocated is False assert p.children is None candidate_filter.assert_called_once_with(1, 2, 3, 4)
def test_already_allocated(self): # Should fail if already allocated p = PackTree(1, 2, 3, 4) p.allocated = True assert p.request(1, 2) is None assert p.request(2, 3) is None # No dividing should have occurred... assert p.children is None
def test_candidate_filter(self): p = PackTree(0, 0, 2, 1) p.vsplit(1) cf = Mock(side_effect=[False, True]) assert p.alloc_area(1, 0.0, cf) == (1, 0, 1, 1) assert cf.mock_calls == [ call(0, 0, 1, 1), call(1, 0, 1, 1), ]
def test_try_children(self): # Try inserting into the children, try the smallest chlid first p = PackTree(0, 0, 3, 1) p.vsplit(x=2) assert p.alloc(1, 1) == (2, 0) assert p.allocated is False assert p.children[0].allocated is False assert p.children[1].allocated is True
def test_vsplit(): p = PackTree(1, 2, 3, 4) p.vsplit(x=3) assert p.children[0].x == 1 assert p.children[0].y == 2 assert p.children[0].width == 2 assert p.children[0].height == 4 assert p.children[1].x == 3 assert p.children[1].y == 2 assert p.children[1].width == 1 assert p.children[1].height == 4
def test_fit_top(self): # If we can fit exactly by splitting and putting on the top, we should # do so. p = PackTree(1, 2, 3, 4) candidate_filter = Mock(side_effect=[False, True]) assert p.alloc(3, 1, candidate_filter) == (1, 5) assert p.allocated is False assert p.children is not None assert p.children[0].width == 3 assert p.children[0].height == 3 assert p.children[0].allocated is False assert p.children[1].width == 3 assert p.children[1].height == 1 assert p.children[1].allocated is True
def test_fit_bottom(self, candidate_filter): # If we can fit exactly by splitting and putting on the bottom, we # should do so. p = PackTree(1, 2, 3, 4) assert p.alloc(3, 1, candidate_filter) == (1, 2) assert p.allocated is False assert p.children is not None assert p.children[0].width == 3 assert p.children[0].height == 1 assert p.children[0].allocated is True assert p.children[1].width == 3 assert p.children[1].height == 3 assert p.children[1].allocated is False if candidate_filter is not None: candidate_filter.assert_called_once_with(1, 2, 3, 1)
def test_right_gap_only(self): p = PackTree(1, 2, 3, 1) assert p.request(1, 2) == (1, 2) assert p.allocated is False assert p.children is not None assert p.children[0].allocated is True assert p.children[0].width == 1 assert p.children[0].height == 1 assert p.children[0].children is None assert p.children[1].allocated is False assert p.children[1].width == 2 assert p.children[1].height == 1 assert p.children[1].children is None
def test_below_gap_only(self): p = PackTree(1, 2, 1, 4) assert p.request(1, 5) == (1, 5) assert p.allocated is False assert p.children is not None assert p.children[0].allocated is False assert p.children[0].width == 1 assert p.children[0].height == 3 assert p.children[0].children is None assert p.children[1].allocated is True assert p.children[1].width == 1 assert p.children[1].height == 1 assert p.children[1].children is None
def test_try_children(self): p = PackTree(1, 2, 2, 1) p.vsplit(x=2) assert p.request(1, 2) == (1, 2) assert p.allocated is False assert p.children is not None assert p.children[0].allocated is True assert p.children[0].children is None assert p.children[1].allocated is False assert p.children[1].children is None assert p.request(2, 2) == (2, 2) assert p.allocated is False assert p.children is not None assert p.children[0].allocated is True assert p.children[0].children is None assert p.children[1].allocated is True assert p.children[1].children is None
def test_constructor(): p = PackTree(1, 2, 3, 4) # Arguments should be kept assert p.x == 1 assert p.y == 2 assert p.width == 3 assert p.height == 4 # Default internal state should be set assert p.allocated is False assert p.children is None
def __init__(self, width, height, dead_boards=None, dead_links=None, next_id=1): """ Parameters ---------- width, height : int Dimensions of the machine in triads. dead_boards : set([(x, y, z), ...]) The set of boards which are dead and which must not be allocated. dead_links : set([(x, y, z, :py:class:`rig.links.Links`), ...]) The set of links leaving boards which are known not to be working. Connections to boards in the set dead_boards are assumed to be dead and need not be included in this list. Note that both link directions must be flagged as dead (if the link is bidirectionally down). next_id : int The ID of the next allocation to be made. """ self.width = width self.height = height self.dead_boards = dead_boards if dead_boards is not None else set() self.dead_links = dead_links if dead_links is not None else set() # Unique IDs are assigned to every new allocation. The next ID to be # allocated. self.next_id = next_id # A 2D tree at the granularity of triads used for board allocation. self.pack_tree = PackTree(0, 0, width, height) # Provides a lookup from (live) allocation IDs to the type of # allocation. self.allocation_types = {} # Lookup from allocation IDs to the bottom-left board in the allocation self.allocation_board = {} # Since we cannot allocate individual boards in the pack_tree, whenever # an individual board is requested a whole triad may be allocated and # one of the boards from the triad returned. This dictionary records # what triads have been allocated like this and which boards are # unused. These may then be used for future single-board allocations # rather than allocating another whole triad. # A dictionary containing any triads used for allocating individual # boards which still have some free and working boards. # {(x, y): [z, ...], ...} self.single_board_triads = {} # When all the boards in a triad in single_board_triads are used up the # triad is removed from that dictionary and placed into the set below. self.full_single_board_triads = set()
def test_alloc_perfect_pack(self, w, h): # Should be able to allocate lots of the same sized block which have a # trivial perfect packing. W, H = 10, 20 p = PackTree(0, 0, W, H) allocations = set() for _ in range((W * H) // (w * h)): allocation = p.alloc(w, h) assert allocation is not None assert allocation not in allocations allocations.add(allocation) # After allocating everything, no more should fit assert p.alloc(w, h) is None # After freeing everything, we should have a full square for x, y in allocations: p.free(x, y) assert p.allocated is False assert p.children is None
def test_free_child(self): # Make sure we can match our children, even if they have the same # coordinate as us. p = PackTree(1, 2, 3, 4) p.hsplit(y=3) p.children[0].allocated = True p.children[1].allocated = True p.free(1, 2) assert p.children[0].allocated is False assert p.children[1].allocated is True p.children[0].allocated = True p.children[1].allocated = True p.free(1, 3) assert p.children[0].allocated is True assert p.children[1].allocated is False
def test_fit_h0_then_v1_split(self): # Make sure that if two splits are required, they are performed p = PackTree(1, 2, 4, 3) candidate_filter = Mock(side_effect=[False, False, True]) assert p.alloc(3, 1, candidate_filter) == (2, 2) assert p.allocated is False assert p.children is not None assert p.children[0].width == 4 assert p.children[0].height == 1 assert p.children[0].allocated is False assert p.children[0].children is not None assert p.children[0].children[0].width == 1 assert p.children[0].children[0].height == 1 assert p.children[0].children[0].allocated is False assert p.children[0].children[1].width == 3 assert p.children[0].children[1].height == 1 assert p.children[0].children[1].allocated is True assert p.children[1].width == 4 assert p.children[1].height == 2 assert p.children[1].children is None assert p.children[1].allocated is False
def test_one_child_full(self): p = PackTree(0, 0, 2, 1) assert p.alloc(1, 1) == (0, 0) assert p.alloc_area(1) == (1, 0, 1, 1) p.free(0, 0) assert p.alloc_area(1) == (0, 0, 1, 1)
def test_children_full(self): p = PackTree(0, 0, 2, 1) assert p.alloc(1, 1) == (0, 0) assert p.alloc(1, 1) == (1, 0) assert p.alloc_area(1) is None
def test_outside(self): # If outside the region, should fail p = PackTree(1, 2, 3, 4) assert p.request(0, 0) is None
def test_no_children_no_match(self, x, y): # Should fail if we try to free something which isn't a leaf node p = PackTree(1, 2, 3, 4) with pytest.raises(FreeError): p.free(2, 3)
def test_first_one(self): p = PackTree(1, 2, 3, 4) p.allocated = True p.free(1, 2) assert p.allocated is False
def test_all_gaps(self): p = PackTree(0, 0, 10, 10) assert p.request(8, 6) == (8, 6) assert p.allocated is False assert p.children is not None assert p.children[0].allocated is False assert p.children[0].x == 0 assert p.children[0].y == 0 assert p.children[0].width == 8 assert p.children[0].height == 10 assert p.children[0].children is None assert p.children[1].allocated is False assert p.children[1].x == 8 assert p.children[1].y == 0 assert p.children[1].width == 2 assert p.children[1].height == 10 assert p.children[1].children is not None p = p.children[1] assert p.children[0].allocated is False assert p.children[0].x == 8 assert p.children[0].y == 0 assert p.children[0].width == 2 assert p.children[0].height == 6 assert p.children[0].children is None assert p.children[1].allocated is False assert p.children[1].x == 8 assert p.children[1].y == 6 assert p.children[1].width == 2 assert p.children[1].height == 4 assert p.children[1].children is not None p = p.children[1] assert p.children[0].allocated is False assert p.children[0].x == 8 assert p.children[0].y == 6 assert p.children[0].width == 2 assert p.children[0].height == 1 assert p.children[0].children is not None assert p.children[1].allocated is False assert p.children[1].x == 8 assert p.children[1].y == 7 assert p.children[1].width == 2 assert p.children[1].height == 3 assert p.children[1].children is None p = p.children[0] assert p.children[0].allocated is True assert p.children[0].x == 8 assert p.children[0].y == 6 assert p.children[0].width == 1 assert p.children[0].height == 1 assert p.children[0].children is None assert p.children[1].allocated is False assert p.children[1].x == 9 assert p.children[1].y == 6 assert p.children[1].width == 1 assert p.children[1].height == 1 assert p.children[1].children is None
def test_first_one_but_not_allocated(self): p = PackTree(1, 2, 3, 4) with pytest.raises(FreeError): p.free(1, 2)
def test_too_large(self): p = PackTree(0, 0, 1, 1) assert p.alloc_area(2) is None
class Allocator(object): """This object allows high-level allocation of SpiNNaker boards from a larger, possibly faulty, toroidal machine. Internally this object uses a :py:class:`spalloc_server.pack_tree.PackTree` to allocate rectangular blocks of triads in a machine. A :py:class:`._CandidateFilter` to restrict the allocations made by :py:class:`~spalloc_server.pack_tree.PackTree` to those which match the needs of the user (e.g. specific connectivity requirements). The allocator can allocate either rectangular blocks of triads or individual boards. When allocating individual boards, the allocator allocates a 1x1 triad block from the :py:class:`~spalloc_server.pack_tree.PackTree` and returns one of the boards from that block. Subsequent single-board allocations will use up spare boards left in triads allocated for single-board allocations before allocating new 1x1 triads. """ def __init__(self, width, height, dead_boards=None, dead_links=None, next_id=1): """ Parameters ---------- width, height : int Dimensions of the machine in triads. dead_boards : set([(x, y, z), ...]) The set of boards which are dead and which must not be allocated. dead_links : set([(x, y, z, :py:class:`rig.links.Links`), ...]) The set of links leaving boards which are known not to be working. Connections to boards in the set dead_boards are assumed to be dead and need not be included in this list. Note that both link directions must be flagged as dead (if the link is bidirectionally down). next_id : int The ID of the next allocation to be made. """ self.width = width self.height = height self.dead_boards = dead_boards if dead_boards is not None else set() self.dead_links = dead_links if dead_links is not None else set() # Unique IDs are assigned to every new allocation. The next ID to be # allocated. self.next_id = next_id # A 2D tree at the granularity of triads used for board allocation. self.pack_tree = PackTree(0, 0, width, height) # Provides a lookup from (live) allocation IDs to the type of # allocation. self.allocation_types = {} # Lookup from allocation IDs to the bottom-left board in the allocation self.allocation_board = {} # Since we cannot allocate individual boards in the pack_tree, whenever # an individual board is requested a whole triad may be allocated and # one of the boards from the triad returned. This dictionary records # what triads have been allocated like this and which boards are # unused. These may then be used for future single-board allocations # rather than allocating another whole triad. # A dictionary containing any triads used for allocating individual # boards which still have some free and working boards. # {(x, y): [z, ...], ...} self.single_board_triads = {} # When all the boards in a triad in single_board_triads are used up the # triad is removed from that dictionary and placed into the set below. self.full_single_board_triads = set() def _alloc_triads_possible(self, width, height, max_dead_boards=None, max_dead_links=None, require_torus=False, min_ratio=0.0): """Is it guaranteed that the specified allocation *could* succeed if enough of the machine is free? This function may be conservative. If the specified request would fail when no resources have been allocated, we return False, even if some circumstances the allocation may succeed. For example, if one board in each of the four corners of the machine is dead, no allocation with max_dead_boards==0 can succeed when the machine is empty but may succeed if some other allocation has taken place. Parameters ---------- width, height : int The size of the block to allocate, in triads. max_dead_boards : int or None The maximum number of broken or unreachable boards to allow in the allocated region. If None, any number of dead boards is permitted, as long as the board on the bottom-left corner is alive (Default: None). max_dead_links : int or None The maximum number of broken links allow in the allocated region. When require_torus is True this includes wrap-around links, otherwise peripheral links are not counted. If None, any number of broken links is allowed. (Default: None). require_torus : bool If True, only allocate blocks with torus connectivity. In general this will only succeed for requests to allocate an entire machine (when the machine is otherwise not in use!). (Default: False) min_ratio : float Ignored. Returns ------- bool See Also -------- alloc_possible : The (public) wrapper which also supports checking triad allocations. """ # If too big, we can't fit if width > self.width or height > self.height: return False # Can't be a non-machine if width <= 0 or height <= 0: return False # If torus connectivity is required, we must be *exactly* the right # size otherwise we can't help... if require_torus and (width != self.width or height != self.height): return False # Test to see whether the allocation could succeed in the idle machine cf = _CandidateFilter(self.width, self.height, self.dead_boards, self.dead_links, max_dead_boards, max_dead_links, require_torus) for x, y in set([(0, 0), (self.width - width, 0), (0, self.height - height), (self.width - width, self.height - height)]): if cf(x, y, width, height): return True # No possible allocation could be made... return False def _alloc_triads(self, width, height, max_dead_boards=None, max_dead_links=None, require_torus=False, min_ratio=0.0): """Allocate a rectangular block of triads of interconnected boards. Parameters ---------- width, height : int The size of the block to allocate, in triads. max_dead_boards : int or None The maximum number of broken or unreachable boards to allow in the allocated region. If None, any number of dead boards is permitted, as long as the board on the bottom-left corner is alive (Default: None). max_dead_links : int or None The maximum number of broken links allow in the allocated region. When require_torus is True this includes wrap-around links, otherwise peripheral links are not counted. If None, any number of broken links is allowed. (Default: None). require_torus : bool If True, only allocate blocks with torus connectivity. In general this will only succeed for requests to allocate an entire machine (when the machine is otherwise not in use!). (Default: False) min_ratio : float Ignored. Returns ------- (allocation_id, boards, periphery, torus) or None If the allocation was successful a four-tuple is returned. If the allocation was not successful None is returned. The ``allocation_id`` is an integer which should be used to free the allocation with the :py:meth:`.free` method. ``boards`` is a set of (x, y, z) tuples giving the locations of the (working) boards in the allocation. ``periphery`` is a set of (x, y, z, link) tuples giving the links which leave the allocated region. ``torus`` is True iff at least one torus link is working. See Also -------- alloc : The (public) wrapper which also supports allocating individual boards. """ # Special case: If a torus is required this is only deliverable when # the requirements match the size of the machine exactly. if require_torus and (width != self.width or height != self.height): return None # Sanity check: can't be a non-machine if width <= 0 or height <= 0: return None cf = _CandidateFilter(self.width, self.height, self.dead_boards, self.dead_links, max_dead_boards, max_dead_links, require_torus) xy = self.pack_tree.alloc(width, height, candidate_filter=cf) # If a block could not be allocated, fail if xy is None: return None # If a block was allocated, store the allocation allocation_id = self.next_id self.next_id += 1 self.allocation_types[allocation_id] = _AllocationType.triads x, y = xy self.allocation_board[allocation_id] = (x, y, 0) return (allocation_id, cf.boards, cf.periphery, cf.torus) def _alloc_boards_possible(self, boards, min_ratio=0.0, max_dead_boards=None, max_dead_links=None, require_torus=False): """Is it guaranteed that the specified allocation *could* succeed if enough of the machine is free? This function may be conservative. If the specified request would fail when no resources have been allocated, we return False, even if some circumstances the allocation may succeed. For example, if one board in each of the four corners of the machine is dead, no allocation with max_dead_boards==0 can succeed when the machine is empty but may succeed if some other allocation has taken place. Parameters ---------- boards : int The *minimum* number of boards, must be at least 1. Note that if only 1 board is required, :py:class:`._alloc_board` would be a more appropriate function since this function may return as many as three boards when only a single one is requested. min_ratio : float The aspect ratio which the allocated region must be 'at least as square as'. Set to 0.0 for any allowable shape. max_dead_boards : int or None The maximum number of broken or unreachable boards to allow in the allocated region. If None, any number of dead boards is permitted, as long as the board on the bottom-left corner is alive (Default: None). max_dead_links : int or None The maximum number of broken links allow in the allocated region. When require_torus is True this includes wrap-around links, otherwise peripheral links are not counted. If None, any number of broken links is allowed. (Default: None). require_torus : bool If True, only allocate blocks with torus connectivity. In general this will only succeed for requests to allocate an entire machine (when the machine is otherwise not in use!). (Default: False) Returns ------- bool See Also -------- alloc_possible : The (public) wrapper which also supports checking triad allocations. """ # Convert number of boards to number of triads (rounding up...) triads = int(ceil(boards / 3.0)) # Sanity check: can't be a non-machine if triads <= 0: return False # Special case: If a torus is required this is only deliverable when # the requirements match the size of the machine exactly. if require_torus and (triads != self.width * self.height): return False # If no region of the right shape can be made, just fail wh = area_to_rect(triads, self.width, self.height, min_ratio) if wh is None: return False width, height = wh # Test to see whether the allocation could succeed in the idle machine cf = _CandidateFilter(self.width, self.height, self.dead_boards, self.dead_links, max_dead_boards, max_dead_links, require_torus, boards) for x, y in set([(0, 0), (self.width - width, 0), (0, self.height - height), (self.width - width, self.height - height)]): if cf(x, y, width, height): return True # No possible allocation could be made... return False def _alloc_boards(self, boards, min_ratio=0.0, max_dead_boards=None, max_dead_links=None, require_torus=False): """Allocate a rectangular block of triads with at least the specified number of boards which is 'at least as square' as the specified aspect ratio. Parameters ---------- boards : int The *minimum* number of boards, must be at least 1. Note that if only 1 board is required, :py:class:`._alloc_board` would be a more appropriate function since this function may return as many as three boards when only a single one is requested. min_ratio : float The aspect ratio which the allocated region must be 'at least as square as'. Set to 0.0 for any allowable shape. max_dead_boards : int or None The maximum number of broken or unreachable boards to allow in the allocated region. If None, any number of dead boards is permitted, as long as the board on the bottom-left corner is alive (Default: None). max_dead_links : int or None The maximum number of broken links allow in the allocated region. When require_torus is True this includes wrap-around links, otherwise peripheral links are not counted. If None, any number of broken links is allowed. (Default: None). require_torus : bool If True, only allocate blocks with torus connectivity. In general this will only succeed for requests to allocate an entire machine (when the machine is otherwise not in use!). (Default: False) Returns ------- (allocation_id, boards, periphery, torus) or None If the allocation was successful a four-tuple is returned. If the allocation was not successful None is returned. The ``allocation_id`` is an integer which should be used to free the allocation with the :py:meth:`.free` method. ``boards`` is a set of (x, y, z) tuples giving the locations of the (working) boards in the allocation. ``periphery`` is a set of (x, y, z, link) tuples giving the links which leave the allocated region. ``torus`` is a :py:class:`.WrapAround` value indicating torus connectivity when at least one torus may exist. See Also -------- alloc : The (public) wrapper which also supports allocating individual boards. """ # Convert number of boards to number of triads (rounding up...) triads = int(ceil(boards / 3.0)) # Sanity check: can't be a non-machine if triads <= 0: return None # Special case: If a torus is required this is only deliverable when # the requirements match the size of the machine exactly. if require_torus and (triads != self.width * self.height): return None cf = _CandidateFilter(self.width, self.height, self.dead_boards, self.dead_links, max_dead_boards, max_dead_links, require_torus, boards) xywh = self.pack_tree.alloc_area(triads, min_ratio, candidate_filter=cf) # If a block could not be allocated, fail if xywh is None: return None # If a block was allocated, store the allocation allocation_id = self.next_id self.next_id += 1 self.allocation_types[allocation_id] = _AllocationType.triads x, y, w, h = xywh self.allocation_board[allocation_id] = (x, y, 0) return (allocation_id, cf.boards, cf.periphery, cf.torus) def _alloc_board_possible(self, x=None, y=None, z=None, max_dead_boards=None, max_dead_links=None, require_torus=False, min_ratio=0.0): """Is it guaranteed that the specified allocation *could* succeed if enough of the machine is free? Parameters ---------- x, y, z : ints or None If specified, requests a specific board. max_dead_boards : int or None Ignored. max_dead_links : int or None Ignored. require_torus : bool Must be False. min_ratio : float Ignored. Returns ------- bool See Also -------- alloc_possible : The (public) wrapper which also supports checking board allocations. """ assert require_torus is False assert (((x is None) == (y is None) == (z is None)) or ((x == 1) == (y is None) == (z is None))) board_requested = y is not None # If the requested board is outside the dimensions of the machine, the # request definitely can't be met. if board_requested and not(0 <= x < self.width and 0 <= y < self.height and 0 <= z < 3): return False # If the requested board is dead, this should fail if board_requested and (x, y, z) in self.dead_boards: return False # If there are no working boards, we must also fail if len(self.dead_boards) >= (self.width * self.height * 3): return False # Should be possible! return True def _alloc_board(self, x=None, y=None, z=None, max_dead_boards=None, max_dead_links=None, require_torus=False, min_ratio=0.0): """Allocate a single board, optionally specifying a specific board to allocate. Parameters ---------- x, y, z : ints or None If None, an arbitrary free board will be returned if possible. If all are defined, attempts to allocate the specific board requested if available and working. max_dead_boards : int or None Ignored. max_dead_links : int or None Ignored. require_torus : bool Must be False. min_ratio : float Ignored. Returns ------- (allocation_id, boards, periphery, torus) or None If the allocation was successful a four-tuple is returned. If the allocation was not successful None is returned. The ``allocation_id`` is an integer which should be used to free the allocation with the :py:meth:`.free` method. ``boards`` is a set of (x, y, z) tuples giving the location of to allocated board. ``periphery`` is a set of (x, y, z, link) tuples giving the links which leave the board. ``torus`` is always :py:attr:`.WrapAround.none` for single boards. See Also -------- alloc : The (public) wrapper which also supports allocating triads. """ assert require_torus is False assert (((x is None) == (y is None) == (z is None)) or ((x == 1) == (y is None) == (z is None))) board_requested = y is not None # Special case: the desired board is dead: just give up if board_requested and (x, y, z) in self.dead_boards: return None # Try and return a board from an already allocated set of single-board # triads if possible if (self.single_board_triads and (not board_requested or z in self.single_board_triads.get((x, y), set()))): if not board_requested: # No specific board requested, return any available x, y = next(iter(self.single_board_triads)) available = self.single_board_triads[(x, y)] z = available.pop() else: # A specific board was requested (and is available), get that # one available = self.single_board_triads[(x, y)] available.remove(z) # If we used up the last board, move the traid to the full list if not available: del self.single_board_triads[(x, y)] self.full_single_board_triads.add((x, y)) # Allocate the board allocation_id = self.next_id self.next_id += 1 self.allocation_types[allocation_id] = _AllocationType.board self.allocation_board[allocation_id] = (x, y, z) return (allocation_id, set([(x, y, z)]), set((x, y, z, link) for link in Links), WrapAround.none) # The desired board was not available in an already-allocated triad. # Attempt to request that triad. def has_at_least_one_working_board(x, y, width, height): num_dead = 0 for z in range(3): if (x, y, z) in self.dead_boards: num_dead += 1 return num_dead < 3 if board_requested: xy = self.pack_tree.request(x, y) else: xy = self.pack_tree.alloc( 1, 1, candidate_filter=has_at_least_one_working_board) # If a triad could not be allocated, fail if xy is None: return None # If a triad was allocated, add it to the set of allocated triads for # single-boards self.single_board_triads[xy] = \ set(z for z in range(3) if (xy[0], xy[1], z) not in self.dead_boards) # Recursing will return a board from the triad return self._alloc_board(x, y, z) def _alloc_type(self, x_or_num_or_width=None, y_or_height=None, z=None, max_dead_boards=None, max_dead_links=None, require_torus=False, min_ratio=0.0): """Returns the type of allocation the user is attempting to make (and fails if it is invalid. Usage:: a.alloc() # Allocate any single board a.alloc(1) # Allocate any single board a.alloc(3, 2, 1) # Allocate the specific board (3, 2, 1) a.alloc(4) # Allocate at least 4 boards a.alloc(2, 3, **kwargs) # Allocate a 2x3 triad machine Parameters ---------- <nothing> OR num OR x, y, z OR width, height If nothing, allocate a single board. If num, allocate at least that number of boards. Special case: if 1, allocate exactly 1 board. If x, y and z, allocate a specific board. If width and height, allocate a block of this size, in triads. max_dead_boards : int or None The maximum number of broken or unreachable boards to allow in the allocated region. If None, any number of dead boards is permitted, as long as the board on the bottom-left corner is alive (Default: None). max_dead_links : int or None The maximum number of broken links allow in the allocated region. When require_torus is True this includes wrap-around links, otherwise peripheral links are not counted. If None, any number of broken links is allowed. (Default: None). require_torus : bool If True, only allocate blocks with torus connectivity. In general this will only succeed for requests to allocate an entire machine (when the machine is otherwise not in use!). Must be False when allocating boards. (Default: False) Returns ------- :py:class:`._AllocationType` """ # Work-around for Python 2's non-support for keyword-only arguments... args = [] if x_or_num_or_width is not None: args.append(x_or_num_or_width) if y_or_height is not None: args.append(y_or_height) if z is not None: args.append(z) # Select allocation type if len(args) == 0: alloc_type = _AllocationType.board elif len(args) == 1: if args[0] == 1: alloc_type = _AllocationType.board else: alloc_type = _AllocationType.boards elif len(args) == 2: alloc_type = _AllocationType.triads elif len(args) == 3: # pragma: no branch alloc_type = _AllocationType.board # Validate arguments if alloc_type == _AllocationType.board: if require_torus: raise ValueError( "require_torus must be False when allocating boards.") return alloc_type def alloc_possible(self, *args, **kwargs): """Is the specified allocation actually possible on this machine? Usage:: a.alloc_possible() # Can allocate a single board? a.alloc_possible(1) # Can allocate a single board? a.alloc_possible(4) # Can allocate at least 4 boards? a.alloc_possible(3, 2, 1) # Can allocate a board (3, 2, 1)? a.alloc_possible(2, 3, **kwargs) # Can allocate 2x3 triads? Parameters ---------- <nothing> OR num OR x, y, z OR width, height If nothing, allocate a single board. If num, allocate at least that number of boards. Special case: if 1, allocate exactly 1 board. If x, y and z, allocate a specific board. If width and height, allocate a block of this size, in triads. min_ratio : float The aspect ratio which the allocated region must be 'at least as square as'. Set to 0.0 for any allowable shape. Ignored when allocating single boards or specific rectangles of triads. max_dead_boards : int or None The maximum number of broken or unreachable boards to allow in the allocated region. If None, any number of dead boards is permitted, as long as the board on the bottom-left corner is alive (Default: None). max_dead_links : int or None The maximum number of broken links allow in the allocated region. When require_torus is True this includes wrap-around links, otherwise peripheral links are not counted. If None, any number of broken links is allowed. (Default: None). require_torus : bool If True, only allocate blocks with torus connectivity. In general this will only succeed for requests to allocate an entire machine (when the machine is otherwise not in use!). Must be False when allocating boards. (Default: False) Returns ------- bool """ alloc_type = self._alloc_type(*args, **kwargs) if alloc_type is _AllocationType.board: return self._alloc_board_possible(*args, **kwargs) elif alloc_type is _AllocationType.boards: return self._alloc_boards_possible(*args, **kwargs) else: return self._alloc_triads_possible(*args, **kwargs) def alloc(self, *args, **kwargs): """Attempt to allocate a board or rectangular region of triads of boards. Usage:: a.alloc() # Allocate a single board a.alloc(1) # Allocate a single board a.alloc(4) # Allocate at least 4 boards a.alloc(3, 2, 1) # Allocate a specific board (3, 2, 1) a.alloc(2, 3, **kwargs) # Allocate a 2x3 triad machine Parameters ---------- <nothing> OR num OR x, y, z OR width, height If all None, allocate a single board. If num, allocate at least that number of boards. Special case: if 1, allocate exactly 1 board. If x, y and z, allocate a specific board. If width and height, allocate a block of this size, in triads. min_ratio : float The aspect ratio which the allocated region must be 'at least as square as'. Set to 0.0 for any allowable shape. Ignored when allocating single boards or specific rectangles of triads. max_dead_boards : int or None The maximum number of broken or unreachable boards to allow in the allocated region. If None, any number of dead boards is permitted, as long as the board on the bottom-left corner is alive (Default: None). max_dead_links : int or None The maximum number of broken links allow in the allocated region. When require_torus is True this includes wrap-around links, otherwise peripheral links are not counted. If None, any number of broken links is allowed. (Default: None). require_torus : bool If True, only allocate blocks with torus connectivity. In general this will only succeed for requests to allocate an entire machine (when the machine is otherwise not in use!). Must be False when allocating boards. (Default: False) Returns ------- (allocation_id, boards, periphery, torus) or None If the allocation was successful a four-tuple is returned. If the allocation was not successful None is returned. The ``allocation_id`` is an integer which should be used to free the allocation with the :py:meth:`.free` method. ``boards`` is a set of (x, y, z) tuples giving the locations of to allocated boards. ``periphery`` is a set of (x, y, z, link) tuples giving the links which leave the allocated set of boards. ``torus`` is a :py:class:`.WrapAround` value indicating torus connectivity when at least one torus may exist. """ alloc_type = self._alloc_type(*args, **kwargs) if alloc_type is _AllocationType.board: return self._alloc_board(*args, **kwargs) elif alloc_type is _AllocationType.boards: return self._alloc_boards(*args, **kwargs) else: return self._alloc_triads(*args, **kwargs) def free(self, allocation_id): """Free the resources consumed by the specified allocation. Parameters ---------- allocation_id : int The ID of the allocation to free. """ type = self.allocation_types.pop(allocation_id) x, y, z = self.allocation_board.pop(allocation_id) if type is _AllocationType.triads: # Simply free the allocation self.pack_tree.free(x, y) elif type is _AllocationType.board: # If the traid the board came from was full, it now isn't... if (x, y) in self.full_single_board_triads: self.full_single_board_triads.remove((x, y)) self.single_board_triads[(x, y)] = set() # Return the board to the set available in that triad self.single_board_triads[(x, y)].add(z) # If all working boards have been freed in the triad, we must free # the triad. working = set(z for z in range(3) if (x, y, z) not in self.dead_boards) if self.single_board_triads[(x, y)] == working: del self.single_board_triads[(x, y)] self.pack_tree.free(x, y) else: # pragma: no cover assert False, "Unknown allocation type!"
def test_already_allocated(self): p = PackTree(0, 0, 1, 1) assert p.alloc(1, 1) == (0, 0) assert p.alloc_area(1) is None
def test_no_children(self): p = PackTree(0, 0, 3, 3) assert p.alloc_area(6) == (0, 0, 3, 2) p = PackTree(0, 0, 3, 3) assert p.alloc_area(6, 1.0) == (0, 0, 3, 3)
def test_unsuitable_ratio(self): p = PackTree(0, 0, 3, 1) assert p.alloc_area(3, min_ratio=1.0) is None
def test_perfect_fit(self): p = PackTree(1, 2, 1, 1) assert p.request(1, 2) == (1, 2) assert p.allocated is True assert p.children is None