truffle: src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 3772:6747fd0512e0

7004681: G1: Extend marking verification to Full GCs Summary: Perform a heap verification after the first phase of G1's full GC using objects' mark words to determine liveness. The third parameter of the heap verification routines, which was used in G1 to determine which marking bitmap to use in liveness calculations, has been changed from a boolean to an enum with values defined for using the mark word, and the 'prev' and 'next' bitmaps. Reviewed-by: tonyp, ysr

author	johnc
date	Tue, 14 Jun 2011 11:01:10 -0700
parents	c3f1170908be
children	c9ca3f51cf41

comparison

equal deleted inserted replaced

-:842b840e67db
+:6747fd0512e0
 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();
 {

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 3772:6747fd0512e0