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

equal deleted inserted replaced

-:73d05e56ec86
+:cb68e4923223
 JavaThread::dirty_card_queue_set().abandon_logs();
 assert(dirty_card_queue_set().completed_buffers_num() == 0, "DCQS should be empty");
 // At this point there should be no regions in the
 // entire heap tagged as young.
-assert(check_young_list_empty(true /* check_heap */),
+assert(check_young_list_empty(), "young list should be empty at this point");
-"young list should be empty at this point");
 // Update the number of full collections that have been completed.
 increment_old_marking_cycles_completed(false /* concurrent */);
 _hrm.verify_optional();
 _humongous_set("Master Humongous Set", true /* humongous */, new HumongousRegionSetMtSafeChecker()),
 _humongous_reclaim_candidates(),
 _has_humongous_reclaim_candidates(false),
 _archive_allocator(NULL),
 _free_regions_coming(false),
-_young_list(new YoungList(this)),
 _gc_time_stamp(0),
 _summary_bytes_used(0),
 _survivor_evac_stats("Young", YoungPLABSize, PLABWeight),
 _old_evac_stats("Old", OldPLABSize, PLABWeight),
 _expand_heap_after_alloc_failure(true),
 bool G1CollectedHeap::supports_tlab_allocation() const {
 return true;
 }
 size_t G1CollectedHeap::tlab_capacity(Thread* ignored) const {
-return (_g1_policy->young_list_target_length() - young_list()->survivor_length()) * HeapRegion::GrainBytes;
+return (_g1_policy->young_list_target_length() - _survivor.length()) * HeapRegion::GrainBytes;
 }
 size_t G1CollectedHeap::tlab_used(Thread* ignored) const {
-return young_list()->eden_used_bytes();
+return _eden.length() * HeapRegion::GrainBytes;
 }
 // For G1 TLABs should not contain humongous objects, so the maximum TLAB size
 // must be equal to the humongous object limit.
 size_t G1CollectedHeap::max_tlab_size() const {
 p2i(_hrm.reserved().start()),
 p2i(_hrm.reserved().start() + _hrm.length() + HeapRegion::GrainWords),
 p2i(_hrm.reserved().end()));
 st->cr();
 st->print("  region size " SIZE_FORMAT "K, ", HeapRegion::GrainBytes / K);
-uint young_regions = _young_list->length();
+uint young_regions = young_regions_count();
 st->print("%u young (" SIZE_FORMAT "K), ", young_regions,
 (size_t) young_regions * HeapRegion::GrainBytes / K);
-uint survivor_regions = _young_list->survivor_length();
+uint survivor_regions = survivor_regions_count();
 st->print("%u survivors (" SIZE_FORMAT "K)", survivor_regions,
 (size_t) survivor_regions * HeapRegion::GrainBytes / K);
 st->cr();
 MetaspaceAux::print_on(st);
 }
 heap_region_iterate(&cl);
 }
 #endif // PRODUCT
 G1HeapSummary G1CollectedHeap::create_g1_heap_summary() {
-YoungList* young_list = heap()->young_list();
+size_t eden_used_bytes = heap()->eden_regions_count() * HeapRegion::GrainBytes;
-size_t eden_used_bytes = young_list->eden_used_bytes();
+size_t survivor_used_bytes = heap()->survivor_regions_count() * HeapRegion::GrainBytes;
-size_t survivor_used_bytes = young_list->survivor_used_bytes();
 size_t heap_used = Heap_lock->owned_by_self() ? used() : used_unlocked();
 size_t eden_capacity_bytes =
 (g1_policy()->young_list_target_length() * HeapRegion::GrainBytes) - survivor_used_bytes;
 }
 G1HeapTransition heap_transition(this);
 size_t heap_used_bytes_before_gc = used();
