20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "gc/g1/g1CollectedHeap.inline.hpp"
27 #include "gc/g1/heapRegionRemSet.hpp"
28 #include "gc/g1/heapRegionSet.inline.hpp"
29
30 uint FreeRegionList::_unrealistically_long_length = 0;
31
32 void HeapRegionSetBase::fill_in_ext_msg(hrs_ext_msg* msg, const char* message) {
33 msg->append("[%s] %s ln: %u cy: " SIZE_FORMAT,
34 name(), message, length(), total_capacity_bytes());
35 fill_in_ext_msg_extra(msg);
36 }
37
38 #ifndef PRODUCT
39 void HeapRegionSetBase::verify_region(HeapRegion* hr) {
40 assert(hr->containing_set() == this, err_msg("Inconsistent containing set for %u", hr->hrm_index()));
41 assert(!hr->is_young(), err_msg("Adding young region %u", hr->hrm_index())); // currently we don't use these sets for young regions
42 assert(hr->is_humongous() == regions_humongous(), err_msg("Wrong humongous state for region %u and set %s", hr->hrm_index(), name()));
43 assert(hr->is_free() == regions_free(), err_msg("Wrong free state for region %u and set %s", hr->hrm_index(), name()));
44 assert(!hr->is_free() || hr->is_empty(), err_msg("Free region %u is not empty for set %s", hr->hrm_index(), name()));
45 assert(!hr->is_empty() || hr->is_free() || hr->is_archive(),
46 err_msg("Empty region %u is not free or archive for set %s", hr->hrm_index(), name()));
47 assert(hr->rem_set()->verify_ready_for_par_iteration(), err_msg("Wrong iteration state %u", hr->hrm_index()));
48 }
49 #endif
50
51 void HeapRegionSetBase::verify() {
52 // It's important that we also observe the MT safety protocol even
53 // for the verification calls. If we do verification without the
54 // appropriate locks and the set changes underneath our feet
55 // verification might fail and send us on a wild goose chase.
56 check_mt_safety();
57
58 guarantee(( is_empty() && length() == 0 && total_capacity_bytes() == 0) ||
59 (!is_empty() && length() > 0 && total_capacity_bytes() > 0) ,
60 hrs_ext_msg(this, "invariant"));
61 }
62
63 void HeapRegionSetBase::verify_start() {
64 // See comment in verify() about MT safety and verification.
65 check_mt_safety();
66 assert(!_verify_in_progress,
67 hrs_ext_msg(this, "verification should not be in progress"));
68
69 // Do the basic verification first before we do the checks over the regions.
70 HeapRegionSetBase::verify();
71
72 _verify_in_progress = true;
73 }
74
75 void HeapRegionSetBase::verify_end() {
76 // See comment in verify() about MT safety and verification.
77 check_mt_safety();
78 assert(_verify_in_progress,
79 hrs_ext_msg(this, "verification should be in progress"));
80
81 _verify_in_progress = false;
82 }
83
84 void HeapRegionSetBase::print_on(outputStream* out, bool print_contents) {
85 out->cr();
86 out->print_cr("Set: %s (" PTR_FORMAT ")", name(), p2i(this));
87 out->print_cr(" Region Assumptions");
88 out->print_cr(" humongous : %s", BOOL_TO_STR(regions_humongous()));
89 out->print_cr(" free : %s", BOOL_TO_STR(regions_free()));
90 out->print_cr(" Attributes");
91 out->print_cr(" length : %14u", length());
92 out->print_cr(" total capacity : " SIZE_FORMAT_W(14) " bytes",
93 total_capacity_bytes());
94 }
95
96 HeapRegionSetBase::HeapRegionSetBase(const char* name, bool humongous, bool free, HRSMtSafeChecker* mt_safety_checker)
97 : _name(name), _verify_in_progress(false),
98 _is_humongous(humongous), _is_free(free), _mt_safety_checker(mt_safety_checker),
99 _count()
134 verify_optional();
135 from_list->verify_optional();
136
137 if (from_list->is_empty()) {
138 return;
139 }
140
141 #ifdef ASSERT
142 FreeRegionListIterator iter(from_list);
143 while (iter.more_available()) {
144 HeapRegion* hr = iter.get_next();
145 // In set_containing_set() we check that we either set the value
146 // from NULL to non-NULL or vice versa to catch bugs. So, we have
147 // to NULL it first before setting it to the value.
148 hr->set_containing_set(NULL);
149 hr->set_containing_set(this);
150 }
151 #endif // ASSERT
152
153 if (is_empty()) {
154 assert(length() == 0 && _tail == NULL, hrs_ext_msg(this, "invariant"));
155 _head = from_list->_head;
156 _tail = from_list->_tail;
157 } else {
158 HeapRegion* curr_to = _head;
159 HeapRegion* curr_from = from_list->_head;
160
161 while (curr_from != NULL) {
162 while (curr_to != NULL && curr_to->hrm_index() < curr_from->hrm_index()) {
163 curr_to = curr_to->next();
164 }
165
166 if (curr_to == NULL) {
167 // The rest of the from list should be added as tail
168 _tail->set_next(curr_from);
169 curr_from->set_prev(_tail);
170 curr_from = NULL;
171 } else {
172 HeapRegion* next_from = curr_from->next();
173
174 curr_from->set_next(curr_to);
181 curr_to->set_prev(curr_from);
182
183 curr_from = next_from;
184 }
185 }
186
187 if (_tail->hrm_index() < from_list->_tail->hrm_index()) {
188 _tail = from_list->_tail;
189 }
190 }
191
192 _count.increment(from_list->length(), from_list->total_capacity_bytes());
193 from_list->clear();
194
195 verify_optional();
196 from_list->verify_optional();
197 }
198
199 void FreeRegionList::remove_starting_at(HeapRegion* first, uint num_regions) {
200 check_mt_safety();
201 assert(num_regions >= 1, hrs_ext_msg(this, "pre-condition"));
202 assert(!is_empty(), hrs_ext_msg(this, "pre-condition"));
203
204 verify_optional();
205 DEBUG_ONLY(uint old_length = length();)
206
207 HeapRegion* curr = first;
208 uint count = 0;
209 while (count < num_regions) {
210 verify_region(curr);
211 HeapRegion* next = curr->next();
212 HeapRegion* prev = curr->prev();
213
214 assert(count < num_regions,
215 hrs_err_msg("[%s] should not come across more regions "
216 "pending for removal than num_regions: %u",
217 name(), num_regions));
218
219 if (prev == NULL) {
220 assert(_head == curr, hrs_ext_msg(this, "invariant"));
221 _head = next;
222 } else {
223 assert(_head != curr, hrs_ext_msg(this, "invariant"));
224 prev->set_next(next);
225 }
226 if (next == NULL) {
227 assert(_tail == curr, hrs_ext_msg(this, "invariant"));
228 _tail = prev;
229 } else {
230 assert(_tail != curr, hrs_ext_msg(this, "invariant"));
231 next->set_prev(prev);
232 }
233 if (_last = curr) {
234 _last = NULL;
235 }
236
237 curr->set_next(NULL);
238 curr->set_prev(NULL);
239 remove(curr);
240
241 count++;
242 curr = next;
243 }
244
245 assert(count == num_regions,
246 hrs_err_msg("[%s] count: %u should be == num_regions: %u",
247 name(), count, num_regions));
248 assert(length() + num_regions == old_length,
249 hrs_err_msg("[%s] new length should be consistent "
250 "new length: %u old length: %u num_regions: %u",
251 name(), length(), old_length, num_regions));
252
253 verify_optional();
254 }
255
256 void FreeRegionList::verify() {
257 // See comment in HeapRegionSetBase::verify() about MT safety and
258 // verification.
259 check_mt_safety();
260
261 // This will also do the basic verification too.
262 verify_start();
263
264 verify_list();
265
266 verify_end();
267 }
268
269 void FreeRegionList::clear() {
270 _count = HeapRegionSetCount();
271 _head = NULL;
288 }
289 }
290
291 out->cr();
292 }
293
294 void FreeRegionList::verify_list() {
295 HeapRegion* curr = _head;
296 HeapRegion* prev1 = NULL;
297 HeapRegion* prev0 = NULL;
298 uint count = 0;
299 size_t capacity = 0;
300 uint last_index = 0;
301
302 guarantee(_head == NULL || _head->prev() == NULL, "_head should not have a prev");
303 while (curr != NULL) {
304 verify_region(curr);
305
306 count++;
307 guarantee(count < _unrealistically_long_length,
308 hrs_err_msg("[%s] the calculated length: %u seems very long, is there maybe a cycle? curr: " PTR_FORMAT " prev0: " PTR_FORMAT " " "prev1: " PTR_FORMAT " length: %u",
309 name(), count, p2i(curr), p2i(prev0), p2i(prev1), length()));
310
311 if (curr->next() != NULL) {
312 guarantee(curr->next()->prev() == curr, "Next or prev pointers messed up");
313 }
314 guarantee(curr->hrm_index() == 0 || curr->hrm_index() > last_index, "List should be sorted");
315 last_index = curr->hrm_index();
316
317 capacity += curr->capacity();
318
319 prev1 = prev0;
320 prev0 = curr;
321 curr = curr->next();
322 }
323
324 guarantee(_tail == prev0, err_msg("Expected %s to end with %u but it ended with %u.", name(), _tail->hrm_index(), prev0->hrm_index()));
325 guarantee(_tail == NULL || _tail->next() == NULL, "_tail should not have a next");
326 guarantee(length() == count, err_msg("%s count mismatch. Expected %u, actual %u.", name(), length(), count));
327 guarantee(total_capacity_bytes() == capacity, err_msg("%s capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
328 name(), total_capacity_bytes(), capacity));
329 }
330
331 // Note on the check_mt_safety() methods below:
332 //
333 // Verification of the "master" heap region sets / lists that are
334 // maintained by G1CollectedHeap is always done during a STW pause and
335 // by the VM thread at the start / end of the pause. The standard
336 // verification methods all assert check_mt_safety(). This is
337 // important as it ensures that verification is done without
338 // concurrent updates taking place at the same time. It follows, that,
339 // for the "master" heap region sets / lists, the check_mt_safety()
340 // method should include the VM thread / STW case.
341
342 void MasterFreeRegionListMtSafeChecker::check() {
343 // Master Free List MT safety protocol:
344 // (a) If we're at a safepoint, operations on the master free list
345 // should be invoked by either the VM thread (which will serialize
346 // them) or by the GC workers while holding the
347 // FreeList_lock.
348 // (b) If we're not at a safepoint, operations on the master free
|
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "gc/g1/g1CollectedHeap.inline.hpp"
27 #include "gc/g1/heapRegionRemSet.hpp"
28 #include "gc/g1/heapRegionSet.inline.hpp"
29
30 uint FreeRegionList::_unrealistically_long_length = 0;
31
32 void HeapRegionSetBase::fill_in_ext_msg(hrs_ext_msg* msg, const char* message) {
33 msg->append("[%s] %s ln: %u cy: " SIZE_FORMAT,
34 name(), message, length(), total_capacity_bytes());
35 fill_in_ext_msg_extra(msg);
36 }
37
38 #ifndef PRODUCT
39 void HeapRegionSetBase::verify_region(HeapRegion* hr) {
40 assert(hr->containing_set() == this, "Inconsistent containing set for %u", hr->hrm_index());
41 assert(!hr->is_young(), "Adding young region %u", hr->hrm_index()); // currently we don't use these sets for young regions
42 assert(hr->is_humongous() == regions_humongous(), "Wrong humongous state for region %u and set %s", hr->hrm_index(), name());
43 assert(hr->is_free() == regions_free(), "Wrong free state for region %u and set %s", hr->hrm_index(), name());
44 assert(!hr->is_free() || hr->is_empty(), "Free region %u is not empty for set %s", hr->hrm_index(), name());
45 assert(!hr->is_empty() || hr->is_free() || hr->is_archive(),
46 "Empty region %u is not free or archive for set %s", hr->hrm_index(), name());
47 assert(hr->rem_set()->verify_ready_for_par_iteration(), "Wrong iteration state %u", hr->hrm_index());
48 }
49 #endif
50
51 void HeapRegionSetBase::verify() {
52 // It's important that we also observe the MT safety protocol even
53 // for the verification calls. If we do verification without the
54 // appropriate locks and the set changes underneath our feet
55 // verification might fail and send us on a wild goose chase.
56 check_mt_safety();
57
58 guarantee(( is_empty() && length() == 0 && total_capacity_bytes() == 0) ||
59 (!is_empty() && length() > 0 && total_capacity_bytes() > 0) ,
60 "%s", hrs_ext_msg(this, "invariant").buffer());
61 }
62
63 void HeapRegionSetBase::verify_start() {
64 // See comment in verify() about MT safety and verification.
65 check_mt_safety();
66 assert(!_verify_in_progress,
67 "%s", hrs_ext_msg(this, "verification should not be in progress").buffer());
68
69 // Do the basic verification first before we do the checks over the regions.
70 HeapRegionSetBase::verify();
71
72 _verify_in_progress = true;
73 }
74
75 void HeapRegionSetBase::verify_end() {
76 // See comment in verify() about MT safety and verification.
77 check_mt_safety();
78 assert(_verify_in_progress,
79 "%s", hrs_ext_msg(this, "verification should be in progress").buffer());
80
81 _verify_in_progress = false;
82 }
83
84 void HeapRegionSetBase::print_on(outputStream* out, bool print_contents) {
85 out->cr();
86 out->print_cr("Set: %s (" PTR_FORMAT ")", name(), p2i(this));
87 out->print_cr(" Region Assumptions");
88 out->print_cr(" humongous : %s", BOOL_TO_STR(regions_humongous()));
89 out->print_cr(" free : %s", BOOL_TO_STR(regions_free()));
90 out->print_cr(" Attributes");
91 out->print_cr(" length : %14u", length());
92 out->print_cr(" total capacity : " SIZE_FORMAT_W(14) " bytes",
93 total_capacity_bytes());
94 }
95
96 HeapRegionSetBase::HeapRegionSetBase(const char* name, bool humongous, bool free, HRSMtSafeChecker* mt_safety_checker)
97 : _name(name), _verify_in_progress(false),
98 _is_humongous(humongous), _is_free(free), _mt_safety_checker(mt_safety_checker),
99 _count()
134 verify_optional();
135 from_list->verify_optional();
136
137 if (from_list->is_empty()) {
138 return;
139 }
140
141 #ifdef ASSERT
142 FreeRegionListIterator iter(from_list);
143 while (iter.more_available()) {
144 HeapRegion* hr = iter.get_next();
145 // In set_containing_set() we check that we either set the value
146 // from NULL to non-NULL or vice versa to catch bugs. So, we have
147 // to NULL it first before setting it to the value.
148 hr->set_containing_set(NULL);
149 hr->set_containing_set(this);
150 }
151 #endif // ASSERT
152
153 if (is_empty()) {
154 assert(length() == 0 && _tail == NULL, "%s", hrs_ext_msg(this, "invariant").buffer());
155 _head = from_list->_head;
156 _tail = from_list->_tail;
157 } else {
158 HeapRegion* curr_to = _head;
159 HeapRegion* curr_from = from_list->_head;
160
161 while (curr_from != NULL) {
162 while (curr_to != NULL && curr_to->hrm_index() < curr_from->hrm_index()) {
163 curr_to = curr_to->next();
164 }
165
166 if (curr_to == NULL) {
167 // The rest of the from list should be added as tail
168 _tail->set_next(curr_from);
169 curr_from->set_prev(_tail);
170 curr_from = NULL;
171 } else {
172 HeapRegion* next_from = curr_from->next();
173
174 curr_from->set_next(curr_to);
181 curr_to->set_prev(curr_from);
182
183 curr_from = next_from;
184 }
185 }
186
187 if (_tail->hrm_index() < from_list->_tail->hrm_index()) {
188 _tail = from_list->_tail;
189 }
190 }
191
192 _count.increment(from_list->length(), from_list->total_capacity_bytes());
193 from_list->clear();
194
195 verify_optional();
196 from_list->verify_optional();
197 }
198
199 void FreeRegionList::remove_starting_at(HeapRegion* first, uint num_regions) {
200 check_mt_safety();
201 assert(num_regions >= 1, "%s", hrs_ext_msg(this, "pre-condition").buffer());
202 assert(!is_empty(), "%s", hrs_ext_msg(this, "pre-condition").buffer());
203
204 verify_optional();
205 DEBUG_ONLY(uint old_length = length();)
206
207 HeapRegion* curr = first;
208 uint count = 0;
209 while (count < num_regions) {
210 verify_region(curr);
211 HeapRegion* next = curr->next();
212 HeapRegion* prev = curr->prev();
213
214 assert(count < num_regions,
215 "%s", hrs_err_msg("[%s] should not come across more regions "
216 "pending for removal than num_regions: %u",
217 name(), num_regions).buffer());
218
219 if (prev == NULL) {
220 assert(_head == curr, "%s", hrs_ext_msg(this, "invariant").buffer());
221 _head = next;
222 } else {
223 assert(_head != curr, "%s", hrs_ext_msg(this, "invariant").buffer());
224 prev->set_next(next);
225 }
226 if (next == NULL) {
227 assert(_tail == curr, "%s", hrs_ext_msg(this, "invariant").buffer());
228 _tail = prev;
229 } else {
230 assert(_tail != curr, "%s", hrs_ext_msg(this, "invariant").buffer());
231 next->set_prev(prev);
232 }
233 if (_last = curr) {
234 _last = NULL;
235 }
236
237 curr->set_next(NULL);
238 curr->set_prev(NULL);
239 remove(curr);
240
241 count++;
242 curr = next;
243 }
244
245 assert(count == num_regions,
246 "%s", hrs_err_msg("[%s] count: %u should be == num_regions: %u",
247 name(), count, num_regions).buffer());
248 assert(length() + num_regions == old_length,
249 "%s", hrs_err_msg("[%s] new length should be consistent "
250 "new length: %u old length: %u num_regions: %u",
251 name(), length(), old_length, num_regions).buffer());
252
253 verify_optional();
254 }
255
256 void FreeRegionList::verify() {
257 // See comment in HeapRegionSetBase::verify() about MT safety and
258 // verification.
259 check_mt_safety();
260
261 // This will also do the basic verification too.
262 verify_start();
263
264 verify_list();
265
266 verify_end();
267 }
268
269 void FreeRegionList::clear() {
270 _count = HeapRegionSetCount();
271 _head = NULL;
288 }
289 }
290
291 out->cr();
292 }
293
294 void FreeRegionList::verify_list() {
295 HeapRegion* curr = _head;
296 HeapRegion* prev1 = NULL;
297 HeapRegion* prev0 = NULL;
298 uint count = 0;
299 size_t capacity = 0;
300 uint last_index = 0;
301
302 guarantee(_head == NULL || _head->prev() == NULL, "_head should not have a prev");
303 while (curr != NULL) {
304 verify_region(curr);
305
306 count++;
307 guarantee(count < _unrealistically_long_length,
308 "%s", hrs_err_msg("[%s] the calculated length: %u seems very long, is there maybe a cycle? curr: " PTR_FORMAT " prev0: " PTR_FORMAT " " "prev1: " PTR_FORMAT " length: %u",
309 name(), count, p2i(curr), p2i(prev0), p2i(prev1), length()).buffer());
310
311 if (curr->next() != NULL) {
312 guarantee(curr->next()->prev() == curr, "Next or prev pointers messed up");
313 }
314 guarantee(curr->hrm_index() == 0 || curr->hrm_index() > last_index, "List should be sorted");
315 last_index = curr->hrm_index();
316
317 capacity += curr->capacity();
318
319 prev1 = prev0;
320 prev0 = curr;
321 curr = curr->next();
322 }
323
324 guarantee(_tail == prev0, "Expected %s to end with %u but it ended with %u.", name(), _tail->hrm_index(), prev0->hrm_index());
325 guarantee(_tail == NULL || _tail->next() == NULL, "_tail should not have a next");
326 guarantee(length() == count, "%s count mismatch. Expected %u, actual %u.", name(), length(), count);
327 guarantee(total_capacity_bytes() == capacity, "%s capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
328 name(), total_capacity_bytes(), capacity);
329 }
330
331 // Note on the check_mt_safety() methods below:
332 //
333 // Verification of the "master" heap region sets / lists that are
334 // maintained by G1CollectedHeap is always done during a STW pause and
335 // by the VM thread at the start / end of the pause. The standard
336 // verification methods all assert check_mt_safety(). This is
337 // important as it ensures that verification is done without
338 // concurrent updates taking place at the same time. It follows, that,
339 // for the "master" heap region sets / lists, the check_mt_safety()
340 // method should include the VM thread / STW case.
341
342 void MasterFreeRegionListMtSafeChecker::check() {
343 // Master Free List MT safety protocol:
344 // (a) If we're at a safepoint, operations on the master free list
345 // should be invoked by either the VM thread (which will serialize
346 // them) or by the GC workers while holding the
347 // FreeList_lock.
348 // (b) If we're not at a safepoint, operations on the master free
|