54 } 55 curr += 1; 56 } 57 assert(num_so_far <= num, "post-condition"); 58 if (num_so_far == num) { 59 // we found enough space for the humongous object 60 assert(from <= first && first < len, "post-condition"); 61 assert(first < curr && (curr - first) == num, "post-condition"); 62 for (uint i = first; i < first + num; ++i) { 63 assert(at(i)->is_empty(), "post-condition"); 64 } 65 return first; 66 } else { 67 // we failed to find enough space for the humongous object 68 return G1_NULL_HRS_INDEX; 69 } 70 } 71 72 // Public 73 74 void HeapRegionSeq::initialize(HeapWord* bottom, HeapWord* end, 75 uint max_length) { 76 assert((uintptr_t) bottom % HeapRegion::GrainBytes == 0, 77 "bottom should be heap region aligned"); 78 assert((uintptr_t) end % HeapRegion::GrainBytes == 0, 79 "end should be heap region aligned"); 80 81 _length = 0; 82 _heap_bottom = bottom; 83 _heap_end = end; 84 _region_shift = HeapRegion::LogOfHRGrainBytes; 85 _next_search_index = 0; 86 _allocated_length = 0; 87 _max_length = max_length; 88 89 _regions = NEW_C_HEAP_ARRAY(HeapRegion*, max_length, mtGC); 90 memset(_regions, 0, (size_t) max_length * sizeof(HeapRegion*)); 91 _regions_biased = _regions - ((uintx) bottom >> _region_shift); 92 93 assert(&_regions[0] == &_regions_biased[addr_to_index_biased(bottom)], 94 "bottom should be included in the region with index 0"); 95 } 96 97 MemRegion HeapRegionSeq::expand_by(HeapWord* old_end, 98 HeapWord* new_end, 99 FreeRegionList* list) { 100 assert(old_end < new_end, "don't call it otherwise"); 101 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 102 103 HeapWord* next_bottom = old_end; 104 assert(_heap_bottom <= next_bottom, "invariant"); 105 while (next_bottom < new_end) { 106 assert(next_bottom < _heap_end, "invariant"); 107 uint index = length(); 108 109 assert(index < _max_length, "otherwise we cannot expand further"); 110 if (index == 0) { 111 // We have not allocated any regions so far 112 assert(next_bottom == _heap_bottom, "invariant"); 113 } else { 114 // next_bottom should match the end of the last/previous region 115 assert(next_bottom == at(index - 1)->end(), "invariant"); 116 } 117 118 if (index == _allocated_length) { 119 // We have to allocate a new HeapRegion. 120 HeapRegion* new_hr = g1h->new_heap_region(index, next_bottom); 121 if (new_hr == NULL) { 122 // allocation failed, we bail out and return what we have done so far 123 return MemRegion(old_end, next_bottom); 124 } 125 assert(_regions[index] == NULL, "invariant"); 126 _regions[index] = new_hr; 127 increment_allocated_length(); 128 } 129 // Have to increment the length first, otherwise we will get an 130 // assert failure at(index) below. 131 increment_length(); 132 HeapRegion* hr = at(index); 133 list->add_as_tail(hr); 134 135 next_bottom = hr->end(); 136 } 137 assert(next_bottom == new_end, "post-condition"); 138 return MemRegion(old_end, next_bottom); 139 } 140 141 uint HeapRegionSeq::free_suffix() { 142 uint res = 0; 143 uint index = length(); 144 while (index > 0) { 145 index -= 1; 146 if (!at(index)->is_empty()) { 211 assert(_allocated_length > 0, "we should have at least one region committed"); 212 assert(num_regions_to_remove < length(), "We should never remove all regions"); 213 214 uint i = 0; 215 for (; i < num_regions_to_remove; i++) { 216 HeapRegion* cur = at(length() - 1); 217 218 if (!cur->is_empty()) { 219 // We have to give up if the region can not be moved 220 break; 221 } 222 assert(!cur->isHumongous(), "Humongous regions should not be empty"); 223 224 decrement_length(); 225 } 226 return i; 227 } 228 229 #ifndef PRODUCT 230 void HeapRegionSeq::verify_optional() { 231 guarantee(_length <= _allocated_length, 232 err_msg("invariant: _length: %u _allocated_length: %u", 233 _length, _allocated_length)); 234 guarantee(_allocated_length <= _max_length, 235 err_msg("invariant: _allocated_length: %u _max_length: %u", 236 _allocated_length, _max_length)); 237 guarantee(_next_search_index <= _length, 238 err_msg("invariant: _next_search_index: %u _length: %u", 239 _next_search_index, _length)); 240 241 HeapWord* prev_end = _heap_bottom; 242 for (uint i = 0; i < _allocated_length; i += 1) { 243 HeapRegion* hr = _regions[i]; 244 guarantee(hr != NULL, err_msg("invariant: i: %u", i)); 245 guarantee(hr->bottom() == prev_end, 246 err_msg("invariant i: %u "HR_FORMAT" prev_end: "PTR_FORMAT, 247 i, HR_FORMAT_PARAMS(hr), prev_end)); 248 guarantee(hr->hrs_index() == i, 249 err_msg("invariant: i: %u hrs_index(): %u", i, hr->hrs_index())); 250 if (i < _length) { 251 // Asserts will fire if i is >= _length 252 HeapWord* addr = hr->bottom(); 253 guarantee(addr_to_region(addr) == hr, "sanity"); 254 guarantee(addr_to_region_unsafe(addr) == hr, "sanity"); 255 } else { 256 guarantee(hr->is_empty(), "sanity"); 257 guarantee(!hr->isHumongous(), "sanity"); 258 // using assert instead of guarantee here since containing_set() 259 // is only available in non-product builds. 260 assert(hr->containing_set() == NULL, "sanity"); 261 } 262 if (hr->startsHumongous()) { 263 prev_end = hr->orig_end(); 264 } else { 265 prev_end = hr->end(); 266 } 267 } 268 for (uint i = _allocated_length; i < _max_length; i += 1) { 269 guarantee(_regions[i] == NULL, err_msg("invariant i: %u", i)); 270 } 271 } 272 #endif // PRODUCT | 54 } 55 curr += 1; 56 } 57 assert(num_so_far <= num, "post-condition"); 58 if (num_so_far == num) { 59 // we found enough space for the humongous object 60 assert(from <= first && first < len, "post-condition"); 61 assert(first < curr && (curr - first) == num, "post-condition"); 62 for (uint i = first; i < first + num; ++i) { 63 assert(at(i)->is_empty(), "post-condition"); 64 } 65 return first; 66 } else { 67 // we failed to find enough space for the humongous object 68 return G1_NULL_HRS_INDEX; 69 } 70 } 71 72 // Public 73 74 void HeapRegionSeq::initialize(HeapWord* bottom, HeapWord* end) { 75 assert((uintptr_t) bottom % HeapRegion::GrainBytes == 0, 76 "bottom should be heap region aligned"); 77 assert((uintptr_t) end % HeapRegion::GrainBytes == 0, 78 "end should be heap region aligned"); 79 80 _next_search_index = 0; 81 _allocated_length = 0; 82 83 _regions.initialize(bottom, end, HeapRegion::GrainBytes); 84 } 85 86 MemRegion HeapRegionSeq::expand_by(HeapWord* old_end, 87 HeapWord* new_end, 88 FreeRegionList* list) { 89 assert(old_end < new_end, "don't call it otherwise"); 90 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 91 92 HeapWord* next_bottom = old_end; 93 assert(heap_bottom() <= next_bottom, "invariant"); 94 while (next_bottom < new_end) { 95 assert(next_bottom < heap_end(), "invariant"); 96 uint index = length(); 97 98 assert(index < max_length(), "otherwise we cannot expand further"); 99 if (index == 0) { 100 // We have not allocated any regions so far 101 assert(next_bottom == heap_bottom(), "invariant"); 102 } else { 103 // next_bottom should match the end of the last/previous region 104 assert(next_bottom == at(index - 1)->end(), "invariant"); 105 } 106 107 if (index == _allocated_length) { 108 // We have to allocate a new HeapRegion. 109 HeapRegion* new_hr = g1h->new_heap_region(index, next_bottom); 110 if (new_hr == NULL) { 111 // allocation failed, we bail out and return what we have done so far 112 return MemRegion(old_end, next_bottom); 113 } 114 assert(_regions.get_by_index(index) == NULL, "invariant"); 115 _regions.set_by_index(index, new_hr); 116 increment_allocated_length(); 117 } 118 // Have to increment the length first, otherwise we will get an 119 // assert failure at(index) below. 120 increment_length(); 121 HeapRegion* hr = at(index); 122 list->add_as_tail(hr); 123 124 next_bottom = hr->end(); 125 } 126 assert(next_bottom == new_end, "post-condition"); 127 return MemRegion(old_end, next_bottom); 128 } 129 130 uint HeapRegionSeq::free_suffix() { 131 uint res = 0; 132 uint index = length(); 133 while (index > 0) { 134 index -= 1; 135 if (!at(index)->is_empty()) { 200 assert(_allocated_length > 0, "we should have at least one region committed"); 201 assert(num_regions_to_remove < length(), "We should never remove all regions"); 202 203 uint i = 0; 204 for (; i < num_regions_to_remove; i++) { 205 HeapRegion* cur = at(length() - 1); 206 207 if (!cur->is_empty()) { 208 // We have to give up if the region can not be moved 209 break; 210 } 211 assert(!cur->isHumongous(), "Humongous regions should not be empty"); 212 213 decrement_length(); 214 } 215 return i; 216 } 217 218 #ifndef PRODUCT 219 void HeapRegionSeq::verify_optional() { 220 guarantee(length() <= _allocated_length, 221 err_msg("invariant: _length: %u _allocated_length: %u", 222 length(), _allocated_length)); 223 guarantee(_allocated_length <= max_length(), 224 err_msg("invariant: _allocated_length: %u _max_length: %u", 225 _allocated_length, max_length())); 226 guarantee(_next_search_index <= length(), 227 err_msg("invariant: _next_search_index: %u _length: %u", 228 _next_search_index, length())); 229 230 HeapWord* prev_end = heap_bottom(); 231 for (uint i = 0; i < _allocated_length; i += 1) { 232 HeapRegion* hr = _regions.get_by_index(i); 233 guarantee(hr != NULL, err_msg("invariant: i: %u", i)); 234 guarantee(hr->bottom() == prev_end, 235 err_msg("invariant i: %u "HR_FORMAT" prev_end: "PTR_FORMAT, 236 i, HR_FORMAT_PARAMS(hr), prev_end)); 237 guarantee(hr->hrs_index() == i, 238 err_msg("invariant: i: %u hrs_index(): %u", i, hr->hrs_index())); 239 if (i < length()) { 240 // Asserts will fire if i is >= _length 241 HeapWord* addr = hr->bottom(); 242 guarantee(addr_to_region(addr) == hr, "sanity"); 243 guarantee(addr_to_region_unsafe(addr) == hr, "sanity"); 244 } else { 245 guarantee(hr->is_empty(), "sanity"); 246 guarantee(!hr->isHumongous(), "sanity"); 247 // using assert instead of guarantee here since containing_set() 248 // is only available in non-product builds. 249 assert(hr->containing_set() == NULL, "sanity"); 250 } 251 if (hr->startsHumongous()) { 252 prev_end = hr->orig_end(); 253 } else { 254 prev_end = hr->end(); 255 } 256 } 257 for (uint i = _allocated_length; i < max_length(); i += 1) { 258 guarantee(_regions.get_by_index(i) == NULL, err_msg("invariant i: %u", i)); 259 } 260 } 261 #endif // PRODUCT |