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

equal deleted inserted replaced

-:3cfab71d6c81
+:5caa1d5f74c1
 #include "gc/g1/g1CollectorPolicy.hpp"
 #include "gc/g1/g1CollectorState.hpp"
 #include "gc/g1/g1ConcurrentRefine.hpp"
 #include "gc/g1/g1ConcurrentRefineThread.hpp"
 #include "gc/g1/g1EvacStats.inline.hpp"
+#include "gc/g1/g1FullCollector.hpp"
 #include "gc/g1/g1FullGCScope.hpp"
 #include "gc/g1/g1GCPhaseTimes.hpp"
 #include "gc/g1/g1HeapSizingPolicy.hpp"
 #include "gc/g1/g1HeapTransition.hpp"
 #include "gc/g1/g1HeapVerifier.hpp"
 #include "gc/g1/g1HotCardCache.hpp"
 #include "gc/g1/g1OopClosures.inline.hpp"
 #include "gc/g1/g1ParScanThreadState.inline.hpp"
 #include "gc/g1/g1Policy.hpp"
 #include "gc/g1/g1RegionToSpaceMapper.hpp"
-#include "gc/g1/g1RemSet.inline.hpp"
+#include "gc/g1/g1RemSet.hpp"
 #include "gc/g1/g1RootClosures.hpp"
 #include "gc/g1/g1RootProcessor.hpp"
-#include "gc/g1/g1SerialFullCollector.hpp"
 #include "gc/g1/g1StringDedup.hpp"
 #include "gc/g1/g1YCTypes.hpp"
 #include "gc/g1/g1YoungRemSetSamplingThread.hpp"
 #include "gc/g1/heapRegion.inline.hpp"
 #include "gc/g1/heapRegionRemSet.hpp"
 // The from card cache is not the memory that is actually committed. So we cannot
 // take advantage of the zero_filled parameter.
 reset_from_card_cache(start_idx, num_regions);
 }
+HeapRegion* G1CollectedHeap::new_heap_region(uint hrs_index,
+MemRegion mr) {
+return new HeapRegion(hrs_index, bot(), mr);
+}
 // Private methods.
 HeapRegion*
 G1CollectedHeap::new_region_try_secondary_free_list(bool is_old) {
 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag);
 MetaspaceGC::compute_new_size();
 }
 void G1CollectedHeap::abort_refinement() {
 if (_hot_card_cache->use_cache()) {
-_hot_card_cache->reset_card_counts();
 _hot_card_cache->reset_hot_cache();
 }
 // Discard all remembered set updates.
 JavaThread::dirty_card_queue_set().abandon_logs();
 ref_processor_stw()->verify_no_references_recorded();
 ref_processor_cm()->verify_no_references_recorded();
 }
 void G1CollectedHeap::print_heap_after_full_collection(G1HeapTransition* heap_transition) {
+// Post collection logging.
+// We should do this after we potentially resize the heap so
+// that all the COMMIT / UNCOMMIT events are generated before
+// the compaction events.
 print_hrm_post_compaction();
 heap_transition->print();
 print_heap_after_gc();
 print_heap_regions();
 #ifdef TRACESPINNING
 verify_before_full_collection(scope->is_explicit_gc());
 gc_prologue(true);
 prepare_heap_for_full_collection();
-G1SerialFullCollector serial(scope, ref_processor_stw());
+G1FullCollector collector(scope, ref_processor_stw(), concurrent_mark()->next_mark_bitmap(), workers()->active_workers());
-serial.prepare_collection();
+collector.prepare_collection();
-serial.collect();
+collector.collect();
-serial.complete_collection();
+collector.complete_collection();
 prepare_heap_for_mutators();
 g1_policy()->record_full_collection_end();
 gc_epilogue(true);
-// Post collection verification.
 verify_after_full_collection();
-// Post collection logging.
-// We should do this after we potentially resize the heap so
-// that all the COMMIT / UNCOMMIT events are generated before
-// the compaction events.
 print_heap_after_full_collection(scope->heap_transition());
 }
 bool G1CollectedHeap::do_full_collection(bool explicit_gc,
 bool clear_all_soft_refs) {
 bool dummy = do_full_collection(true,                /* explicit_gc */
 clear_all_soft_refs);
 }
 void G1CollectedHeap::resize_if_necessary_after_full_collection() {
-// Include bytes that will be pre-allocated to support collections, as "used".
+// Capacity, free and used after the GC counted as full regions to
-const size_t used_after_gc = used();
+// include the waste in the following calculations.
 const size_t capacity_after_gc = capacity();
-const size_t free_after_gc = capacity_after_gc - used_after_gc;
+const size_t used_after_gc = capacity_after_gc - unused_committed_regions_in_bytes();
 // This is enforced in arguments.cpp.
 assert(MinHeapFreeRatio <= MaxHeapFreeRatio,
 "otherwise the code below doesn't make sense");
 if (capacity_after_gc < minimum_desired_capacity) {
 // Don't expand unless it's significant
 size_t expand_bytes = minimum_desired_capacity - capacity_after_gc;
 log_debug(gc, ergo, heap)("Attempt heap expansion (capacity lower than min desired capacity after Full GC). "
-"Capacity: " SIZE_FORMAT "B occupancy: " SIZE_FORMAT "B min_desired_capacity: " SIZE_FORMAT "B (" UINTX_FORMAT " %%)",
+"Capacity: " SIZE_FORMAT "B occupancy: " SIZE_FORMAT "B live: " SIZE_FORMAT "B "
-capacity_after_gc, used_after_gc, minimum_desired_capacity, MinHeapFreeRatio);
+"min_desired_capacity: " SIZE_FORMAT "B (" UINTX_FORMAT " %%)",
+capacity_after_gc, used_after_gc, used(), minimum_desired_capacity, MinHeapFreeRatio);
 expand(expand_bytes, _workers);
 // No expansion, now see if we want to shrink
 } else if (capacity_after_gc > maximum_desired_capacity) {
 // Capacity too large, compute shrinking size
 size_t shrink_bytes = capacity_after_gc - maximum_desired_capacity;
 log_debug(gc, ergo, heap)("Attempt heap shrinking (capacity higher than max desired capacity after Full GC). "
-"Capacity: " SIZE_FORMAT "B occupancy: " SIZE_FORMAT "B min_desired_capacity: " SIZE_FORMAT "B (" UINTX_FORMAT " %%)",
+"Capacity: " SIZE_FORMAT "B occupancy: " SIZE_FORMAT "B live: " SIZE_FORMAT "B "
-capacity_after_gc, used_after_gc, minimum_desired_capacity, MinHeapFreeRatio);
+"maximum_desired_capacity: " SIZE_FORMAT "B (" UINTX_FORMAT " %%)",
+capacity_after_gc, used_after_gc, used(), maximum_desired_capacity, MaxHeapFreeRatio);
 shrink(shrink_bytes);
 }
 }
 size_t G1CollectedHeap::capacity() const {
 return _hrm.length() * HeapRegion::GrainBytes;
 }
