1 /* 2 * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 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_implementation/g1/g1BlockOffsetTable.inline.hpp" 27 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" 28 #include "gc_implementation/g1/g1OopClosures.inline.hpp" 29 #include "gc_implementation/g1/heapRegion.inline.hpp" 30 #include "gc_implementation/g1/heapRegionRemSet.hpp" 31 #include "gc_implementation/g1/heapRegionSeq.inline.hpp" 32 #include "memory/genOopClosures.inline.hpp" 33 #include "memory/iterator.hpp" 34 #include "oops/oop.inline.hpp" 35 36 int HeapRegion::LogOfHRGrainBytes = 0; 37 int HeapRegion::LogOfHRGrainWords = 0; 38 int HeapRegion::GrainBytes = 0; 39 int HeapRegion::GrainWords = 0; 40 int HeapRegion::CardsPerRegion = 0; 41 42 HeapRegionDCTOC::HeapRegionDCTOC(G1CollectedHeap* g1, 43 HeapRegion* hr, OopClosure* cl, 44 CardTableModRefBS::PrecisionStyle precision, 45 FilterKind fk) : 46 ContiguousSpaceDCTOC(hr, cl, precision, NULL), 47 _hr(hr), _fk(fk), _g1(g1) 48 {} 49 50 FilterOutOfRegionClosure::FilterOutOfRegionClosure(HeapRegion* r, 51 OopClosure* oc) : 52 _r_bottom(r->bottom()), _r_end(r->end()), 53 _oc(oc), _out_of_region(0) 54 {} 55 56 class VerifyLiveClosure: public OopClosure { 57 private: 58 G1CollectedHeap* _g1h; 59 CardTableModRefBS* _bs; 60 oop _containing_obj; 61 bool _failures; 62 int _n_failures; 63 VerifyOption _vo; 64 public: 65 // _vo == UsePrevMarking -> use "prev" marking information, 66 // _vo == UseNextMarking -> use "next" marking information, 67 // _vo == UseMarkWord -> use mark word from object header. 68 VerifyLiveClosure(G1CollectedHeap* g1h, VerifyOption vo) : 69 _g1h(g1h), _bs(NULL), _containing_obj(NULL), 70 _failures(false), _n_failures(0), _vo(vo) 71 { 72 BarrierSet* bs = _g1h->barrier_set(); 73 if (bs->is_a(BarrierSet::CardTableModRef)) 74 _bs = (CardTableModRefBS*)bs; 75 } 76 77 void set_containing_obj(oop obj) { 78 _containing_obj = obj; 79 } 80 81 bool failures() { return _failures; } 82 int n_failures() { return _n_failures; } 83 84 virtual void do_oop(narrowOop* p) { do_oop_work(p); } 85 virtual void do_oop( oop* p) { do_oop_work(p); } 86 87 void print_object(outputStream* out, oop obj) { 88 #ifdef PRODUCT 89 klassOop k = obj->klass(); 90 const char* class_name = instanceKlass::cast(k)->external_name(); 91 out->print_cr("class name %s", class_name); 92 #else // PRODUCT 93 obj->print_on(out); 94 #endif // PRODUCT 95 } 96 97 template <class T> void do_oop_work(T* p) { 98 assert(_containing_obj != NULL, "Precondition"); 99 assert(!_g1h->is_obj_dead_cond(_containing_obj, _vo), 100 "Precondition"); 101 T heap_oop = oopDesc::load_heap_oop(p); 102 if (!oopDesc::is_null(heap_oop)) { 103 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); 104 bool failed = false; 105 if (!_g1h->is_in_closed_subset(obj) || 106 _g1h->is_obj_dead_cond(obj, _vo)) { 107 if (!_failures) { 108 gclog_or_tty->print_cr(""); 109 gclog_or_tty->print_cr("----------"); 110 } 111 if (!_g1h->is_in_closed_subset(obj)) { 112 HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p); 113 gclog_or_tty->print_cr("Field "PTR_FORMAT 114 " of live obj "PTR_FORMAT" in region " 115 "["PTR_FORMAT", "PTR_FORMAT")", 116 p, (void*) _containing_obj, 117 from->bottom(), from->end()); 118 print_object(gclog_or_tty, _containing_obj); 119 gclog_or_tty->print_cr("points to obj "PTR_FORMAT" not in the heap", 120 (void*) obj); 121 } else { 122 HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p); 123 HeapRegion* to = _g1h->heap_region_containing((HeapWord*)obj); 124 gclog_or_tty->print_cr("Field "PTR_FORMAT 125 " of live obj "PTR_FORMAT" in region " 126 "["PTR_FORMAT", "PTR_FORMAT")", 127 p, (void*) _containing_obj, 128 from->bottom(), from->end()); 129 print_object(gclog_or_tty, _containing_obj); 130 gclog_or_tty->print_cr("points to dead obj "PTR_FORMAT" in region " 131 "["PTR_FORMAT", "PTR_FORMAT")", 132 (void*) obj, to->bottom(), to->end()); 133 print_object(gclog_or_tty, obj); 134 } 135 gclog_or_tty->print_cr("----------"); 136 _failures = true; 137 failed = true; 138 _n_failures++; 139 } 140 141 if (!_g1h->full_collection()) { 142 HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p); 143 HeapRegion* to = _g1h->heap_region_containing(obj); 144 if (from != NULL && to != NULL && 145 from != to && 146 !to->isHumongous()) { 147 jbyte cv_obj = *_bs->byte_for_const(_containing_obj); 148 jbyte cv_field = *_bs->byte_for_const(p); 149 const jbyte dirty = CardTableModRefBS::dirty_card_val(); 150 151 bool is_bad = !(from->is_young() 152 || to->rem_set()->contains_reference(p) 153 || !G1HRRSFlushLogBuffersOnVerify && // buffers were not flushed 154 (_containing_obj->is_objArray() ? 155 cv_field == dirty 156 : cv_obj == dirty || cv_field == dirty)); 157 if (is_bad) { 158 if (!_failures) { 159 gclog_or_tty->print_cr(""); 160 gclog_or_tty->print_cr("----------"); 161 } 162 gclog_or_tty->print_cr("Missing rem set entry:"); 163 gclog_or_tty->print_cr("Field "PTR_FORMAT" " 164 "of obj "PTR_FORMAT", " 165 "in region "HR_FORMAT, 166 p, (void*) _containing_obj, 167 HR_FORMAT_PARAMS(from)); 168 _containing_obj->print_on(gclog_or_tty); 169 gclog_or_tty->print_cr("points to obj "PTR_FORMAT" " 170 "in region "HR_FORMAT, 171 (void*) obj, 172 HR_FORMAT_PARAMS(to)); 173 obj->print_on(gclog_or_tty); 174 gclog_or_tty->print_cr("Obj head CTE = %d, field CTE = %d.", 175 cv_obj, cv_field); 176 gclog_or_tty->print_cr("----------"); 177 _failures = true; 178 if (!failed) _n_failures++; 179 } 180 } 181 } 182 } 183 } 184 }; 185 186 template<class ClosureType> 187 HeapWord* walk_mem_region_loop(ClosureType* cl, G1CollectedHeap* g1h, 188 HeapRegion* hr, 189 HeapWord* cur, HeapWord* top) { 190 oop cur_oop = oop(cur); 191 int oop_size = cur_oop->size(); 192 HeapWord* next_obj = cur + oop_size; 193 while (next_obj < top) { 194 // Keep filtering the remembered set. 195 if (!g1h->is_obj_dead(cur_oop, hr)) { 196 // Bottom lies entirely below top, so we can call the 197 // non-memRegion version of oop_iterate below. 198 cur_oop->oop_iterate(cl); 199 } 200 cur = next_obj; 201 cur_oop = oop(cur); 202 oop_size = cur_oop->size(); 203 next_obj = cur + oop_size; 204 } 205 return cur; 206 } 207 208 void HeapRegionDCTOC::walk_mem_region_with_cl(MemRegion mr, 209 HeapWord* bottom, 210 HeapWord* top, 211 OopClosure* cl) { 212 G1CollectedHeap* g1h = _g1; 213 214 int oop_size; 215 216 OopClosure* cl2 = cl; 217 FilterIntoCSClosure intoCSFilt(this, g1h, cl); 218 FilterOutOfRegionClosure outOfRegionFilt(_hr, cl); 219 switch (_fk) { 220 case IntoCSFilterKind: cl2 = &intoCSFilt; break; 221 case OutOfRegionFilterKind: cl2 = &outOfRegionFilt; break; 222 } 223 224 // Start filtering what we add to the remembered set. If the object is 225 // not considered dead, either because it is marked (in the mark bitmap) 226 // or it was allocated after marking finished, then we add it. Otherwise 227 // we can safely ignore the object. 228 if (!g1h->is_obj_dead(oop(bottom), _hr)) { 229 oop_size = oop(bottom)->oop_iterate(cl2, mr); 230 } else { 231 oop_size = oop(bottom)->size(); 232 } 233 234 bottom += oop_size; 235 236 if (bottom < top) { 237 // We replicate the loop below for several kinds of possible filters. 238 switch (_fk) { 239 case NoFilterKind: 240 bottom = walk_mem_region_loop(cl, g1h, _hr, bottom, top); 241 break; 242 case IntoCSFilterKind: { 243 FilterIntoCSClosure filt(this, g1h, cl); 244 bottom = walk_mem_region_loop(&filt, g1h, _hr, bottom, top); 245 break; 246 } 247 case OutOfRegionFilterKind: { 248 FilterOutOfRegionClosure filt(_hr, cl); 249 bottom = walk_mem_region_loop(&filt, g1h, _hr, bottom, top); 250 break; 251 } 252 default: 253 ShouldNotReachHere(); 254 } 255 256 // Last object. Need to do dead-obj filtering here too. 257 if (!g1h->is_obj_dead(oop(bottom), _hr)) { 258 oop(bottom)->oop_iterate(cl2, mr); 259 } 260 } 261 } 262 263 // Minimum region size; we won't go lower than that. 264 // We might want to decrease this in the future, to deal with small 265 // heaps a bit more efficiently. 266 #define MIN_REGION_SIZE ( 1024 * 1024 ) 267 268 // Maximum region size; we don't go higher than that. There's a good 269 // reason for having an upper bound. We don't want regions to get too 270 // large, otherwise cleanup's effectiveness would decrease as there 271 // will be fewer opportunities to find totally empty regions after 272 // marking. 273 #define MAX_REGION_SIZE ( 32 * 1024 * 1024 ) 274 275 // The automatic region size calculation will try to have around this 276 // many regions in the heap (based on the min heap size). 277 #define TARGET_REGION_NUMBER 2048 278 279 void HeapRegion::setup_heap_region_size(uintx min_heap_size) { 280 // region_size in bytes 281 uintx region_size = G1HeapRegionSize; 282 if (FLAG_IS_DEFAULT(G1HeapRegionSize)) { 283 // We base the automatic calculation on the min heap size. This 284 // can be problematic if the spread between min and max is quite 285 // wide, imagine -Xms128m -Xmx32g. But, if we decided it based on 286 // the max size, the region size might be way too large for the 287 // min size. Either way, some users might have to set the region 288 // size manually for some -Xms / -Xmx combos. 289 290 region_size = MAX2(min_heap_size / TARGET_REGION_NUMBER, 291 (uintx) MIN_REGION_SIZE); 292 } 293 294 int region_size_log = log2_long((jlong) region_size); 295 // Recalculate the region size to make sure it's a power of 296 // 2. This means that region_size is the largest power of 2 that's 297 // <= what we've calculated so far. 298 region_size = ((uintx)1 << region_size_log); 299 300 // Now make sure that we don't go over or under our limits. 301 if (region_size < MIN_REGION_SIZE) { 302 region_size = MIN_REGION_SIZE; 303 } else if (region_size > MAX_REGION_SIZE) { 304 region_size = MAX_REGION_SIZE; 305 } 306 307 // And recalculate the log. 308 region_size_log = log2_long((jlong) region_size); 309 310 // Now, set up the globals. 311 guarantee(LogOfHRGrainBytes == 0, "we should only set it once"); 312 LogOfHRGrainBytes = region_size_log; 313 314 guarantee(LogOfHRGrainWords == 0, "we should only set it once"); 315 LogOfHRGrainWords = LogOfHRGrainBytes - LogHeapWordSize; 316 317 guarantee(GrainBytes == 0, "we should only set it once"); 318 // The cast to int is safe, given that we've bounded region_size by 319 // MIN_REGION_SIZE and MAX_REGION_SIZE. 320 GrainBytes = (int) region_size; 321 322 guarantee(GrainWords == 0, "we should only set it once"); 323 GrainWords = GrainBytes >> LogHeapWordSize; 324 guarantee(1 << LogOfHRGrainWords == GrainWords, "sanity"); 325 326 guarantee(CardsPerRegion == 0, "we should only set it once"); 327 CardsPerRegion = GrainBytes >> CardTableModRefBS::card_shift; 328 } 329 330 void HeapRegion::reset_after_compaction() { 331 G1OffsetTableContigSpace::reset_after_compaction(); 332 // After a compaction the mark bitmap is invalid, so we must 333 // treat all objects as being inside the unmarked area. 334 zero_marked_bytes(); 335 init_top_at_mark_start(); 336 } 337 338 DirtyCardToOopClosure* 339 HeapRegion::new_dcto_closure(OopClosure* cl, 340 CardTableModRefBS::PrecisionStyle precision, 341 HeapRegionDCTOC::FilterKind fk) { 342 return new HeapRegionDCTOC(G1CollectedHeap::heap(), 343 this, cl, precision, fk); 344 } 345 346 void HeapRegion::hr_clear(bool par, bool clear_space) { 347 assert(_humongous_type == NotHumongous, 348 "we should have already filtered out humongous regions"); 349 assert(_humongous_start_region == NULL, 350 "we should have already filtered out humongous regions"); 351 assert(_end == _orig_end, 352 "we should have already filtered out humongous regions"); 353 354 _in_collection_set = false; 355 356 set_young_index_in_cset(-1); 357 uninstall_surv_rate_group(); 358 set_young_type(NotYoung); 359 reset_pre_dummy_top(); 360 361 if (!par) { 362 // If this is parallel, this will be done later. 363 HeapRegionRemSet* hrrs = rem_set(); 364 if (hrrs != NULL) hrrs->clear(); 365 _claimed = InitialClaimValue; 366 } 367 zero_marked_bytes(); 368 set_sort_index(-1); 369 370 _offsets.resize(HeapRegion::GrainWords); 371 init_top_at_mark_start(); 372 if (clear_space) clear(SpaceDecorator::Mangle); 373 } 374 375 void HeapRegion::par_clear() { 376 assert(used() == 0, "the region should have been already cleared"); 377 assert(capacity() == (size_t) HeapRegion::GrainBytes, 378 "should be back to normal"); 379 HeapRegionRemSet* hrrs = rem_set(); 380 hrrs->clear(); 381 CardTableModRefBS* ct_bs = 382 (CardTableModRefBS*)G1CollectedHeap::heap()->barrier_set(); 383 ct_bs->clear(MemRegion(bottom(), end())); 384 } 385 386 // <PREDICTION> 387 void HeapRegion::calc_gc_efficiency() { 388 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 389 _gc_efficiency = (double) garbage_bytes() / 390 g1h->predict_region_elapsed_time_ms(this, false); 391 } 392 // </PREDICTION> 393 394 void HeapRegion::set_startsHumongous(HeapWord* new_top, HeapWord* new_end) { 395 assert(!isHumongous(), "sanity / pre-condition"); 396 assert(end() == _orig_end, 397 "Should be normal before the humongous object allocation"); 398 assert(top() == bottom(), "should be empty"); 399 assert(bottom() <= new_top && new_top <= new_end, "pre-condition"); 400 401 _humongous_type = StartsHumongous; 402 _humongous_start_region = this; 403 404 set_end(new_end); 405 _offsets.set_for_starts_humongous(new_top); 406 } 407 408 void HeapRegion::set_continuesHumongous(HeapRegion* first_hr) { 409 assert(!isHumongous(), "sanity / pre-condition"); 410 assert(end() == _orig_end, 411 "Should be normal before the humongous object allocation"); 412 assert(top() == bottom(), "should be empty"); 413 assert(first_hr->startsHumongous(), "pre-condition"); 414 415 _humongous_type = ContinuesHumongous; 416 _humongous_start_region = first_hr; 417 } 418 419 void HeapRegion::set_notHumongous() { 420 assert(isHumongous(), "pre-condition"); 421 422 if (startsHumongous()) { 423 assert(top() <= end(), "pre-condition"); 424 set_end(_orig_end); 425 if (top() > end()) { 426 // at least one "continues humongous" region after it 427 set_top(end()); 428 } 429 } else { 430 // continues humongous 431 assert(end() == _orig_end, "sanity"); 432 } 433 434 assert(capacity() == (size_t) HeapRegion::GrainBytes, "pre-condition"); 435 _humongous_type = NotHumongous; 436 _humongous_start_region = NULL; 437 } 438 439 bool HeapRegion::claimHeapRegion(jint claimValue) { 440 jint current = _claimed; 441 if (current != claimValue) { 442 jint res = Atomic::cmpxchg(claimValue, &_claimed, current); 443 if (res == current) { 444 return true; 445 } 446 } 447 return false; 448 } 449 450 HeapWord* HeapRegion::next_block_start_careful(HeapWord* addr) { 451 HeapWord* low = addr; 452 HeapWord* high = end(); 453 while (low < high) { 454 size_t diff = pointer_delta(high, low); 455 // Must add one below to bias toward the high amount. Otherwise, if 456 // "high" were at the desired value, and "low" were one less, we 457 // would not converge on "high". This is not symmetric, because 458 // we set "high" to a block start, which might be the right one, 459 // which we don't do for "low". 460 HeapWord* middle = low + (diff+1)/2; 461 if (middle == high) return high; 462 HeapWord* mid_bs = block_start_careful(middle); 463 if (mid_bs < addr) { 464 low = middle; 465 } else { 466 high = mid_bs; 467 } 468 } 469 assert(low == high && low >= addr, "Didn't work."); 470 return low; 471 } 472 473 void HeapRegion::initialize(MemRegion mr, bool clear_space, bool mangle_space) { 474 G1OffsetTableContigSpace::initialize(mr, false, mangle_space); 475 hr_clear(false/*par*/, clear_space); 476 } 477 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away 478 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list 479 #endif // _MSC_VER 480 481 482 HeapRegion:: 483 HeapRegion(size_t hrs_index, G1BlockOffsetSharedArray* sharedOffsetArray, 484 MemRegion mr, bool is_zeroed) 485 : G1OffsetTableContigSpace(sharedOffsetArray, mr, is_zeroed), 486 _next_fk(HeapRegionDCTOC::NoFilterKind), _hrs_index(hrs_index), 487 _humongous_type(NotHumongous), _humongous_start_region(NULL), 488 _in_collection_set(false), 489 _next_in_special_set(NULL), _orig_end(NULL), 490 _claimed(InitialClaimValue), _evacuation_failed(false), 491 _prev_marked_bytes(0), _next_marked_bytes(0), _sort_index(-1), 492 _young_type(NotYoung), _next_young_region(NULL), 493 _next_dirty_cards_region(NULL), _next(NULL), _pending_removal(false), 494 #ifdef ASSERT 495 _containing_set(NULL), 496 #endif // ASSERT 497 _young_index_in_cset(-1), _surv_rate_group(NULL), _age_index(-1), 498 _rem_set(NULL), _recorded_rs_length(0), _predicted_elapsed_time_ms(0), 499 _predicted_bytes_to_copy(0) 500 { 501 _orig_end = mr.end(); 502 // Note that initialize() will set the start of the unmarked area of the 503 // region. 504 this->initialize(mr, !is_zeroed, SpaceDecorator::Mangle); 505 set_top(bottom()); 506 set_saved_mark(); 507 508 _rem_set = new HeapRegionRemSet(sharedOffsetArray, this); 509 510 assert(HeapRegionRemSet::num_par_rem_sets() > 0, "Invariant."); 511 // In case the region is allocated during a pause, note the top. 512 // We haven't done any counting on a brand new region. 513 _top_at_conc_mark_count = bottom(); 514 } 515 516 class NextCompactionHeapRegionClosure: public HeapRegionClosure { 517 const HeapRegion* _target; 518 bool _target_seen; 519 HeapRegion* _last; 520 CompactibleSpace* _res; 521 public: 522 NextCompactionHeapRegionClosure(const HeapRegion* target) : 523 _target(target), _target_seen(false), _res(NULL) {} 524 bool doHeapRegion(HeapRegion* cur) { 525 if (_target_seen) { 526 if (!cur->isHumongous()) { 527 _res = cur; 528 return true; 529 } 530 } else if (cur == _target) { 531 _target_seen = true; 532 } 533 return false; 534 } 535 CompactibleSpace* result() { return _res; } 536 }; 537 538 CompactibleSpace* HeapRegion::next_compaction_space() const { 539 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 540 // cast away const-ness 541 HeapRegion* r = (HeapRegion*) this; 542 NextCompactionHeapRegionClosure blk(r); 543 g1h->heap_region_iterate_from(r, &blk); 544 return blk.result(); 545 } 546 547 void HeapRegion::save_marks() { 548 set_saved_mark(); 549 } 550 551 void HeapRegion::oops_in_mr_iterate(MemRegion mr, OopClosure* cl) { 552 HeapWord* p = mr.start(); 553 HeapWord* e = mr.end(); 554 oop obj; 555 while (p < e) { 556 obj = oop(p); 557 p += obj->oop_iterate(cl); 558 } 559 assert(p == e, "bad memregion: doesn't end on obj boundary"); 560 } 561 562 #define HeapRegion_OOP_SINCE_SAVE_MARKS_DEFN(OopClosureType, nv_suffix) \ 563 void HeapRegion::oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl) { \ 564 ContiguousSpace::oop_since_save_marks_iterate##nv_suffix(cl); \ 565 } 566 SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(HeapRegion_OOP_SINCE_SAVE_MARKS_DEFN) 567 568 569 void HeapRegion::oop_before_save_marks_iterate(OopClosure* cl) { 570 oops_in_mr_iterate(MemRegion(bottom(), saved_mark_word()), cl); 571 } 572 573 HeapWord* 574 HeapRegion::object_iterate_mem_careful(MemRegion mr, 575 ObjectClosure* cl) { 576 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 577 // We used to use "block_start_careful" here. But we're actually happy 578 // to update the BOT while we do this... 579 HeapWord* cur = block_start(mr.start()); 580 mr = mr.intersection(used_region()); 581 if (mr.is_empty()) return NULL; 582 // Otherwise, find the obj that extends onto mr.start(). 583 584 assert(cur <= mr.start() 585 && (oop(cur)->klass_or_null() == NULL || 586 cur + oop(cur)->size() > mr.start()), 587 "postcondition of block_start"); 588 oop obj; 589 while (cur < mr.end()) { 590 obj = oop(cur); 591 if (obj->klass_or_null() == NULL) { 592 // Ran into an unparseable point. 593 return cur; 594 } else if (!g1h->is_obj_dead(obj)) { 595 cl->do_object(obj); 596 } 597 if (cl->abort()) return cur; 598 // The check above must occur before the operation below, since an 599 // abort might invalidate the "size" operation. 600 cur += obj->size(); 601 } 602 return NULL; 603 } 604 605 HeapWord* 606 HeapRegion:: 607 oops_on_card_seq_iterate_careful(MemRegion mr, 608 FilterOutOfRegionClosure* cl, 609 bool filter_young, 610 jbyte* card_ptr) { 611 // Currently, we should only have to clean the card if filter_young 612 // is true and vice versa. 613 if (filter_young) { 614 assert(card_ptr != NULL, "pre-condition"); 615 } else { 616 assert(card_ptr == NULL, "pre-condition"); 617 } 618 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 619 620 // If we're within a stop-world GC, then we might look at a card in a 621 // GC alloc region that extends onto a GC LAB, which may not be 622 // parseable. Stop such at the "saved_mark" of the region. 623 if (G1CollectedHeap::heap()->is_gc_active()) { 624 mr = mr.intersection(used_region_at_save_marks()); 625 } else { 626 mr = mr.intersection(used_region()); 627 } 628 if (mr.is_empty()) return NULL; 629 // Otherwise, find the obj that extends onto mr.start(). 630 631 // The intersection of the incoming mr (for the card) and the 632 // allocated part of the region is non-empty. This implies that 633 // we have actually allocated into this region. The code in 634 // G1CollectedHeap.cpp that allocates a new region sets the 635 // is_young tag on the region before allocating. Thus we 636 // safely know if this region is young. 637 if (is_young() && filter_young) { 638 return NULL; 639 } 640 641 assert(!is_young(), "check value of filter_young"); 642 643 // We can only clean the card here, after we make the decision that 644 // the card is not young. And we only clean the card if we have been 645 // asked to (i.e., card_ptr != NULL). 646 if (card_ptr != NULL) { 647 *card_ptr = CardTableModRefBS::clean_card_val(); 648 // We must complete this write before we do any of the reads below. 649 OrderAccess::storeload(); 650 } 651 652 // We used to use "block_start_careful" here. But we're actually happy 653 // to update the BOT while we do this... 654 HeapWord* cur = block_start(mr.start()); 655 assert(cur <= mr.start(), "Postcondition"); 656 657 while (cur <= mr.start()) { 658 if (oop(cur)->klass_or_null() == NULL) { 659 // Ran into an unparseable point. 660 return cur; 661 } 662 // Otherwise... 663 int sz = oop(cur)->size(); 664 if (cur + sz > mr.start()) break; 665 // Otherwise, go on. 666 cur = cur + sz; 667 } 668 oop obj; 669 obj = oop(cur); 670 // If we finish this loop... 671 assert(cur <= mr.start() 672 && obj->klass_or_null() != NULL 673 && cur + obj->size() > mr.start(), 674 "Loop postcondition"); 675 if (!g1h->is_obj_dead(obj)) { 676 obj->oop_iterate(cl, mr); 677 } 678 679 HeapWord* next; 680 while (cur < mr.end()) { 681 obj = oop(cur); 682 if (obj->klass_or_null() == NULL) { 683 // Ran into an unparseable point. 684 return cur; 685 }; 686 // Otherwise: 687 next = (cur + obj->size()); 688 if (!g1h->is_obj_dead(obj)) { 689 if (next < mr.end()) { 690 obj->oop_iterate(cl); 691 } else { 692 // this obj spans the boundary. If it's an array, stop at the 693 // boundary. 694 if (obj->is_objArray()) { 695 obj->oop_iterate(cl, mr); 696 } else { 697 obj->oop_iterate(cl); 698 } 699 } 700 } 701 cur = next; 702 } 703 return NULL; 704 } 705 706 void HeapRegion::print() const { print_on(gclog_or_tty); } 707 void HeapRegion::print_on(outputStream* st) const { 708 if (isHumongous()) { 709 if (startsHumongous()) 710 st->print(" HS"); 711 else 712 st->print(" HC"); 713 } else { 714 st->print(" "); 715 } 716 if (in_collection_set()) 717 st->print(" CS"); 718 else 719 st->print(" "); 720 if (is_young()) 721 st->print(is_survivor() ? " SU" : " Y "); 722 else 723 st->print(" "); 724 if (is_empty()) 725 st->print(" F"); 726 else 727 st->print(" "); 728 st->print(" %5d", _gc_time_stamp); 729 st->print(" PTAMS "PTR_FORMAT" NTAMS "PTR_FORMAT, 730 prev_top_at_mark_start(), next_top_at_mark_start()); 731 G1OffsetTableContigSpace::print_on(st); 732 } 733 734 void HeapRegion::verify(bool allow_dirty) const { 735 bool dummy = false; 736 verify(allow_dirty, VerifyOption_G1UsePrevMarking, /* failures */ &dummy); 737 } 738 739 // This really ought to be commoned up into OffsetTableContigSpace somehow. 740 // We would need a mechanism to make that code skip dead objects. 741 742 void HeapRegion::verify(bool allow_dirty, 743 VerifyOption vo, 744 bool* failures) const { 745 G1CollectedHeap* g1 = G1CollectedHeap::heap(); 746 *failures = false; 747 HeapWord* p = bottom(); 748 HeapWord* prev_p = NULL; 749 VerifyLiveClosure vl_cl(g1, vo); 750 bool is_humongous = isHumongous(); 751 bool do_bot_verify = !is_young(); 752 size_t object_num = 0; 753 while (p < top()) { 754 oop obj = oop(p); 755 size_t obj_size = obj->size(); 756 object_num += 1; 757 758 if (is_humongous != g1->isHumongous(obj_size)) { 759 gclog_or_tty->print_cr("obj "PTR_FORMAT" is of %shumongous size (" 760 SIZE_FORMAT" words) in a %shumongous region", 761 p, g1->isHumongous(obj_size) ? "" : "non-", 762 obj_size, is_humongous ? "" : "non-"); 763 *failures = true; 764 return; 765 } 766 767 // If it returns false, verify_for_object() will output the 768 // appropriate messasge. 769 if (do_bot_verify && !_offsets.verify_for_object(p, obj_size)) { 770 *failures = true; 771 return; 772 } 773 774 if (!g1->is_obj_dead_cond(obj, this, vo)) { 775 if (obj->is_oop()) { 776 klassOop klass = obj->klass(); 777 if (!klass->is_perm()) { 778 gclog_or_tty->print_cr("klass "PTR_FORMAT" of object "PTR_FORMAT" " 779 "not in perm", klass, obj); 780 *failures = true; 781 return; 782 } else if (!klass->is_klass()) { 783 gclog_or_tty->print_cr("klass "PTR_FORMAT" of object "PTR_FORMAT" " 784 "not a klass", klass, obj); 785 *failures = true; 786 return; 787 } else { 788 vl_cl.set_containing_obj(obj); 789 obj->oop_iterate(&vl_cl); 790 if (vl_cl.failures()) { 791 *failures = true; 792 } 793 if (G1MaxVerifyFailures >= 0 && 794 vl_cl.n_failures() >= G1MaxVerifyFailures) { 795 return; 796 } 797 } 798 } else { 799 gclog_or_tty->print_cr(PTR_FORMAT" no an oop", obj); 800 *failures = true; 801 return; 802 } 803 } 804 prev_p = p; 805 p += obj_size; 806 } 807 808 if (p != top()) { 809 gclog_or_tty->print_cr("end of last object "PTR_FORMAT" " 810 "does not match top "PTR_FORMAT, p, top()); 811 *failures = true; 812 return; 813 } 814 815 HeapWord* the_end = end(); 816 assert(p == top(), "it should still hold"); 817 // Do some extra BOT consistency checking for addresses in the 818 // range [top, end). BOT look-ups in this range should yield 819 // top. No point in doing that if top == end (there's nothing there). 820 if (p < the_end) { 821 // Look up top 822 HeapWord* addr_1 = p; 823 HeapWord* b_start_1 = _offsets.block_start_const(addr_1); 824 if (b_start_1 != p) { 825 gclog_or_tty->print_cr("BOT look up for top: "PTR_FORMAT" " 826 " yielded "PTR_FORMAT", expecting "PTR_FORMAT, 827 addr_1, b_start_1, p); 828 *failures = true; 829 return; 830 } 831 832 // Look up top + 1 833 HeapWord* addr_2 = p + 1; 834 if (addr_2 < the_end) { 835 HeapWord* b_start_2 = _offsets.block_start_const(addr_2); 836 if (b_start_2 != p) { 837 gclog_or_tty->print_cr("BOT look up for top + 1: "PTR_FORMAT" " 838 " yielded "PTR_FORMAT", expecting "PTR_FORMAT, 839 addr_2, b_start_2, p); 840 *failures = true; 841 return; 842 } 843 } 844 845 // Look up an address between top and end 846 size_t diff = pointer_delta(the_end, p) / 2; 847 HeapWord* addr_3 = p + diff; 848 if (addr_3 < the_end) { 849 HeapWord* b_start_3 = _offsets.block_start_const(addr_3); 850 if (b_start_3 != p) { 851 gclog_or_tty->print_cr("BOT look up for top + diff: "PTR_FORMAT" " 852 " yielded "PTR_FORMAT", expecting "PTR_FORMAT, 853 addr_3, b_start_3, p); 854 *failures = true; 855 return; 856 } 857 } 858 859 // Loook up end - 1 860 HeapWord* addr_4 = the_end - 1; 861 HeapWord* b_start_4 = _offsets.block_start_const(addr_4); 862 if (b_start_4 != p) { 863 gclog_or_tty->print_cr("BOT look up for end - 1: "PTR_FORMAT" " 864 " yielded "PTR_FORMAT", expecting "PTR_FORMAT, 865 addr_4, b_start_4, p); 866 *failures = true; 867 return; 868 } 869 } 870 871 if (is_humongous && object_num > 1) { 872 gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] is humongous " 873 "but has "SIZE_FORMAT", objects", 874 bottom(), end(), object_num); 875 *failures = true; 876 return; 877 } 878 } 879 880 // G1OffsetTableContigSpace code; copied from space.cpp. Hope this can go 881 // away eventually. 882 883 void G1OffsetTableContigSpace::initialize(MemRegion mr, bool clear_space, bool mangle_space) { 884 // false ==> we'll do the clearing if there's clearing to be done. 885 ContiguousSpace::initialize(mr, false, mangle_space); 886 _offsets.zero_bottom_entry(); 887 _offsets.initialize_threshold(); 888 if (clear_space) clear(mangle_space); 889 } 890 891 void G1OffsetTableContigSpace::clear(bool mangle_space) { 892 ContiguousSpace::clear(mangle_space); 893 _offsets.zero_bottom_entry(); 894 _offsets.initialize_threshold(); 895 } 896 897 void G1OffsetTableContigSpace::set_bottom(HeapWord* new_bottom) { 898 Space::set_bottom(new_bottom); 899 _offsets.set_bottom(new_bottom); 900 } 901 902 void G1OffsetTableContigSpace::set_end(HeapWord* new_end) { 903 Space::set_end(new_end); 904 _offsets.resize(new_end - bottom()); 905 } 906 907 void G1OffsetTableContigSpace::print() const { 908 print_short(); 909 gclog_or_tty->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " 910 INTPTR_FORMAT ", " INTPTR_FORMAT ")", 911 bottom(), top(), _offsets.threshold(), end()); 912 } 913 914 HeapWord* G1OffsetTableContigSpace::initialize_threshold() { 915 return _offsets.initialize_threshold(); 916 } 917 918 HeapWord* G1OffsetTableContigSpace::cross_threshold(HeapWord* start, 919 HeapWord* end) { 920 _offsets.alloc_block(start, end); 921 return _offsets.threshold(); 922 } 923 924 HeapWord* G1OffsetTableContigSpace::saved_mark_word() const { 925 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 926 assert( _gc_time_stamp <= g1h->get_gc_time_stamp(), "invariant" ); 927 if (_gc_time_stamp < g1h->get_gc_time_stamp()) 928 return top(); 929 else 930 return ContiguousSpace::saved_mark_word(); 931 } 932 933 void G1OffsetTableContigSpace::set_saved_mark() { 934 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 935 unsigned curr_gc_time_stamp = g1h->get_gc_time_stamp(); 936 937 if (_gc_time_stamp < curr_gc_time_stamp) { 938 // The order of these is important, as another thread might be 939 // about to start scanning this region. If it does so after 940 // set_saved_mark and before _gc_time_stamp = ..., then the latter 941 // will be false, and it will pick up top() as the high water mark 942 // of region. If it does so after _gc_time_stamp = ..., then it 943 // will pick up the right saved_mark_word() as the high water mark 944 // of the region. Either way, the behaviour will be correct. 945 ContiguousSpace::set_saved_mark(); 946 OrderAccess::storestore(); 947 _gc_time_stamp = curr_gc_time_stamp; 948 // No need to do another barrier to flush the writes above. If 949 // this is called in parallel with other threads trying to 950 // allocate into the region, the caller should call this while 951 // holding a lock and when the lock is released the writes will be 952 // flushed. 953 } 954 } 955 956 G1OffsetTableContigSpace:: 957 G1OffsetTableContigSpace(G1BlockOffsetSharedArray* sharedOffsetArray, 958 MemRegion mr, bool is_zeroed) : 959 _offsets(sharedOffsetArray, mr), 960 _par_alloc_lock(Mutex::leaf, "OffsetTableContigSpace par alloc lock", true), 961 _gc_time_stamp(0) 962 { 963 _offsets.set_space(this); 964 initialize(mr, !is_zeroed, SpaceDecorator::Mangle); 965 }