jdk-sandbox: comparison hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp

equal deleted inserted replaced

-:efb74fdbd46e
+:290620c08233
 if (VerifyBeforeGC && total_collections() >= VerifyGCStartAt) {
 HandleMark hm;  // Discard invalid handles created during verification
 gclog_or_tty->print(" VerifyBeforeGC:");
 prepare_for_verify();
-Universe::verify(true);
+Universe::verify(/* allow dirty */ true,
+/* silent      */ false,
+/* option      */ VerifyOption_G1UsePrevMarking);
 }
 COMPILER2_PRESENT(DerivedPointerTable::clear());
 // We want to discover references, but not process them yet.
 // Temporarily clear _is_alive_non_header
 ReferenceProcessorIsAliveMutator rp_is_alive_null(ref_processor(), NULL);
 ref_processor()->enable_discovery();
 ref_processor()->setup_policy(do_clear_all_soft_refs);
 // Do collection work
 {
 HandleMark hm;  // Discard invalid handles created during gc
 G1MarkSweep::invoke_at_safepoint(ref_processor(), do_clear_all_soft_refs);
 }
 if (VerifyAfterGC && total_collections() >= VerifyGCStartAt) {
 HandleMark hm;  // Discard invalid handles created during verification
 gclog_or_tty->print(" VerifyAfterGC:");
 prepare_for_verify();
-Universe::verify(false);
+Universe::verify(/* allow dirty */ false,
+/* silent      */ false,
+/* option      */ VerifyOption_G1UsePrevMarking);
 }
 NOT_PRODUCT(ref_processor()->verify_no_references_recorded());
 reset_gc_time_stamp();
 // Since everything potentially moved, we will clear all remembered
 }
 g1_rem_set()->prepare_for_verify();
 }
 class VerifyLivenessOopClosure: public OopClosure {
-G1CollectedHeap* g1h;
+G1CollectedHeap* _g1h;
+VerifyOption _vo;
 public:
-VerifyLivenessOopClosure(G1CollectedHeap* _g1h) {
+VerifyLivenessOopClosure(G1CollectedHeap* g1h, VerifyOption vo):
-g1h = _g1h;
+_g1h(g1h), _vo(vo)
-}
+{ }
 void do_oop(narrowOop *p) { do_oop_work(p); }
 void do_oop(      oop *p) { do_oop_work(p); }
 template <class T> void do_oop_work(T *p) {
 oop obj = oopDesc::load_decode_heap_oop(p);
-guarantee(obj == NULL || !g1h->is_obj_dead(obj),
+guarantee(obj == NULL || !_g1h->is_obj_dead_cond(obj, _vo),
 "Dead object referenced by a not dead object");
 }
 };
 class VerifyObjsInRegionClosure: public ObjectClosure {
 private:
 G1CollectedHeap* _g1h;
 size_t _live_bytes;
 HeapRegion *_hr;
-bool _use_prev_marking;
+VerifyOption _vo;
 public:
-// use_prev_marking == true  -> use "prev" marking information,
+// _vo == UsePrevMarking -> use "prev" marking information,
-// use_prev_marking == false -> use "next" marking information
+// _vo == UseNextMarking -> use "next" marking information,
-VerifyObjsInRegionClosure(HeapRegion *hr, bool use_prev_marking)
+// _vo == UseMarkWord    -> use mark word from object header.
-: _live_bytes(0), _hr(hr), _use_prev_marking(use_prev_marking) {
+VerifyObjsInRegionClosure(HeapRegion *hr, VerifyOption vo)
+: _live_bytes(0), _hr(hr), _vo(vo) {
 _g1h = G1CollectedHeap::heap();
 }
 void do_object(oop o) {
-VerifyLivenessOopClosure isLive(_g1h);
+VerifyLivenessOopClosure isLive(_g1h, _vo);
 assert(o != NULL, "Huh?");
-if (!_g1h->is_obj_dead_cond(o, _use_prev_marking)) {
+if (!_g1h->is_obj_dead_cond(o, _vo)) {
+// If the object is alive according to the mark word,
+// then verify that the marking information agrees.
+// Note we can't verify the contra-positive of the
+// above: if the object is dead (according to the mark
+// word), it may not be marked, or may have been marked
+// but has since became dead, or may have been allocated
+// since the last marking.
+if (_vo == VerifyOption_G1UseMarkWord) {
+guarantee(!_g1h->is_obj_dead(o), "mark word and concurrent mark mismatch");
+}
 o->oop_iterate(&isLive);
 if (!_hr->obj_allocated_since_prev_marking(o)) {
 size_t obj_size = o->size();    // Make sure we don't overflow
 _live_bytes += (obj_size * HeapWordSize);
 }
 }
 };
 class VerifyRegionClosure: public HeapRegionClosure {
 private:
-bool _allow_dirty;
+bool         _allow_dirty;
-bool _par;
+bool         _par;
-bool _use_prev_marking;
+VerifyOption _vo;
-bool _failures;
+bool         _failures;
 public:
-// use_prev_marking == true  -> use "prev" marking information,
+// _vo == UsePrevMarking -> use "prev" marking information,
-// use_prev_marking == false -> use "next" marking information
+// _vo == UseNextMarking -> use "next" marking information,
-VerifyRegionClosure(bool allow_dirty, bool par, bool use_prev_marking)
+// _vo == UseMarkWord    -> use mark word from object header.
+VerifyRegionClosure(bool allow_dirty, bool par, VerifyOption vo)
 : _allow_dirty(allow_dirty),
 _par(par),
-_use_prev_marking(use_prev_marking),
+_vo(vo),
 _failures(false) {}
 bool failures() {
 return _failures;
 }
 bool doHeapRegion(HeapRegion* r) {
 guarantee(_par || r->claim_value() == HeapRegion::InitialClaimValue,
 "Should be unclaimed at verify points.");
 if (!r->continuesHumongous()) {
 bool failures = false;
-r->verify(_allow_dirty, _use_prev_marking, &failures);
+r->verify(_allow_dirty, _vo, &failures);
 if (failures) {
 _failures = true;
 } else {
-VerifyObjsInRegionClosure not_dead_yet_cl(r, _use_prev_marking);
+VerifyObjsInRegionClosure not_dead_yet_cl(r, _vo);
 r->object_iterate(&not_dead_yet_cl);
 if (r->max_live_bytes() < not_dead_yet_cl.live_bytes()) {
 gclog_or_tty->print_cr("["PTR_FORMAT","PTR_FORMAT"] "
 "max_live_bytes "SIZE_FORMAT" "
 "< calculated "SIZE_FORMAT,
 };
 class VerifyRootsClosure: public OopsInGenClosure {
 private:
 G1CollectedHeap* _g1h;
-bool             _use_prev_marking;
+VerifyOption     _vo;
 bool             _failures;
 public:
-// use_prev_marking == true  -> use "prev" marking information,
+// _vo == UsePrevMarking -> use "prev" marking information,
-// use_prev_marking == false -> use "next" marking information
+// _vo == UseNextMarking -> use "next" marking information,
-VerifyRootsClosure(bool use_prev_marking) :
+// _vo == UseMarkWord    -> use mark word from object header.
+VerifyRootsClosure(VerifyOption vo) :
 _g1h(G1CollectedHeap::heap()),
-_use_prev_marking(use_prev_marking),
+_vo(vo),
 _failures(false) { }
 bool failures() { return _failures; }
 template <class T> void do_oop_nv(T* p) {
 T heap_oop = oopDesc::load_heap_oop(p);
 if (!oopDesc::is_null(heap_oop)) {
 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
-if (_g1h->is_obj_dead_cond(obj, _use_prev_marking)) {
+if (_g1h->is_obj_dead_cond(obj, _vo)) {
 gclog_or_tty->print_cr("Root location "PTR_FORMAT" "
 "points to dead obj "PTR_FORMAT, p, (void*) obj);
+if (_vo == VerifyOption_G1UseMarkWord) {
+gclog_or_tty->print_cr("  Mark word: "PTR_FORMAT, (void*)(obj->mark()));
+}
 obj->print_on(gclog_or_tty);
 _failures = true;
 }
 }
 }
 // This is the task used for parallel heap verification.
 class G1ParVerifyTask: public AbstractGangTask {
 private:
 G1CollectedHeap* _g1h;
-bool _allow_dirty;
+bool             _allow_dirty;
-bool _use_prev_marking;
+VerifyOption     _vo;
-bool _failures;
+bool             _failures;
 public:
-// use_prev_marking == true  -> use "prev" marking information,
+// _vo == UsePrevMarking -> use "prev" marking information,
-// use_prev_marking == false -> use "next" marking information
+// _vo == UseNextMarking -> use "next" marking information,
-G1ParVerifyTask(G1CollectedHeap* g1h, bool allow_dirty,
+// _vo == UseMarkWord    -> use mark word from object header.
-bool use_prev_marking) :
+G1ParVerifyTask(G1CollectedHeap* g1h, bool allow_dirty, VerifyOption vo) :
 AbstractGangTask("Parallel verify task"),
 _g1h(g1h),
 _allow_dirty(allow_dirty),
-_use_prev_marking(use_prev_marking),
+_vo(vo),
 _failures(false) { }
 bool failures() {
 return _failures;
 }
 void work(int worker_i) {
 HandleMark hm;
-VerifyRegionClosure blk(_allow_dirty, true, _use_prev_marking);
+VerifyRegionClosure blk(_allow_dirty, true, _vo);
 _g1h->heap_region_par_iterate_chunked(&blk, worker_i,
 HeapRegion::ParVerifyClaimValue);
 if (blk.failures()) {
 _failures = true;
 }
 }
 };
 void G1CollectedHeap::verify(bool allow_dirty, bool silent) {
-verify(allow_dirty, silent, /* use_prev_marking */ true);
+verify(allow_dirty, silent, VerifyOption_G1UsePrevMarking);
 }
 void G1CollectedHeap::verify(bool allow_dirty,
 bool silent,
-bool use_prev_marking) {
+VerifyOption vo) {
 if (SafepointSynchronize::is_at_safepoint() || ! UseTLAB) {
 if (!silent) { gclog_or_tty->print("Roots (excluding permgen) "); }
-VerifyRootsClosure rootsCl(use_prev_marking);
+VerifyRootsClosure rootsCl(vo);
 CodeBlobToOopClosure blobsCl(&rootsCl, /*do_marking=*/ false);
 // We apply the relevant closures to all the oops in the
 // system dictionary, the string table and the code cache.
 const int so = SharedHeap::SO_AllClasses | SharedHeap::SO_Strings | SharedHeap::SO_CodeCache;
 process_strong_roots(true,      // activate StrongRootsScope
 true,      // we set "collecting perm gen" to true,
 // so we don't reset the dirty cards in the perm gen.
 SharedHeap::ScanningOption(so),  // roots scanning options
 &rootsCl,
 &blobsCl,
 &rootsCl);
-// Since we used "collecting_perm_gen" == true above, we will not have
-// checked the refs from perm into the G1-collected heap. We check those
+// If we're verifying after the marking phase of a Full GC then we can't
-// references explicitly below. Whether the relevant cards are dirty
+// treat the perm gen as roots into the G1 heap. Some of the objects in
-// is checked further below in the rem set verification.
+// the perm gen may be dead and hence not marked. If one of these dead
-if (!silent) { gclog_or_tty->print("Permgen roots "); }
+// objects is considered to be a root then we may end up with a false
-perm_gen()->oop_iterate(&rootsCl);
+// "Root location <x> points to dead ob <y>" failure.
+if (vo != VerifyOption_G1UseMarkWord) {
+// Since we used "collecting_perm_gen" == true above, we will not have
+// checked the refs from perm into the G1-collected heap. We check those
+// references explicitly below. Whether the relevant cards are dirty
+// is checked further below in the rem set verification.
+if (!silent) { gclog_or_tty->print("Permgen roots "); }
+perm_gen()->oop_iterate(&rootsCl);
+}
 bool failures = rootsCl.failures();
-if (!silent) { gclog_or_tty->print("HeapRegionSets "); }
-verify_region_sets();
+if (vo != VerifyOption_G1UseMarkWord) {
+// If we're verifying during a full GC then the region sets
+// will have been torn down at the start of the GC. Therefore
+// verifying the region sets will fail. So we only verify
+// the region sets when not in a full GC.
+if (!silent) { gclog_or_tty->print("HeapRegionSets "); }
+verify_region_sets();
+}
 if (!silent) { gclog_or_tty->print("HeapRegions "); }
 if (GCParallelVerificationEnabled && ParallelGCThreads > 1) {
 assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue),
 "sanity check");
-G1ParVerifyTask task(this, allow_dirty, use_prev_marking);
+G1ParVerifyTask task(this, allow_dirty, vo);
 int n_workers = workers()->total_workers();
 set_par_threads(n_workers);
 workers()->run_task(&task);
 set_par_threads(0);
 if (task.failures()) {
 reset_heap_region_claim_values();
 assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue),
 "sanity check");
 } else {
-VerifyRegionClosure blk(allow_dirty, false, use_prev_marking);
+VerifyRegionClosure blk(allow_dirty, false, vo);
 heap_region_iterate(&blk);
 if (blk.failures()) {
 failures = true;
 }
 }
 print_on(gclog_or_tty, true /* extended */);
 gclog_or_tty->print_cr("");
 #ifndef PRODUCT
 if (VerifyDuringGC && G1VerifyDuringGCPrintReachable) {
 concurrent_mark()->print_reachable("at-verification-failure",
-use_prev_marking, false /* all */);
+vo, false /* all */);
 }
 #endif
 gclog_or_tty->flush();
 }
 guarantee(!failures, "there should not have been any failures");
 _cmThread->set_started();
 CGC_lock->notify();
 }
 }
-class VerifyMarkedObjsClosure: public ObjectClosure {
-G1CollectedHeap* _g1h;
-public:
-VerifyMarkedObjsClosure(G1CollectedHeap* g1h) : _g1h(g1h) {}
-void do_object(oop obj) {
-assert(obj->mark()->is_marked() ? !_g1h->is_obj_dead(obj) : true,
-"markandsweep mark should agree with concurrent deadness");
-}
-};
-void
-G1CollectedHeap::checkConcurrentMark() {
-VerifyMarkedObjsClosure verifycl(this);
-//    MutexLockerEx x(getMarkBitMapLock(),
-//              Mutex::_no_safepoint_check_flag);
-object_iterate(&verifycl, false);
-}
 void G1CollectedHeap::do_sync_mark() {
 _cm->checkpointRootsInitial();
 _cm->markFromRoots();
 _cm->checkpointRootsFinal(false);
 }
 if (VerifyBeforeGC && total_collections() >= VerifyGCStartAt) {
 HandleMark hm;  // Discard invalid handles created during verification
 gclog_or_tty->print(" VerifyBeforeGC:");
 prepare_for_verify();
-Universe::verify(false);
+Universe::verify(/* allow dirty */ false,
+/* silent      */ false,
+/* option      */ VerifyOption_G1UsePrevMarking);
 }
 COMPILER2_PRESENT(DerivedPointerTable::clear());
 // Please see comment in G1CollectedHeap::ref_processing_init()
 if (VerifyAfterGC && total_collections() >= VerifyGCStartAt) {
 HandleMark hm;  // Discard invalid handles created during verification
 gclog_or_tty->print(" VerifyAfterGC:");
 prepare_for_verify();
-Universe::verify(false);
+Universe::verify(/* allow dirty */ true,
+/* silent      */ false,
+/* option      */ VerifyOption_G1UsePrevMarking);
 }
 if (was_enabled) ref_processor()->enable_discovery();
 {

changeset 9995	290620c08233
parent 9989	305a76435cf1
child 9997	b75b7939f448