graal-jvmci-8: src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 20291:e0954897238a

7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS Reviewed-by: jmasa, tschatzl, ehelin Contributed-by: tony.printezis@oracle.com, bengt.rutisson@oracle.com

author	brutisso
date	Tue, 29 Apr 2014 09:33:20 +0200
parents	f3aeae1f9fc5
children	3f2894c5052e

comparison

equal deleted inserted replaced

-:85c339200299
+:e0954897238a
 // If we have continues humongous regions (hr != NULL), then the
 // end of the last one should match new_end and its top should
 // match new_top.
 assert(hr == NULL ||
 (hr->end() == new_end && hr->top() == new_top), "sanity");
+check_bitmaps("Humongous Region Allocation", first_hr);
 assert(first_hr->used() == word_size * HeapWordSize, "invariant");
 _summary_bytes_used += first_hr->used();
 _humongous_set.add(first_hr);
 assert(used() == recalculate_used(), "Should be equal");
 verify_before_gc();
+check_bitmaps("Full GC Start");
 pre_full_gc_dump(gc_timer);
 COMPILER2_PRESENT(DerivedPointerTable::clear());
 // Disable discovery and empty the discovered lists
 _hrs.verify_optional();
 verify_region_sets_optional();
 verify_after_gc();
+// Clear the previous marking bitmap, if needed for bitmap verification.
+// Note we cannot do this when we clear the next marking bitmap in
+// ConcurrentMark::abort() above since VerifyDuringGC verifies the
+// objects marked during a full GC against the previous bitmap.
+// But we need to clear it before calling check_bitmaps below since
+// the full GC has compacted objects and updated TAMS but not updated
+// the prev bitmap.
+if (G1VerifyBitmaps) {
+((CMBitMap*) concurrent_mark()->prevMarkBitMap())->clearAll();
+}
+check_bitmaps("Full GC End");
 // Start a new incremental collection set for the next pause
 assert(g1_policy()->collection_set() == NULL, "must be");
 g1_policy()->start_incremental_cset_building();
 gc_prologue(false);
 increment_total_collections(false /* full gc */);
 increment_gc_time_stamp();
 verify_before_gc();
+check_bitmaps("GC Start");
 COMPILER2_PRESENT(DerivedPointerTable::clear());
 // Please see comment in g1CollectedHeap.hpp and
 // G1CollectedHeap::ref_processing_init() to see how
 // is_gc_active() check to decided which top to use when
 // scanning cards (see CR 7039627).
 increment_gc_time_stamp();
 verify_after_gc();
