inline HeapRegion* HeapRegionSeq::addr_to_region(HeapWord* addr) const { if (addr != NULL && addr < heap_end()) { assert(addr >= heap_bottom(), err_msg("addr: "PTR_FORMAT" bottom: "PTR_FORMAT, addr, heap_bottom())); return addr_to_region_unsafe(addr); } return NULL; }
inline HeapRegion* HeapRegionManager::addr_to_region(HeapWord* addr) const { assert(addr < heap_end(), err_msg("addr: " PTR_FORMAT " end: " PTR_FORMAT, p2i(addr), p2i(heap_end()))); assert(addr >= heap_bottom(), err_msg("addr: " PTR_FORMAT " bottom: " PTR_FORMAT, p2i(addr), p2i(heap_bottom()))); HeapRegion* hr = _regions.get_by_address(addr); return hr; }
MemRegion HeapRegionSeq::expand_by(HeapWord* old_end, HeapWord* new_end, FreeRegionList* list) { assert(old_end < new_end, "don't call it otherwise"); G1CollectedHeap* g1h = G1CollectedHeap::heap(); HeapWord* next_bottom = old_end; assert(heap_bottom() <= next_bottom, "invariant"); while (next_bottom < new_end) { assert(next_bottom < heap_end(), "invariant"); uint index = length(); assert(index < max_length(), "otherwise we cannot expand further"); if (index == 0) { // We have not allocated any regions so far assert(next_bottom == heap_bottom(), "invariant"); } else { // next_bottom should match the end of the last/previous region assert(next_bottom == at(index - 1)->end(), "invariant"); } if (index == _allocated_length) { // We have to allocate a new HeapRegion. HeapRegion* new_hr = g1h->new_heap_region(index, next_bottom); if (new_hr == NULL) { // allocation failed, we bail out and return what we have done so far return MemRegion(old_end, next_bottom); } assert(_regions.get_by_index(index) == NULL, "invariant"); _regions.set_by_index(index, new_hr); increment_allocated_length(); } // Have to increment the length first, otherwise we will get an // assert failure at(index) below. increment_length(); HeapRegion* hr = at(index); list->add_as_tail(hr); next_bottom = hr->end(); } assert(next_bottom == new_end, "post-condition"); return MemRegion(old_end, next_bottom); }
void HeapRegionSeq::verify_optional() { guarantee(length() <= _allocated_length, err_msg("invariant: _length: %u _allocated_length: %u", length(), _allocated_length)); guarantee(_allocated_length <= max_length(), err_msg("invariant: _allocated_length: %u _max_length: %u", _allocated_length, max_length())); guarantee(_next_search_index <= length(), err_msg("invariant: _next_search_index: %u _length: %u", _next_search_index, length())); HeapWord* prev_end = heap_bottom(); for (uint i = 0; i < _allocated_length; i += 1) { HeapRegion* hr = _regions.get_by_index(i); guarantee(hr != NULL, err_msg("invariant: i: %u", i)); guarantee(hr->bottom() == prev_end, err_msg("invariant i: %u "HR_FORMAT" prev_end: "PTR_FORMAT, i, HR_FORMAT_PARAMS(hr), p2i(prev_end))); guarantee(hr->hrs_index() == i, err_msg("invariant: i: %u hrs_index(): %u", i, hr->hrs_index())); if (i < length()) { // Asserts will fire if i is >= _length HeapWord* addr = hr->bottom(); guarantee(addr_to_region(addr) == hr, "sanity"); guarantee(addr_to_region_unsafe(addr) == hr, "sanity"); } else { guarantee(hr->is_empty(), "sanity"); guarantee(!hr->isHumongous(), "sanity"); // using assert instead of guarantee here since containing_set() // is only available in non-product builds. assert(hr->containing_set() == NULL, "sanity"); } if (hr->startsHumongous()) { prev_end = hr->orig_end(); } else { prev_end = hr->end(); } } for (uint i = _allocated_length; i < max_length(); i += 1) { guarantee(_regions.get_by_index(i) == NULL, err_msg("invariant i: %u", i)); } }
void HeapRegionManager::verify() { guarantee(length() <= _allocated_heapregions_length, "invariant: _length: %u _allocated_length: %u", length(), _allocated_heapregions_length); guarantee(_allocated_heapregions_length <= max_length(), "invariant: _allocated_length: %u _max_length: %u", _allocated_heapregions_length, max_length()); bool prev_committed = true; uint num_committed = 0; HeapWord* prev_end = heap_bottom(); for (uint i = 0; i < _allocated_heapregions_length; i++) { if (!is_available(i)) { prev_committed = false; continue; } num_committed++; HeapRegion* hr = _regions.get_by_index(i); guarantee(hr != NULL, "invariant: i: %u", i); guarantee(!prev_committed || hr->bottom() == prev_end, "invariant i: %u " HR_FORMAT " prev_end: " PTR_FORMAT, i, HR_FORMAT_PARAMS(hr), p2i(prev_end)); guarantee(hr->hrm_index() == i, "invariant: i: %u hrm_index(): %u", i, hr->hrm_index()); // Asserts will fire if i is >= _length HeapWord* addr = hr->bottom(); guarantee(addr_to_region(addr) == hr, "sanity"); // We cannot check whether the region is part of a particular set: at the time // this method may be called, we have only completed allocation of the regions, // but not put into a region set. prev_committed = true; prev_end = hr->end(); } for (uint i = _allocated_heapregions_length; i < max_length(); i++) { guarantee(_regions.get_by_index(i) == NULL, "invariant i: %u", i); } guarantee(num_committed == _num_committed, "Found %u committed regions, but should be %u", num_committed, _num_committed); _free_list.verify(); }
MemRegion reserved() const { return MemRegion(heap_bottom(), heap_end()); }