-assert(check_young_list_well_formed(), "young list should be well formed");
 // Don't dynamically change the number of GC threads this early.  A value of
 // 0 is used to indicate serial work.  When parallel work is done,
 // it will be set.
 { // Call to jvmpi::post_class_unload_events must occur outside of active GC
 if (collector_state()->during_initial_mark_pause()) {
 concurrent_mark()->checkpointRootsInitialPre();
 }
-g1_policy()->finalize_collection_set(target_pause_time_ms);
+g1_policy()->finalize_collection_set(target_pause_time_ms, &_survivor);
 evacuation_info.set_collectionset_regions(collection_set()->region_length());
 // Make sure the remembered sets are up to date. This needs to be
 // done before register_humongous_regions_with_cset(), because the
 // Start a new incremental collection set for the next pause.
 collection_set()->start_incremental_building();
 clear_cset_fast_test();
-// Don't check the whole heap at this point as the
+guarantee(_eden.length() == 0, "eden should have been cleared");
-// GC alloc regions from this pause have been tagged
+g1_policy()->transfer_survivors_to_cset(survivor());
-// as survivors and moved on to the survivor list.
-// Survivor regions will fail the !is_young() check.
-assert(check_young_list_empty(false /* check_heap */),
-"young list should be empty");
-_young_list->reset_auxilary_lists();
 if (evacuation_failed()) {
 set_used(recalculate_used());
 if (_archive_allocator != NULL) {
 _archive_allocator->clear_used();
 FreeRegionList local_free_list("Local List for CSet Freeing");
 double young_time_ms     = 0.0;
 double non_young_time_ms = 0.0;
-// Since the collection set is a superset of the the young list,
+_eden.clear();
-// all we need to do to clear the young list is clear its
-// head and length, and unlink any young regions in the code below
-_young_list->clear();
 G1Policy* policy = g1_policy();
 double start_sec = os::elapsedTime();
 bool non_young = true;
 assert(index != -1, "invariant");
 assert((uint) index < collection_set()->young_region_length(), "invariant");
 size_t words_survived = surviving_young_words[index];
 cur->record_surv_words_in_group(words_survived);
-// At this point the we have 'popped' cur from the collection set
-// (linked via next_in_collection_set()) but it is still in the
-// young list (linked via next_young_region()). Clear the
-// _next_young_region field.
-cur->set_next_young_region(NULL);
 } else {
 int index = cur->young_index_in_cset();
 assert(index == -1, "invariant");
 }
 bool G1CollectedHeap::is_old_gc_alloc_region(HeapRegion* hr) {
 return _allocator->is_retained_old_region(hr);
 }
 void G1CollectedHeap::set_region_short_lived_locked(HeapRegion* hr) {
-_young_list->push_region(hr);
+_eden.add(hr);
-}
+_g1_policy->set_region_eden(hr);
+}
+#ifdef ASSERT
 class NoYoungRegionsClosure: public HeapRegionClosure {
 private:
 bool _success;
 public:
 return false;
 }
 bool success() { return _success; }
 };
-bool G1CollectedHeap::check_young_list_empty(bool check_heap) {
+bool G1CollectedHeap::check_young_list_empty() {
-bool ret = _young_list->check_list_empty();
+bool ret = (young_regions_count() == 0);
-if (check_heap) {
+NoYoungRegionsClosure closure;
-NoYoungRegionsClosure closure;
+heap_region_iterate(&closure);
-heap_region_iterate(&closure);
+ret = ret && closure.success();
-ret = ret && closure.success();
-}
 return ret;
 }
+#endif // ASSERT
 class TearDownRegionSetsClosure : public HeapRegionClosure {
 private:
 HeapRegionSet *_old_set;
 TearDownRegionSetsClosure(HeapRegionSet* old_set) : _old_set(old_set) { }
 bool doHeapRegion(HeapRegion* r) {
 if (r->is_old()) {
 _old_set->remove(r);
+} else if(r->is_young()) {
+r->uninstall_surv_rate_group();
 } else {
 // We ignore free regions, we'll empty the free list afterwards.
-// We ignore young regions, we'll empty the young list afterwards.
 // We ignore humongous regions, we're not tearing down the
 // humongous regions set.
-assert(r->is_free() || r->is_young() || r->is_humongous(),
+assert(r->is_free() || r->is_humongous(),
 "it cannot be another type");
 }
 return false;
 }
 // Add free regions to the free list
 r->set_free();
 r->set_allocation_context(AllocationContext::system());
 _hrm->insert_into_free_list(r);
 } else if (!_free_list_only) {
-assert(!r->is_young(), "we should not come across young regions");
 if (r->is_humongous()) {
 // We ignore humongous regions. We left the humongous set unchanged.
 } else {
-// Objects that were compacted would have ended up on regions
+assert(r->is_young() || r->is_free() || r->is_old(), "invariant");
-// that were previously old or free.  Archive regions (which are
+// We now consider all regions old, so register as such. Leave
-// old) will not have been touched.
-assert(r->is_free() || r->is_old(), "invariant");
-// We now consider them old, so register as such. Leave
 // archive regions set that way, however, while still adding
 // them to the old set.
 if (!r->is_archive()) {
 r->set_old();
 }
 void G1CollectedHeap::rebuild_region_sets(bool free_list_only) {
 assert_at_safepoint(true /* should_be_vm_thread */);
 if (!free_list_only) {
-_young_list->empty_list();
+_eden.clear();
+_survivor.clear();
 }
 RebuildRegionSetsClosure cl(free_list_only, &_old_set, &_hrm);
 heap_region_iterate(&cl);
 bool G1CollectedHeap::has_more_regions(InCSetState dest) {
 if (dest.is_old()) {
 return true;
 } else {
-return young_list()->survivor_length() < g1_policy()->max_survivor_regions();
+return survivor_regions_count() < g1_policy()->max_survivor_regions();
 }
 }
 HeapRegion* G1CollectedHeap::new_gc_alloc_region(size_t word_size, InCSetState dest) {
 assert(FreeList_lock->owned_by_self(), "pre-condition");
 // should never scan survivors. But it doesn't hurt to do it
 // for survivors too.
 new_alloc_region->record_timestamp();
 if (is_survivor) {
 new_alloc_region->set_survivor();
-young_list()->add_survivor_region(new_alloc_region);
+_survivor.add(new_alloc_region);
 _verifier->check_bitmaps("Survivor Region Allocation", new_alloc_region);
 } else {
 new_alloc_region->set_old();
 _verifier->check_bitmaps("Old Region Allocation", new_alloc_region);
 }

changeset 38183	cb68e4923223
parent 38172	90f405aac699
child 38185	c432f8466c73