+size_t G1CollectedHeap::unused_committed_regions_in_bytes() const {
+return _hrm.total_free_bytes();
+}
 void G1CollectedHeap::reset_gc_time_stamps(HeapRegion* hr) {
 hr->reset_gc_time_stamp();
 }
 #ifndef PRODUCT
 void G1CollectedHeap::heap_region_iterate(HeapRegionClosure* cl) const {
 _hrm.iterate(cl);
 }
-void G1CollectedHeap::heap_region_par_iterate(HeapRegionClosure* cl,
+void G1CollectedHeap::heap_region_par_iterate_from_worker_offset(HeapRegionClosure* cl,
-uint worker_id,
+HeapRegionClaimer *hrclaimer,
-HeapRegionClaimer *hrclaimer) const {
+uint worker_id) const {
-_hrm.par_iterate(cl, worker_id, hrclaimer);
+_hrm.par_iterate(cl, hrclaimer, hrclaimer->offset_for_worker(worker_id));
+}
+void G1CollectedHeap::heap_region_par_iterate_from_start(HeapRegionClosure* cl,
+HeapRegionClaimer *hrclaimer) const {
+_hrm.par_iterate(cl, hrclaimer, 0);
 }
 void G1CollectedHeap::collection_set_iterate(HeapRegionClosure* cl) {
 _collection_set.iterate(cl);
 }
 void G1CollectedHeap::collection_set_iterate_from(HeapRegionClosure *cl, uint worker_id) {
 _collection_set.iterate_from(cl, worker_id, workers()->active_workers());
-}
-HeapRegion* G1CollectedHeap::next_compaction_region(const HeapRegion* from) const {
-HeapRegion* result = _hrm.next_region_in_heap(from);
-while (result != NULL && result->is_pinned()) {
-result = _hrm.next_region_in_heap(result);
-}
-return result;
 }
 HeapWord* G1CollectedHeap::block_start(const void* addr) const {
 HeapRegion* hr = heap_region_containing(addr);
 return hr->block_start(addr);
 const HeapRegion* hr,
 const VerifyOption vo) const {
 switch (vo) {
 case VerifyOption_G1UsePrevMarking: return is_obj_dead(obj, hr);
 case VerifyOption_G1UseNextMarking: return is_obj_ill(obj, hr);
-case VerifyOption_G1UseMarkWord:    return !obj->is_gc_marked() && !hr->is_archive();
+case VerifyOption_G1UseFullMarking: return is_obj_dead_full(obj, hr);
 default:                            ShouldNotReachHere();
 }
 return false; // keep some compilers happy
 }
 bool G1CollectedHeap::is_obj_dead_cond(const oop obj,
 const VerifyOption vo) const {
 switch (vo) {
 case VerifyOption_G1UsePrevMarking: return is_obj_dead(obj);
 case VerifyOption_G1UseNextMarking: return is_obj_ill(obj);
-case VerifyOption_G1UseMarkWord: {
+case VerifyOption_G1UseFullMarking: return is_obj_dead_full(obj);
-HeapRegion* hr = _hrm.addr_to_region((HeapWord*)obj);
-return !obj->is_gc_marked() && !hr->is_archive();
-}
 default:                            ShouldNotReachHere();
 }
 return false; // keep some compilers happy
 }

changeset 47885	5caa1d5f74c1
parent 47799	1772ebf07d1f
child 48100	ab188c22d4b6
child 48105	8d15b1369c7a