jdk8-mips64-public/hotspot: comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp

-:ed80554efa25
+:8aae2050e83e
 if (PrintHeapAtGC) {
 Universe::print_heap_before_gc();
 }
+HRSPhaseSetter x(HRSPhaseFullGC);
 verify_region_sets_optional();
 const bool do_clear_all_soft_refs = clear_all_soft_refs ||
 collector_policy()->should_clear_all_soft_refs();
 // Make sure we'll choose a new allocation region afterwards.
 release_mutator_alloc_region();
 abandon_gc_alloc_regions();
 g1_rem_set()->cleanupHRRS();
-tear_down_region_lists();
 // We should call this after we retire any currently active alloc
 // regions so that all the ALLOC / RETIRE events are generated
 // before the start GC event.
 _hr_printer.start_gc(true /* full */, (size_t) total_collections());
 // after this full GC.
 abandon_collection_set(g1_policy()->inc_cset_head());
 g1_policy()->clear_incremental_cset();
 g1_policy()->stop_incremental_cset_building();
-empty_young_list();
+tear_down_region_sets(false /* free_list_only */);
 g1_policy()->set_full_young_gcs(true);
 // See the comments in g1CollectedHeap.hpp and
 // G1CollectedHeap::ref_processing_init() about
 // how reference processing currently works in G1.
 HandleMark hm;  // Discard invalid handles created during gc
 G1MarkSweep::invoke_at_safepoint(ref_processor_stw(), do_clear_all_soft_refs);
 }
 assert(free_regions() == 0, "we should not have added any free regions");
-rebuild_region_lists();
+rebuild_region_sets(false /* free_list_only */);
-_summary_bytes_used = recalculate_used();
 // Enqueue any discovered reference objects that have
 // not been removed from the discovered lists.
 ref_processor_stw()->enqueue_discovered_references();
 abandon_gc_alloc_regions();
 // Instead of tearing down / rebuilding the free lists here, we
 // could instead use the remove_all_pending() method on free_list to
 // remove only the ones that we need to remove.
-tear_down_region_lists();  // We will rebuild them in a moment.
+tear_down_region_sets(true /* free_list_only */);
 shrink_helper(shrink_bytes);
-rebuild_region_lists();
+rebuild_region_sets(true /* free_list_only */);
 _hrs.verify_optional();
 verify_region_sets_optional();
 }
 _g1mm(NULL),
 _refine_cte_cl(NULL),
 _full_collection(false),
 _free_list("Master Free List"),
 _secondary_free_list("Secondary Free List"),
+_old_set("Old Set"),
 _humongous_set("Master Humongous Set"),
 _free_regions_coming(false),
 _young_list(new YoungList(this)),
 _gc_time_stamp(0),
 _retained_old_gc_alloc_region(NULL),
 if (PrintHeapAtGC) {
 Universe::print_heap_before_gc();
 }
