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

equal deleted inserted replaced

-:f2e823305677
+:e582172ff6ff
 ShouldNotReachHere();
 }
 class PostMCRemSetClearClosure: public HeapRegionClosure {
+G1CollectedHeap* _g1h;
 ModRefBarrierSet* _mr_bs;
 public:
-PostMCRemSetClearClosure(ModRefBarrierSet* mr_bs) : _mr_bs(mr_bs) {}
+PostMCRemSetClearClosure(G1CollectedHeap* g1h, ModRefBarrierSet* mr_bs) :
+_g1h(g1h), _mr_bs(mr_bs) { }
 bool doHeapRegion(HeapRegion* r) {
-r->reset_gc_time_stamp();
+if (r->continuesHumongous()) {
-if (r->continuesHumongous())
 return false;
+}
+_g1h->reset_gc_time_stamps(r);
 HeapRegionRemSet* hrrs = r->rem_set();
 if (hrrs != NULL) hrrs->clear();
 // You might think here that we could clear just the cards
 // corresponding to the used region.  But no: if we leave a dirty card
 // in a region we might allocate into, then it would prevent that card
 _mr_bs->clear(MemRegion(r->bottom(), r->end()));
 return false;
 }
 };
+void G1CollectedHeap::clear_rsets_post_compaction() {
-class PostMCRemSetInvalidateClosure: public HeapRegionClosure {
+PostMCRemSetClearClosure rs_clear(this, mr_bs());
-ModRefBarrierSet* _mr_bs;
+heap_region_iterate(&rs_clear);
-public:
+}
-PostMCRemSetInvalidateClosure(ModRefBarrierSet* mr_bs) : _mr_bs(mr_bs) {}
-bool doHeapRegion(HeapRegion* r) {
-if (r->continuesHumongous()) return false;
-if (r->used_region().word_size() != 0) {
-_mr_bs->invalidate(r->used_region(), true /*whole heap*/);
-}
-return false;
-}
-};
 class RebuildRSOutOfRegionClosure: public HeapRegionClosure {
 G1CollectedHeap*   _g1h;
 UpdateRSOopClosure _cl;
 int                _worker_i;
 // We only generate output for non-empty regions.
 if (!hr->is_empty()) {
 if (!hr->isHumongous()) {
 _hr_printer->post_compaction(hr, G1HRPrinter::Old);
 } else if (hr->startsHumongous()) {
-if (hr->capacity() == HeapRegion::GrainBytes) {
+if (hr->region_num() == 1) {
 // single humongous region
 _hr_printer->post_compaction(hr, G1HRPrinter::SingleHumongous);
 } else {
 _hr_printer->post_compaction(hr, G1HRPrinter::StartsHumongous);
 }
 }
 PostCompactionPrinterClosure(G1HRPrinter* hr_printer)
 : _hr_printer(hr_printer) { }
 };
+void G1CollectedHeap::print_hrs_post_compaction() {
+PostCompactionPrinterClosure cl(hr_printer());
+heap_region_iterate(&cl);
+}
 bool G1CollectedHeap::do_collection(bool explicit_gc,
 bool clear_all_soft_refs,
 size_t word_size) {
 assert_at_safepoint(true /* should_be_vm_thread */);
 reset_gc_time_stamp();
 // Since everything potentially moved, we will clear all remembered
 // sets, and clear all cards.  Later we will rebuild remebered
 // sets. We will also reset the GC time stamps of the regions.
-PostMCRemSetClearClosure rs_clear(mr_bs());
+clear_rsets_post_compaction();
-heap_region_iterate(&rs_clear);
+check_gc_time_stamps();
 // Resize the heap if necessary.
 resize_if_necessary_after_full_collection(explicit_gc ? 0 : word_size);
 if (_hr_printer.is_active()) {
 // We should do this after we potentially resize the heap so
 // that all the COMMIT / UNCOMMIT events are generated before
 // the end GC event.
-PostCompactionPrinterClosure cl(hr_printer());
+print_hrs_post_compaction();
-heap_region_iterate(&cl);
 _hr_printer.end_gc(true /* full */, (size_t) total_collections());
 }
 if (_cg1r->use_cache()) {
 _cg1r->clear_and_record_card_counts();
 size_t G1CollectedHeap::capacity() const {
 return _g1_committed.byte_size();
 }
+void G1CollectedHeap::reset_gc_time_stamps(HeapRegion* hr) {
+assert(!hr->continuesHumongous(), "pre-condition");
+hr->reset_gc_time_stamp();
+if (hr->startsHumongous()) {
+uint first_index = hr->hrs_index() + 1;
+uint last_index = hr->last_hc_index();
+for (uint i = first_index; i < last_index; i += 1) {
+HeapRegion* chr = region_at(i);
+assert(chr->continuesHumongous(), "sanity");
+chr->reset_gc_time_stamp();
+}
+}
+}
+#ifndef PRODUCT
+class CheckGCTimeStampsHRClosure : public HeapRegionClosure {
+private:
+unsigned _gc_time_stamp;
+bool _failures;
+public:
+CheckGCTimeStampsHRClosure(unsigned gc_time_stamp) :
+_gc_time_stamp(gc_time_stamp), _failures(false) { }
+virtual bool doHeapRegion(HeapRegion* hr) {
+unsigned region_gc_time_stamp = hr->get_gc_time_stamp();
+if (_gc_time_stamp != region_gc_time_stamp) {
+gclog_or_tty->print_cr("Region "HR_FORMAT" has GC time stamp = %d, "
+"expected %d", HR_FORMAT_PARAMS(hr),
+region_gc_time_stamp, _gc_time_stamp);
+_failures = true;
+}
+return false;
+}
+bool failures() { return _failures; }
+};
+void G1CollectedHeap::check_gc_time_stamps() {
+CheckGCTimeStampsHRClosure cl(_gc_time_stamp);
+heap_region_iterate(&cl);
+guarantee(!cl.failures(), "all GC time stamps should have been reset");
+}
+#endif // PRODUCT
 void G1CollectedHeap::iterate_dirty_card_closure(CardTableEntryClosure* cl,
 DirtyCardQueue* into_cset_dcq,
 bool concurrent,
 int worker_i) {
 // Clean cards in the hot card cache
 OopClosure* _cl;
 public:
 IterateOopClosureRegionClosure(MemRegion mr, OopClosure* cl)
 : _mr(mr), _cl(cl) {}
 bool doHeapRegion(HeapRegion* r) {
-if (! r->continuesHumongous()) {
+if (!r->continuesHumongous()) {
 r->oop_iterate(_cl);
 }
 return false;
 }
 };
 void G1CollectedHeap::heap_region_iterate(HeapRegionClosure* cl) const {
 _hrs.iterate(cl);
 }
-void G1CollectedHeap::heap_region_iterate_from(HeapRegion* r,
-HeapRegionClosure* cl) const {
-_hrs.iterate_from(r, cl);
-}
 void
 G1CollectedHeap::heap_region_par_iterate_chunked(HeapRegionClosure* cl,
-uint worker,
+uint worker_id,
 uint no_of_par_workers,
 jint claim_value) {
 const uint regions = n_regions();
 const uint max_workers = (G1CollectedHeap::use_parallel_gc_threads() ?
 no_of_par_workers :
 1);
 assert(UseDynamicNumberOfGCThreads ||
 no_of_par_workers == workers()->total_workers(),
 "Non dynamic should use fixed number of workers");
 // try to spread out the starting points of the workers
-const uint start_index = regions / max_workers * worker;
+const HeapRegion* start_hr =
+start_region_for_worker(worker_id, no_of_par_workers);
+const uint start_index = start_hr->hrs_index();
 // each worker will actually look at all regions
 for (uint count = 0; count < regions; ++count) {
 const uint index = (start_index + count) % regions;
 assert(0 <= index && index < regions, "sanity");
 OrderAccess::storestore();
 _worker_cset_start_region_time_stamp[worker_i] = gc_time_stamp;
 return result;
 }
+HeapRegion* G1CollectedHeap::start_region_for_worker(uint worker_i,
+uint no_of_par_workers) {
+uint worker_num =
+G1CollectedHeap::use_parallel_gc_threads() ? no_of_par_workers : 1U;
+assert(UseDynamicNumberOfGCThreads ||
+no_of_par_workers == workers()->total_workers(),
+"Non dynamic should use fixed number of workers");
+const uint start_index = n_regions() * worker_i / worker_num;
+return region_at(start_index);
+}
 void G1CollectedHeap::collection_set_iterate(HeapRegionClosure* cl) {
 HeapRegion* r = g1_policy()->collection_set();
 while (r != NULL) {
 HeapRegion* next = r->next_in_collection_set();
 if (cl->doHeapRegion(r)) {
 void G1CollectedHeap::prepare_for_verify() {
 if (SafepointSynchronize::is_at_safepoint() || ! UseTLAB) {
 ensure_parsability(false);
 }
 g1_rem_set()->prepare_for_verify();
+}
+bool G1CollectedHeap::allocated_since_marking(oop obj, HeapRegion* hr,
+VerifyOption vo) {
+switch (vo) {
+case VerifyOption_G1UsePrevMarking:
+return hr->obj_allocated_since_prev_marking(obj);
+case VerifyOption_G1UseNextMarking:
+return hr->obj_allocated_since_next_marking(obj);
+case VerifyOption_G1UseMarkWord:
+return false;
+default:
+ShouldNotReachHere();
+}
+return false; // keep some compilers happy
+}
+HeapWord* G1CollectedHeap::top_at_mark_start(HeapRegion* hr, VerifyOption vo) {
+switch (vo) {
+case VerifyOption_G1UsePrevMarking: return hr->prev_top_at_mark_start();
+case VerifyOption_G1UseNextMarking: return hr->next_top_at_mark_start();
+case VerifyOption_G1UseMarkWord:    return NULL;
+default:                            ShouldNotReachHere();
+}
+return NULL; // keep some compilers happy
+}
+bool G1CollectedHeap::is_marked(oop obj, VerifyOption vo) {
+switch (vo) {
+case VerifyOption_G1UsePrevMarking: return isMarkedPrev(obj);
+case VerifyOption_G1UseNextMarking: return isMarkedNext(obj);
+case VerifyOption_G1UseMarkWord:    return obj->is_gc_marked();
+default:                            ShouldNotReachHere();
+}
+return false; // keep some compilers happy
+}
+const char* G1CollectedHeap::top_at_mark_start_str(VerifyOption vo) {
+switch (vo) {
+case VerifyOption_G1UsePrevMarking: return "PTAMS";
+case VerifyOption_G1UseNextMarking: return "NTAMS";
+case VerifyOption_G1UseMarkWord:    return "NONE";
+default:                            ShouldNotReachHere();
+}
+return NULL; // keep some compilers happy
 }
 class VerifyLivenessOopClosure: public OopClosure {
 G1CollectedHeap* _g1h;
 VerifyOption _vo;
 }
 };
 class VerifyRegionClosure: public HeapRegionClosure {
 private:
-bool         _par;
+bool             _par;
-VerifyOption _vo;
+VerifyOption     _vo;
-bool         _failures;
+bool             _failures;
 public:
 // _vo == UsePrevMarking -> use "prev" marking information,
 // _vo == UseNextMarking -> use "next" marking information,
 // _vo == UseMarkWord    -> use mark word from object header.
 VerifyRegionClosure(bool par, VerifyOption vo)
 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(_vo, &failures);
 if (failures) {
 _failures = true;
 size_t hr_used = hr->used();
 size_t hr_capacity = hr->capacity();
 size_t hr_pre_used = 0;
 _humongous_set.remove_with_proxy(hr, humongous_proxy_set);
+// We need to read this before we make the region non-humongous,
+// otherwise the information will be gone.
+uint last_index = hr->last_hc_index();
 hr->set_notHumongous();
 free_region(hr, &hr_pre_used, free_list, par);
 uint i = hr->hrs_index() + 1;
-uint num = 1;
+while (i < last_index) {
-while (i < n_regions()) {
 HeapRegion* curr_hr = region_at(i);
-if (!curr_hr->continuesHumongous()) {
+assert(curr_hr->continuesHumongous(), "invariant");
-break;
-}
 curr_hr->set_notHumongous();
 free_region(curr_hr, &hr_pre_used, free_list, par);
-num += 1;
 i += 1;
 }
 assert(hr_pre_used == hr_used,
 err_msg("hr_pre_used: "SIZE_FORMAT" and hr_used: "SIZE_FORMAT" "
 "should be the same", hr_pre_used, hr_used));
 }
 }
 void G1CollectedHeap::verify_dirty_young_regions() {
 verify_dirty_young_list(_young_list->first_region());
-verify_dirty_young_list(_young_list->first_survivor_region());
 }
 #endif
 void G1CollectedHeap::cleanUpCardTable() {
 CardTableModRefBS* ct_bs = (CardTableModRefBS*) (barrier_set());

changeset 13336	e582172ff6ff
parent 13289	0f61d0bac1ca
child 13466	9fdf353d5f4c