void FreeRegionList::remove_starting_at(HeapRegion* first, uint num_regions) { check_mt_safety(); assert_free_region_list(num_regions >= 1, "pre-condition"); assert_free_region_list(!is_empty(), "pre-condition"); verify_optional(); DEBUG_ONLY(uint old_length = length();)
inline HeapRegion* FreeRegionList::remove_region(bool from_head) { check_mt_safety(); verify_optional(); if (is_empty()) { return NULL; } assert_free_region_list(length() > 0 && _head != NULL && _tail != NULL, "invariant"); HeapRegion* hr; if (from_head) { hr = remove_from_head_impl(); } else { hr = remove_from_tail_impl(); } if (_last == hr) { _last = NULL; } // remove() will verify the region and check mt safety. remove(hr); return hr; }
inline void FreeRegionList::add_ordered(HeapRegion* hr) { assert_free_region_list((length() == 0 && _head == NULL && _tail == NULL && _last == NULL) || (length() > 0 && _head != NULL && _tail != NULL), "invariant"); // add() will verify the region and check mt safety. add(hr); // Now link the region if (_head != NULL) { HeapRegion* curr; if (_last != NULL && _last->hrm_index() < hr->hrm_index()) { curr = _last; } else { curr = _head; } // Find first entry with a Region Index larger than entry to insert. while (curr != NULL && curr->hrm_index() < hr->hrm_index()) { curr = curr->next(); } hr->set_next(curr); if (curr == NULL) { // Adding at the end hr->set_prev(_tail); _tail->set_next(hr); _tail = hr; } else if (curr->prev() == NULL) { // Adding at the beginning hr->set_prev(NULL); _head = hr; curr->set_prev(hr); } else { hr->set_prev(curr->prev()); hr->prev()->set_next(hr); curr->set_prev(hr); } } else { // The list was empty _tail = hr; _head = hr; } _last = hr; }
void FreeRegionList::add_ordered(FreeRegionList* from_list) { check_mt_safety(); from_list->check_mt_safety(); verify_optional(); from_list->verify_optional(); if (from_list->is_empty()) { return; } #ifdef ASSERT FreeRegionListIterator iter(from_list); while (iter.more_available()) { HeapRegion* hr = iter.get_next(); // In set_containing_set() we check that we either set the value // from NULL to non-NULL or vice versa to catch bugs. So, we have // to NULL it first before setting it to the value. hr->set_containing_set(NULL); hr->set_containing_set(this); } #endif // ASSERT if (is_empty()) { assert_free_region_list(length() == 0 && _tail == NULL, "invariant"); _head = from_list->_head; _tail = from_list->_tail; } else { HeapRegion* curr_to = _head; HeapRegion* curr_from = from_list->_head; while (curr_from != NULL) { while (curr_to != NULL && curr_to->hrm_index() < curr_from->hrm_index()) { curr_to = curr_to->next(); } if (curr_to == NULL) { // The rest of the from list should be added as tail _tail->set_next(curr_from); curr_from->set_prev(_tail); curr_from = NULL; } else { HeapRegion* next_from = curr_from->next(); curr_from->set_next(curr_to); curr_from->set_prev(curr_to->prev()); if (curr_to->prev() == NULL) { _head = curr_from; } else { curr_to->prev()->set_next(curr_from); } curr_to->set_prev(curr_from); curr_from = next_from; } } if (_tail->hrm_index() < from_list->_tail->hrm_index()) { _tail = from_list->_tail; } } _length += from_list->length(); from_list->clear(); verify_optional(); from_list->verify_optional(); }