+HRSPhaseSetter x(HRSPhaseEvacuation);
 verify_region_sets_optional();
 verify_dirty_young_regions();
 {
 // This call will decide whether this pause is an initial-mark
 !retained_region->in_collection_set() &&
 !(retained_region->top() == retained_region->end()) &&
 !retained_region->is_empty() &&
 !retained_region->isHumongous()) {
 retained_region->set_saved_mark();
+// The retained region was added to the old region set when it was
+// retired. We have to remove it now, since we don't allow regions
+// we allocate to in the region sets. We'll re-add it later, when
+// it's retired again.
+_old_set.remove(retained_region);
 _old_gc_alloc_region.set(retained_region);
 _hr_printer.reuse(retained_region);
 }
 }
 }
 void G1CollectedHeap::free_region_if_empty(HeapRegion* hr,
 size_t* pre_used,
 FreeRegionList* free_list,
+OldRegionSet* old_proxy_set,
 HumongousRegionSet* humongous_proxy_set,
 HRRSCleanupTask* hrrs_cleanup_task,
 bool par) {
 if (hr->used() > 0 && hr->max_live_bytes() == 0 && !hr->is_young()) {
 if (hr->isHumongous()) {
 assert(hr->startsHumongous(), "we should only see starts humongous");
 free_humongous_region(hr, pre_used, free_list, humongous_proxy_set, par);
 } else {
+_old_set.remove_with_proxy(hr, old_proxy_set);
 free_region(hr, pre_used, free_list, par);
 }
 } else {
 hr->rem_set()->do_cleanup_work(hrrs_cleanup_task);
 }
 *pre_used += hr_pre_used;
 }
 void G1CollectedHeap::update_sets_after_freeing_regions(size_t pre_used,
 FreeRegionList* free_list,
+OldRegionSet* old_proxy_set,
 HumongousRegionSet* humongous_proxy_set,
 bool par) {
 if (pre_used > 0) {
 Mutex* lock = (par) ? ParGCRareEvent_lock : NULL;
 MutexLockerEx x(lock, Mutex::_no_safepoint_check_flag);
 _summary_bytes_used -= pre_used;
 }
 if (free_list != NULL && !free_list->is_empty()) {
 MutexLockerEx x(FreeList_lock, Mutex::_no_safepoint_check_flag);
 _free_list.add_as_head(free_list);
+}
+if (old_proxy_set != NULL && !old_proxy_set->is_empty()) {
+MutexLockerEx x(OldSets_lock, Mutex::_no_safepoint_check_flag);
+_old_set.update_from_proxy(old_proxy_set);
 }
 if (humongous_proxy_set != NULL && !humongous_proxy_set->is_empty()) {
 MutexLockerEx x(OldSets_lock, Mutex::_no_safepoint_check_flag);
 _humongous_set.update_from_proxy(humongous_proxy_set);
 }
 cur->uninstall_surv_rate_group();
 if (cur->is_young())
 cur->set_young_index_in_cset(-1);
 cur->set_not_young();
 cur->set_evacuation_failed(false);
+// The region is now considered to be old.
+_old_set.add(cur);
 }
 cur = next;
 }
 policy->record_max_rs_lengths(rs_lengths);
 non_young_time_ms += elapsed_ms;
 else
 young_time_ms += elapsed_ms;
 update_sets_after_freeing_regions(pre_used, &local_free_list,
+NULL /* old_proxy_set */,
 NULL /* humongous_proxy_set */,
 false /* par */);
 policy->record_young_free_cset_time_ms(young_time_ms);
 policy->record_non_young_free_cset_time_ms(non_young_time_ms);
 }
 }
 return ret;
 }