+check_bitmaps("GC End");
 assert(!ref_processor_stw()->discovery_enabled(), "Postcondition");
 ref_processor_stw()->verify_no_references_recorded();
 // CM reference discovery will be re-enabled if necessary.
 bool locked) {
 assert(!hr->isHumongous(), "this is only for non-humongous regions");
 assert(!hr->is_empty(), "the region should not be empty");
 assert(free_list != NULL, "pre-condition");
+if (G1VerifyBitmaps) {
+MemRegion mr(hr->bottom(), hr->end());
+concurrent_mark()->clearRangePrevBitmap(mr);
+}
 // Clear the card counts for this region.
 // Note: we only need to do this if the region is not young
 // (since we don't refine cards in young regions).
 if (!hr->is_young()) {
 _cg1r->hot_card_cache()->reset_card_counts(hr);
 }
 void G1CollectedHeap::verify_dirty_young_regions() {
 verify_dirty_young_list(_young_list->first_region());
 }
-#endif
+bool G1CollectedHeap::verify_no_bits_over_tams(const char* bitmap_name, CMBitMapRO* bitmap,
+HeapWord* tams, HeapWord* end) {
+guarantee(tams <= end,
+err_msg("tams: "PTR_FORMAT" end: "PTR_FORMAT, tams, end));
+HeapWord* result = bitmap->getNextMarkedWordAddress(tams, end);
+if (result < end) {
+gclog_or_tty->cr();
+gclog_or_tty->print_cr("## wrong marked address on %s bitmap: "PTR_FORMAT,
+bitmap_name, result);
+gclog_or_tty->print_cr("## %s tams: "PTR_FORMAT" end: "PTR_FORMAT,
+bitmap_name, tams, end);
+return false;
+}
+return true;
+}
+bool G1CollectedHeap::verify_bitmaps(const char* caller, HeapRegion* hr) {
+CMBitMapRO* prev_bitmap = concurrent_mark()->prevMarkBitMap();
+CMBitMapRO* next_bitmap = (CMBitMapRO*) concurrent_mark()->nextMarkBitMap();
+HeapWord* bottom = hr->bottom();
+HeapWord* ptams  = hr->prev_top_at_mark_start();
+HeapWord* ntams  = hr->next_top_at_mark_start();
+HeapWord* end    = hr->end();
+bool res_p = verify_no_bits_over_tams("prev", prev_bitmap, ptams, end);
+bool res_n = true;
+// We reset mark_in_progress() before we reset _cmThread->in_progress() and in this window
+// we do the clearing of the next bitmap concurrently. Thus, we can not verify the bitmap
+// if we happen to be in that state.
+if (mark_in_progress() || !_cmThread->in_progress()) {
+res_n = verify_no_bits_over_tams("next", next_bitmap, ntams, end);
+}
+if (!res_p || !res_n) {
+gclog_or_tty->print_cr("#### Bitmap verification failed for "HR_FORMAT,
+HR_FORMAT_PARAMS(hr));
+gclog_or_tty->print_cr("#### Caller: %s", caller);
+return false;
+}
+return true;
+}
+void G1CollectedHeap::check_bitmaps(const char* caller, HeapRegion* hr) {
+if (!G1VerifyBitmaps) return;
+guarantee(verify_bitmaps(caller, hr), "bitmap verification");
+}
+class G1VerifyBitmapClosure : public HeapRegionClosure {
+private:
+const char* _caller;
+G1CollectedHeap* _g1h;
+bool _failures;
+public:
+G1VerifyBitmapClosure(const char* caller, G1CollectedHeap* g1h) :
+_caller(caller), _g1h(g1h), _failures(false) { }
+bool failures() { return _failures; }
+virtual bool doHeapRegion(HeapRegion* hr) {
+if (hr->continuesHumongous()) return false;
+bool result = _g1h->verify_bitmaps(_caller, hr);
+if (!result) {
+_failures = true;
+}
+return false;
+}
+};
+void G1CollectedHeap::check_bitmaps(const char* caller) {
+if (!G1VerifyBitmaps) return;
+G1VerifyBitmapClosure cl(caller, this);
+heap_region_iterate(&cl);
+guarantee(!cl.failures(), "bitmap verification");
+}
+#endif // PRODUCT
 void G1CollectedHeap::cleanUpCardTable() {
 G1SATBCardTableModRefBS* ct_bs = g1_barrier_set();
 double start = os::elapsedTime();
 false /* is_old */,
 false /* do_expand */);
 if (new_alloc_region != NULL) {
 set_region_short_lived_locked(new_alloc_region);
 _hr_printer.alloc(new_alloc_region, G1HRPrinter::Eden, young_list_full);
+check_bitmaps("Mutator Region Allocation", new_alloc_region);
 return new_alloc_region;
 }
 }
 return NULL;
 }
 // for survivors too.
 new_alloc_region->record_top_and_timestamp();
 if (survivor) {
 new_alloc_region->set_survivor();
 _hr_printer.alloc(new_alloc_region, G1HRPrinter::Survivor);
+check_bitmaps("Survivor Region Allocation", new_alloc_region);
 } else {
 _hr_printer.alloc(new_alloc_region, G1HRPrinter::Old);
+check_bitmaps("Old Region Allocation", new_alloc_region);
 }
 bool during_im = g1_policy()->during_initial_mark_pause();
 new_alloc_region->note_start_of_copying(during_im);
 return new_alloc_region;
 } else {

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 20291:e0954897238a