-void G1CollectedHeap::empty_young_list() {
+class TearDownRegionSetsClosure : public HeapRegionClosure {
-assert(heap_lock_held_for_gc(),
+private:
-"the heap lock should already be held by or for this thread");
+OldRegionSet *_old_set;
-_young_list->empty_list();
+public:
-}
+TearDownRegionSetsClosure(OldRegionSet* old_set) : _old_set(old_set) { }
-// Done at the start of full GC.
+bool doHeapRegion(HeapRegion* r) {
-void G1CollectedHeap::tear_down_region_lists() {
+if (r->is_empty()) {
+// We ignore empty regions, we'll empty the free list afterwards
+} else if (r->is_young()) {
+// We ignore young regions, we'll empty the young list afterwards
+} else if (r->isHumongous()) {
+// We ignore humongous regions, we're not tearing down the
+// humongous region set
+} else {
+// The rest should be old
+_old_set->remove(r);
+}
+return false;
+}
+~TearDownRegionSetsClosure() {
+assert(_old_set->is_empty(), "post-condition");
+}
+};
+void G1CollectedHeap::tear_down_region_sets(bool free_list_only) {
+assert_at_safepoint(true /* should_be_vm_thread */);
+if (!free_list_only) {
+TearDownRegionSetsClosure cl(&_old_set);
+heap_region_iterate(&cl);
+// Need to do this after the heap iteration to be able to
+// recognize the young regions and ignore them during the iteration.
+_young_list->empty_list();
+}
 _free_list.remove_all();
 }
-class RegionResetter: public HeapRegionClosure {
+class RebuildRegionSetsClosure : public HeapRegionClosure {
-G1CollectedHeap* _g1h;
+private:
-FreeRegionList _local_free_list;
+bool            _free_list_only;
+OldRegionSet*   _old_set;
+FreeRegionList* _free_list;
+size_t          _total_used;
 public:
-RegionResetter() : _g1h(G1CollectedHeap::heap()),
+RebuildRegionSetsClosure(bool free_list_only,
-_local_free_list("Local Free List for RegionResetter") { }
+OldRegionSet* old_set, FreeRegionList* free_list) :
+_free_list_only(free_list_only),
+_old_set(old_set), _free_list(free_list), _total_used(0) {
+assert(_free_list->is_empty(), "pre-condition");
+if (!free_list_only) {
+assert(_old_set->is_empty(), "pre-condition");
+}
+}
 bool doHeapRegion(HeapRegion* r) {
-if (r->continuesHumongous()) return false;
+if (r->continuesHumongous()) {
-if (r->top() > r->bottom()) {
+return false;
-if (r->top() < r->end()) {
+}
-Copy::fill_to_words(r->top(),
-pointer_delta(r->end(), r->top()));
+if (r->is_empty()) {
+// Add free regions to the free list
+_free_list->add_as_tail(r);
+} else if (!_free_list_only) {
+assert(!r->is_young(), "we should not come across young regions");
+if (r->isHumongous()) {
+// We ignore humongous regions, we left the humongous set unchanged
+} else {
+// The rest should be old, add them to the old set
+_old_set->add(r);
 }
-} else {
+_total_used += r->used();
-assert(r->is_empty(), "tautology");
+}
-_local_free_list.add_as_tail(r);
-}
 return false;
 }
-void update_free_lists() {
+size_t total_used() {
-_g1h->update_sets_after_freeing_regions(0, &_local_free_list, NULL,
+return _total_used;
-false /* par */);
 }
 };
-// Done at the end of full GC.
+void G1CollectedHeap::rebuild_region_sets(bool free_list_only) {
-void G1CollectedHeap::rebuild_region_lists() {
+assert_at_safepoint(true /* should_be_vm_thread */);
-// This needs to go at the end of the full GC.
-RegionResetter rs;
+RebuildRegionSetsClosure cl(free_list_only, &_old_set, &_free_list);
-heap_region_iterate(&rs);
+heap_region_iterate(&cl);
-rs.update_free_lists();
+if (!free_list_only) {
+_summary_bytes_used = cl.total_used();
+}
+assert(_summary_bytes_used == recalculate_used(),
+err_msg("inconsistent _summary_bytes_used, "
+"value: "SIZE_FORMAT" recalculated: "SIZE_FORMAT,
+_summary_bytes_used, recalculate_used()));
 }
 void G1CollectedHeap::set_refine_cte_cl_concurrency(bool concurrent) {
 _refine_cte_cl->set_concurrent(concurrent);
 }
 GCAllocPurpose ap) {
 alloc_region->note_end_of_copying();
 g1_policy()->record_bytes_copied_during_gc(allocated_bytes);
 if (ap == GCAllocForSurvived) {
 young_list()->add_survivor_region(alloc_region);
+} else {
+_old_set.add(alloc_region);
 }
 _hr_printer.retire(alloc_region);
 }
 HeapRegion* SurvivorGCAllocRegion::allocate_new_region(size_t word_size,
 }
 // Heap region set verification
 class VerifyRegionListsClosure : public HeapRegionClosure {
 private:
+FreeRegionList*     _free_list;
+OldRegionSet*       _old_set;
 HumongousRegionSet* _humongous_set;
-FreeRegionList*     _free_list;
 size_t              _region_count;
 public:
-VerifyRegionListsClosure(HumongousRegionSet* humongous_set,
+VerifyRegionListsClosure(OldRegionSet* old_set,
+HumongousRegionSet* humongous_set,
 FreeRegionList* free_list) :
-_humongous_set(humongous_set), _free_list(free_list),
+_old_set(old_set), _humongous_set(humongous_set),
-_region_count(0) { }
+_free_list(free_list), _region_count(0) { }
 size_t region_count()      { return _region_count;      }
 bool doHeapRegion(HeapRegion* hr) {
 _region_count += 1;
 // TODO
 } else if (hr->startsHumongous()) {
 _humongous_set->verify_next_region(hr);
 } else if (hr->is_empty()) {
 _free_list->verify_next_region(hr);
+} else {
+_old_set->verify_next_region(hr);
 }
 return false;
 }
 };
 // the secondary free list we have to take the lock before
 // verifying it.
 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag);
 _secondary_free_list.verify();
 }
+_old_set.verify();
 _humongous_set.verify();
 // If a concurrent region freeing operation is in progress it will
 // be difficult to correctly attributed any free regions we come
 // across to the correct free list given that they might belong to
 // attributed to the free_list.
 append_secondary_free_list_if_not_empty_with_lock();
 // Finally, make sure that the region accounting in the lists is
 // consistent with what we see in the heap.
+_old_set.verify_start();
 _humongous_set.verify_start();
 _free_list.verify_start();
-VerifyRegionListsClosure cl(&_humongous_set, &_free_list);
+VerifyRegionListsClosure cl(&_old_set, &_humongous_set, &_free_list);
 heap_region_iterate(&cl);
+_old_set.verify_end();
 _humongous_set.verify_end();
 _free_list.verify_end();
 }

Mercurial > jdk8-mips64-public > hotspot / file comparison

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

src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp