From 94419d5ddc34bf5f79a9a41c8ef0f3e3e831e626 Mon Sep 17 00:00:00 2001 From: kuenking111 Date: Fri, 10 Dec 2021 12:19:05 +0800 Subject: [PATCH] I4LXX3: G1Ucommit Refactor Trigger mechanism --- G1Ucommit-Refactor-Trigger-mechanism.patch | 630 +++++++++++++++++++++ openjdk-1.8.0.spec | 7 +- 2 files changed, 636 insertions(+), 1 deletion(-) create mode 100755 G1Ucommit-Refactor-Trigger-mechanism.patch diff --git a/G1Ucommit-Refactor-Trigger-mechanism.patch b/G1Ucommit-Refactor-Trigger-mechanism.patch new file mode 100755 index 0000000..99b7c20 --- /dev/null +++ b/G1Ucommit-Refactor-Trigger-mechanism.patch @@ -0,0 +1,630 @@ +From f6f0d05f65a35672f48f63d7e8f73a8c2f56d1c3 Mon Sep 17 00:00:00 2001 +From: mashoubing +Date: Wed, 25 Aug 2021 14:22:13 +0800 +Subject: [PATCH 4/4] G1Ucommit: Refactor Trigger mechanism + +--- + .../g1/concurrentG1RefineThread.cpp | 65 --------------- + .../g1/concurrentG1RefineThread.hpp | 1 - + .../gc_implementation/g1/concurrentMark.cpp | 2 +- + .../gc_implementation/g1/g1CollectedHeap.cpp | 51 ++++++++---- + .../gc_implementation/g1/g1CollectedHeap.hpp | 5 +- + .../g1/g1CollectorPolicy.cpp | 60 -------------- + .../g1/g1CollectorPolicy.hpp | 20 +---- + .../gc_implementation/g1/g1UncommitThread.cpp | 82 ++++++++++++++++++- + .../gc_implementation/g1/g1UncommitThread.hpp | 2 + + .../g1/heapRegionManager.cpp | 28 ++++--- + .../g1/heapRegionManager.hpp | 2 +- + .../g1/heapRegionManager.inline.hpp | 2 +- + 12 files changed, 142 insertions(+), 178 deletions(-) + +diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.cpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.cpp +index 98a43ba62..e4ec84895 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.cpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.cpp +@@ -100,69 +100,6 @@ void ConcurrentG1RefineThread::sample_young_list_rs_lengths() { + } + } + +-bool ConcurrentG1RefineThread::should_start_periodic_gc() { +- // If we are currently in a concurrent mark we are going to uncommit memory soon. +- if (G1CollectedHeap::heap()->concurrent_mark()->cmThread()->during_cycle()) { +- if (G1UncommitLog) { +- gclog_or_tty->print_cr("Concurrent cycle in progress. Skipping."); +- } +- return false; +- } +- +- // Check if enough time has passed since the last GC. +- uintx time_since_last_gc; +- if ((time_since_last_gc = (uintx)Universe::heap()->millis_since_last_gc()) < G1PeriodicGCInterval) { +- if (G1UncommitLog) { +- gclog_or_tty->print_cr("Last GC occurred " UINTX_FORMAT "ms before which is below threshold " UINTX_FORMAT "ms. Skipping.", +- time_since_last_gc, G1PeriodicGCInterval); +- } +- return false; +- } +- +- return true; +-} +- +-void ConcurrentG1RefineThread::check_for_periodic_gc() { +- if (!G1Uncommit) { +- return; +- } +- +- assert(G1PeriodicGCInterval > 0, "just checking"); +- double recent_load = -1.0; +- G1CollectedHeap* g1h = G1CollectedHeap::heap(); +- G1CollectorPolicy* g1p = g1h->g1_policy(); +- if (G1PeriodicGCLoadThreshold) { +- // Sample process load and store it +- if (G1PeriodicGCProcessLoad) { +- recent_load = os::get_process_load() * 100; +- } +- if (recent_load < 0) { +- // Fallback to os load +- G1PeriodicGCProcessLoad = false; +- if (os::loadavg(&recent_load, 1) != -1) { +- static int cpu_count = os::active_processor_count(); +- assert(cpu_count > 0, "just checking"); +- recent_load = recent_load * 100 / cpu_count; +- } +- } +- if (recent_load >= 0) { +- g1p->add_os_load(recent_load); +- } +- } +- +- double now = os::elapsedTime(); +- if (now - _last_periodic_gc_attempt_s > G1PeriodicGCInterval / 1000.0) { +- if (G1UncommitLog) { +- recent_load < 0 ? gclog_or_tty->print_cr("Checking for periodic GC.") +- : gclog_or_tty->print_cr("Checking for periodic GC. Current load %1.2f. Heap total " UINT32_FORMAT " free " UINT32_FORMAT, recent_load, g1h->_hrm.length(), g1h->_hrm.num_free_regions()); +- } +- if (should_start_periodic_gc()) { +- g1p->set_periodic_gc(); +- } +- _last_periodic_gc_attempt_s = now; +- } +-} +- + void ConcurrentG1RefineThread::run_young_rs_sampling() { + DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); + _vtime_start = os::elapsedVTime(); +@@ -175,8 +112,6 @@ void ConcurrentG1RefineThread::run_young_rs_sampling() { + _vtime_accum = 0.0; + } + +- check_for_periodic_gc(); +- + MutexLockerEx x(_monitor, Mutex::_no_safepoint_check_flag); + if (_should_terminate) { + break; +diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.hpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.hpp +index 8fa521371..6c712fd2d 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.hpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.hpp +@@ -71,7 +71,6 @@ class ConcurrentG1RefineThread: public ConcurrentGCThread { + void deactivate(); + + void check_for_periodic_gc(); +- bool should_start_periodic_gc(); + + public: + virtual void run(); +diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp +index 447bee183..831ec94fa 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp +@@ -1354,7 +1354,7 @@ void ConcurrentMark::checkpointRootsFinal(bool clear_all_soft_refs) { + satb_mq_set.set_active_all_threads(false, /* new active value */ + true /* expected_active */); + +- g1h->extract_uncommit_list(); ++ g1h->shrink_heap_at_remark(); + if (VerifyDuringGC) { + HandleMark hm; // handle scope + Universe::heap()->prepare_for_verify(); +diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp +index 1f1042caa..6ee33fd05 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp +@@ -1565,6 +1565,19 @@ void G1CollectedHeap::do_full_collection(bool clear_all_soft_refs) { + void + G1CollectedHeap:: + resize_if_necessary_after_full_collection(size_t word_size) { ++ bool should_expand; ++ size_t resize_amount = full_collection_resize_amount(should_expand); ++ ++ if (resize_amount == 0) { ++ return; ++ } else if (should_expand) { ++ expand(resize_amount); ++ } else { ++ shrink(resize_amount); ++ } ++} ++ ++size_t G1CollectedHeap::full_collection_resize_amount(bool& expand) { + // Include the current allocation, if any, and bytes that will be + // pre-allocated to support collections, as "used". + const size_t capacity_after_gc = capacity(); +@@ -1630,8 +1643,8 @@ resize_if_necessary_after_full_collection(size_t word_size) { + ergo_format_byte_perc("min desired capacity"), + capacity_after_gc, used_after_gc, + minimum_desired_capacity, (double) MinHeapFreeRatio); +- expand(expand_bytes); +- ++ expand = true; ++ return expand_bytes; + // No expansion, now see if we want to shrink + } else if (capacity_after_gc > maximum_desired_capacity) { + // Capacity too large, compute shrinking size +@@ -1645,10 +1658,13 @@ resize_if_necessary_after_full_collection(size_t word_size) { + ergo_format_byte_perc("max desired capacity"), + capacity_after_gc, used_after_gc, + maximum_desired_capacity, (double) MaxHeapFreeRatio); +- shrink(shrink_bytes); ++ expand = false; ++ return shrink_bytes; + } +-} + ++ expand = true; ++ return 0; ++} + + HeapWord* + G1CollectedHeap::satisfy_failed_allocation(size_t word_size, +@@ -2185,12 +2201,6 @@ void G1CollectedHeap::stop() { + } + } + +-void G1CollectedHeap::check_trigger_periodic_gc() { +- if (g1_policy()->should_trigger_periodic_gc()) { +- collect(GCCause::_g1_periodic_collection); +- } +-} +- + void G1CollectedHeap::init_periodic_gc_thread() { + if (_uncommit_thread == NULL && G1Uncommit) { + PeriodicGC::start(); +@@ -2198,10 +2208,22 @@ void G1CollectedHeap::init_periodic_gc_thread() { + } + } + +-void G1CollectedHeap::extract_uncommit_list() { +- if (g1_policy()->can_extract_uncommit_list()) { +- uint count = _hrm.extract_uncommit_list(); +- g1_policy()->record_extract_uncommit_list(count); ++void G1CollectedHeap::shrink_heap_at_remark() { ++ if (!G1Uncommit) { ++ return; ++ } ++ ++ bool should_expand; ++ size_t resize_amount = full_collection_resize_amount(should_expand); ++ uint length = _hrm.length(); ++ ++ if (resize_amount > 0 && !should_expand) { ++ uint num_candidate_to_remove = (uint)(resize_amount / HeapRegion::GrainBytes); ++ uint count = _hrm.extract_uncommit_list(num_candidate_to_remove); ++ ++ gclog_or_tty->print(" [G1Uncommit list " UINT32_FORMAT ", remaining " UINT32_FORMAT ++ ", free list " UINT32_FORMAT "]", ++ count, length - count, _hrm.num_free_regions()); + } + } + +@@ -4037,7 +4059,6 @@ G1CollectedHeap::do_collection_pause_at_safepoint(double target_pause_time_ms) { + + + double pause_start_sec = os::elapsedTime(); +- g1_policy()->record_gc_start(pause_start_sec); + g1_policy()->phase_times()->note_gc_start(active_workers, mark_in_progress()); + log_gc_header(); + +diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp +index 3225967b3..d0ec5a773 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp +@@ -626,6 +626,8 @@ protected: + // and will be considered part of the used portion of the heap. + void resize_if_necessary_after_full_collection(size_t word_size); + ++ size_t full_collection_resize_amount(bool& expand); ++ + // Callback from VM_G1CollectForAllocation operation. + // This function does everything necessary/possible to satisfy a + // failed allocation request (including collection, expansion, etc.) +@@ -1026,9 +1028,8 @@ public: + + void set_refine_cte_cl_concurrency(bool concurrent); + +- void check_trigger_periodic_gc(); + void init_periodic_gc_thread(); +- void extract_uncommit_list(); ++ void shrink_heap_at_remark(); + + RefToScanQueue *task_queue(int i) const; + +diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp +index 099762f2b..05ce59987 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp +@@ -89,7 +89,6 @@ G1CollectorPolicy::G1CollectorPolicy() : + _concurrent_mark_cleanup_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), + + _alloc_rate_ms_seq(new TruncatedSeq(TruncatedSeqLength)), +- _heap_size_seq(new TruncatedSeq(TruncatedSeqLength)), + _os_load_seq(new TruncatedSeq(TruncatedSeqLength)), + _gc_count_seq(new TruncatedSeq(TruncatedSeqLength)), + _prev_collection_pause_end_ms(0.0), +@@ -112,11 +111,9 @@ G1CollectorPolicy::G1CollectorPolicy() : + _pause_time_target_ms((double) MaxGCPauseMillis), + + _gcs_are_young(true), +- _periodic_gc(false), + _last_uncommit_attempt_s(0.0), + _os_load(-1.0), + _uncommit_start_time(0), +- _gc_count_cancel_extract(false), + _gc_count(0), + _gc_count_minute(0), + +@@ -160,7 +157,6 @@ G1CollectorPolicy::G1CollectorPolicy() : + _inc_cset_predicted_elapsed_time_ms(0.0), + _inc_cset_predicted_elapsed_time_ms_diffs(0.0), + _collection_pause_end_millis(os::javaTimeNanos() / NANOSECS_PER_MILLISEC), +- _extract_uncommit_list(0), + #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away + #pragma warning( disable:4355 ) // 'this' : used in base member initializer list + #endif // _MSC_VER +@@ -1211,8 +1207,6 @@ void G1CollectorPolicy::record_heap_size_info_at_start(bool full) { + _heap_capacity_bytes_before_gc = _g1->capacity(); + _heap_used_bytes_before_gc = _g1->used(); + _cur_collection_pause_used_regions_at_start = _g1->num_used_regions(); +- _heap_size_seq->add(_cur_collection_pause_used_regions_at_start); +- + _eden_capacity_bytes_before_gc = + (_young_list_target_length * HeapRegion::GrainBytes) - _survivor_used_bytes_before_gc; + +@@ -1255,13 +1249,6 @@ void G1CollectorPolicy::print_detailed_heap_transition(bool full) { + EXT_SIZE_PARAMS(heap_used_bytes_after_gc), + EXT_SIZE_PARAMS(heap_capacity_bytes_after_gc)); + +- if (_extract_uncommit_list) { +- gclog_or_tty->print(" [Uncommit list " UINT32_FORMAT ", remaining " UINT32_FORMAT ", free list " UINT32_FORMAT "]", +- _extract_uncommit_list, +- _g1->_hrm.length(), +- _g1->_hrm.num_free_regions()); +- _extract_uncommit_list = 0; +- } + if (full) { + MetaspaceAux::print_metaspace_change(_metaspace_used_bytes_before_gc); + } +@@ -2175,53 +2162,6 @@ void G1CollectorPolicy::finalize_cset(double target_pause_time_ms, EvacuationInf + evacuation_info.set_collectionset_regions(cset_region_length()); + } + +-void G1CollectorPolicy::record_gc_start(double curr_sec) { +- if (_uncommit_start_time == 0) { +- _uncommit_start_time = curr_sec + G1UncommitDelay; +- } +- long curr = curr_sec / 60; +- if (curr > _gc_count_minute) { +- int diff = curr - _gc_count_minute; +- _gc_count_seq->add(_gc_count); +- for (int i = 1; i < diff; i++) { +- _gc_count_seq->add(0.0); +- } +- _gc_count_minute = curr; +- double gc_count_expected = get_new_prediction(_gc_count_seq); +- // Considering the test result, 15000 is an appropriate value for G1PeriodicGCInterval. +- _gc_count_cancel_extract = gc_count_expected > MIN2(4.0, 60000.0 / G1PeriodicGCInterval); +- _gc_count = 0; +- } +- _gc_count++; +-} +- +-bool G1CollectorPolicy::should_trigger_periodic_gc() { +- if (G1PeriodicGCLoadThreshold && _os_load > G1PeriodicGCLoadThreshold) { +- _periodic_gc = false; +- } else if (_periodic_gc) { +- _periodic_gc = false; +- return true; +- } +- return false; +-} +- +-bool G1CollectorPolicy::can_extract_uncommit_list() { +- double now = os::elapsedTime(); +- if (G1Uncommit && now > _uncommit_start_time) { +- if (G1PeriodicGCLoadThreshold && _os_load > G1PeriodicGCLoadThreshold) { +- return false; +- } +- G1CollectedHeap* g1h = G1CollectedHeap::heap(); +- if (!_gc_count_cancel_extract || now >= (g1h->millis_since_last_gc() + G1PeriodicGCInterval) / 1000.0) { +- if (now - _last_uncommit_attempt_s >= G1PeriodicGCInterval / 1000.0) { +- _last_uncommit_attempt_s = now; +- return true; +- } +- } +- } +- return false; +-} +- + void TraceGen0TimeData::record_start_collection(double time_to_stop_the_world_ms) { + if(TraceGen0Time) { + _all_stop_world_times_ms.add(time_to_stop_the_world_ms); +diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp +index 1a0d20d6f..af5d5d57a 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp +@@ -244,7 +244,6 @@ private: + TruncatedSeq* _constant_other_time_ms_seq; + TruncatedSeq* _young_other_cost_per_region_ms_seq; + TruncatedSeq* _non_young_other_cost_per_region_ms_seq; +- TruncatedSeq* _heap_size_seq; + TruncatedSeq* _os_load_seq; + TruncatedSeq* _gc_count_seq; + +@@ -268,8 +267,6 @@ private: + + uint _free_regions_at_end_of_collection; + +- uint _extract_uncommit_list; +- + size_t _recorded_rs_lengths; + size_t _max_rs_lengths; + double _sigma; +@@ -308,19 +305,12 @@ private: + + size_t _gc_count; + long _gc_count_minute; +- bool _gc_count_cancel_extract; + +- volatile bool _periodic_gc; + double _last_uncommit_attempt_s; + volatile double _os_load; + double _uncommit_start_time; + public: + // Accessors +- +- void set_periodic_gc() { _periodic_gc = true; } +- bool can_extract_uncommit_list(); +- bool should_trigger_periodic_gc(); +- + void set_region_eden(HeapRegion* hr, int young_index_in_cset) { + hr->set_eden(); + hr->install_surv_rate_group(_short_lived_surv_rate_group); +@@ -346,16 +336,14 @@ public: + _max_rs_lengths = rs_lengths; + } + +- size_t predict_heap_size_seq() { +- return (size_t) get_new_prediction(_heap_size_seq); +- } +- + void add_os_load(double load) { + _os_load_seq->add(load); + _os_load = get_new_prediction(_os_load_seq); + } + +- void record_gc_start(double sec); ++ double os_load() { ++ return _os_load; ++ } + + size_t predict_rs_length_diff() { + return (size_t) get_new_prediction(_rs_length_diff_seq); +@@ -739,8 +727,6 @@ public: + void record_stop_world_start(); + void record_concurrent_pause(); + +- void record_extract_uncommit_list(uint count) { _extract_uncommit_list = count; } +- + // Record how much space we copied during a GC. This is typically + // called when a GC alloc region is being retired. + void record_bytes_copied_during_gc(size_t bytes) { +diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1UncommitThread.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1UncommitThread.cpp +index 37bdbdb69..503218917 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/g1UncommitThread.cpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/g1UncommitThread.cpp +@@ -26,6 +26,9 @@ + + #include "gc_implementation/g1/g1UncommitThread.hpp" + #include "gc_implementation/g1/g1_globals.hpp" ++#include "gc_implementation/g1/g1Log.hpp" ++#include "gc_implementation/g1/g1CollectorPolicy.hpp" ++#include "gc_implementation/g1/concurrentMarkThread.hpp" + #include "runtime/javaCalls.hpp" + #include "runtime/os.hpp" + +@@ -104,9 +107,12 @@ void PeriodicGC::start() { + } + + void PeriodicGC::timer_thread_entry(JavaThread* thread, TRAPS) { ++ G1CollectedHeap* g1h = G1CollectedHeap::heap(); + while(!_should_terminate) { + assert(!SafepointSynchronize::is_at_safepoint(), "PeriodicGC timer thread is a JavaThread"); +- G1CollectedHeap::heap()->check_trigger_periodic_gc(); ++ if (check_for_periodic_gc()) { ++ g1h->collect(GCCause::_g1_periodic_collection); ++ } + + MutexLockerEx x(_monitor); + if (_should_terminate) { +@@ -116,6 +122,78 @@ void PeriodicGC::timer_thread_entry(JavaThread* thread, TRAPS) { + } + } + ++bool PeriodicGC::check_for_periodic_gc() { ++ if (!G1Uncommit) { ++ return false; ++ } ++ ++ return should_start_periodic_gc(); ++} ++ ++bool PeriodicGC::should_start_periodic_gc() { ++ G1CollectedHeap* g1h = G1CollectedHeap::heap(); ++ G1CollectorPolicy* g1p = g1h->g1_policy(); ++ // If we are currently in a concurrent mark we are going to uncommit memory soon. ++ if (g1h->concurrent_mark()->cmThread()->during_cycle()) { ++ if (G1UncommitLog && G1Log::finest()) { ++ gclog_or_tty->date_stamp(PrintGCDateStamps); ++ gclog_or_tty->stamp(PrintGCTimeStamps); ++ gclog_or_tty->print_cr("[G1Uncommit] Concurrent cycle in progress. Skipping."); ++ } ++ return false; ++ } ++ ++ // Check if enough time has passed since the last GC. ++ uintx time_since_last_gc = (uintx)Universe::heap()->millis_since_last_gc(); ++ if (time_since_last_gc < G1PeriodicGCInterval) { ++ if (G1UncommitLog && G1Log::finest()) { ++ gclog_or_tty->date_stamp(PrintGCDateStamps); ++ gclog_or_tty->stamp(PrintGCTimeStamps); ++ gclog_or_tty->print_cr("[G1Uncommit] Last GC occurred " UINTX_FORMAT "ms before which is below threshold" ++ UINTX_FORMAT "ms. Skipping.", time_since_last_gc, G1PeriodicGCInterval); ++ } ++ return false; ++ } ++ ++ // Collect load need G1PeriodicGCInterval time after previous GC's end ++ assert(G1PeriodicGCInterval > 0, "just checking"); ++ double recent_load = -1.0; ++ ++ if (G1PeriodicGCLoadThreshold) { ++ // Sample process load and store it ++ if (G1PeriodicGCProcessLoad) { ++ recent_load = os::get_process_load() * 100; ++ } ++ if (recent_load < 0) { ++ // Fallback to os load ++ G1PeriodicGCProcessLoad = false; ++ if (os::loadavg(&recent_load, 1) != -1) { ++ static int cpu_count = os::active_processor_count(); ++ assert(cpu_count > 0, "just checking"); ++ recent_load = recent_load * 100 / cpu_count; ++ } ++ } ++ if (recent_load >= 0) { ++ g1p->add_os_load(recent_load); ++ } ++ } ++ ++ if (G1UncommitLog) { ++ gclog_or_tty->date_stamp(PrintGCDateStamps); ++ gclog_or_tty->stamp(PrintGCTimeStamps); ++ recent_load < 0 ? gclog_or_tty->print_cr("[G1Uncommit] Checking for periodic GC.") ++ : gclog_or_tty->print_cr("[G1Uncommit] Checking for periodic GC. Current load %1.2f. " ++ "total regions: " UINT32_FORMAT" free regions: " UINT32_FORMAT, ++ recent_load, g1h->num_regions(), g1h->num_free_regions()); ++ } ++ ++ if (g1p->os_load() < G1PeriodicGCLoadThreshold || !G1PeriodicGCLoadThreshold) { ++ return true; ++ } ++ gclog_or_tty->print_cr("[G1Uncommit] Periodic GC request denied, skipping!"); ++ return false; ++} ++ + void PeriodicGC::stop() { + _should_terminate = true; + { +@@ -139,7 +217,7 @@ G1UncommitThread::G1UncommitThread() : + } + } + if (G1UncommitLog) { +- gclog_or_tty->print_cr("Periodic GC Thread start"); ++ gclog_or_tty->print_cr("[G1Uncommit] Periodic GC Thread start"); + } + } + +diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1UncommitThread.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1UncommitThread.hpp +index 883a9a418..6f1d5e35f 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/g1UncommitThread.hpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/g1UncommitThread.hpp +@@ -40,6 +40,8 @@ public: + static void start(); + static void stop(); + static bool has_error(TRAPS, const char* error); ++ static bool check_for_periodic_gc(); ++ static bool should_start_periodic_gc(); + }; + + class G1UncommitThread: public ConcurrentGCThread { +diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp +index 56e2d32df..d31073f9f 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp +@@ -573,21 +573,23 @@ void HeapRegionManager::free_uncommit_list_memory() { + } + } + +-uint HeapRegionManager::extract_uncommit_list() +-{ ++uint HeapRegionManager::extract_uncommit_list(uint num_candidate_to_remove) { + assert_at_safepoint(true /* should_be_vm_thread */); ++ double start_up_sec = os::elapsedTime(); ++ if (start_up_sec < G1UncommitDelay) { ++ gclog_or_tty->date_stamp(PrintGCDateStamps); ++ gclog_or_tty->stamp(PrintGCTimeStamps); ++ gclog_or_tty->print_cr("start up seconds:%lf, less than G1UncommitDelay, will not uncommit.", start_up_sec); ++ return 0; ++ } ++ + if (!_uncommit_list_filled) { +- G1CollectedHeap* g1h = G1CollectedHeap::heap(); +- uint dest = ((G1CollectorPolicy*)g1h->collector_policy())->predict_heap_size_seq(); +- +- if (dest < _num_committed) { +- uint num_regions_to_remove = (_num_committed - dest) * G1UncommitPercent; +- if (num_regions_to_remove >= 1 && num_regions_to_remove < _free_list.length()) { +- int count = _free_list.move_regions_to(&_uncommit_list, num_regions_to_remove); +- OrderAccess::storestore(); +- _uncommit_list_filled = true; +- return count; +- } ++ uint num_regions_to_remove = num_candidate_to_remove * G1UncommitPercent; ++ if (num_regions_to_remove >= 1 && num_regions_to_remove < _free_list.length()) { ++ int count = _free_list.move_regions_to(&_uncommit_list, num_regions_to_remove); ++ OrderAccess::storestore(); ++ _uncommit_list_filled = true; ++ return count; + } + } + return 0; +diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.hpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.hpp +index 25f3a223f..3950d6280 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.hpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.hpp +@@ -175,7 +175,7 @@ public: + G1RegionToSpaceMapper* cardtable, + G1RegionToSpaceMapper* card_counts); + +- uint extract_uncommit_list(); ++ uint extract_uncommit_list(uint num_candidate_to_remove); + void free_uncommit_list_memory(); + + // Return the "dummy" region used for G1AllocRegion. This is currently a hardwired +diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.inline.hpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.inline.hpp +index 68840d61e..50d0fa832 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.inline.hpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.inline.hpp +@@ -40,8 +40,8 @@ inline HeapRegion* HeapRegionManager::addr_to_region(HeapWord* addr) const { + } + + inline HeapRegion* HeapRegionManager::at(uint index) const { +- assert(is_available(index), "pre-condition"); + HeapRegion* hr = _regions.get_by_index(index); ++ assert(hr->in_uncommit_list() || is_available(index), "pre-condition"); + assert(hr != NULL, "sanity"); + assert(hr->hrm_index() == index, "sanity"); + return hr; +-- +2.22.0 + diff --git a/openjdk-1.8.0.spec b/openjdk-1.8.0.spec index c63f8e8..f12b3e6 100644 --- a/openjdk-1.8.0.spec +++ b/openjdk-1.8.0.spec @@ -916,7 +916,7 @@ Provides: java-%{javaver}-%{origin}-accessibility%{?1} = %{epoch}:%{version}-%{r Name: java-%{javaver}-%{origin} Version: %{javaver}.%{updatever}.%{buildver} -Release: 3 +Release: 4 # java-1.5.0-ibm from jpackage.org set Epoch to 1 for unknown reasons # and this change was brought into RHEL-4. java-1.5.0-ibm packages # also included the epoch in their virtual provides. This created a @@ -1118,6 +1118,7 @@ Patch220: JDK-debug-version-crash-when-using-AppCDS.patch Patch221: 8183543-Aarch64-C2-compilation-often-fails-with-fail--last.patch Patch222: 8273111-Default-timezone-should-return-zone-ID-if-locatiome-is-valid-but-not-canonicalization-on-linux.patch Patch223: 8233280-Remove-GCLockerInvokesConcurrent-relative-logic-for-G1.patch +Patch224: G1Ucommit-Refactor-Trigger-mechanism.patch # 8u312 @@ -1586,6 +1587,7 @@ pushd %{top_level_dir_name} %patch221 -p1 %patch222 -p1 %patch223 -p1 +%patch224 -p1 popd # System library fixes @@ -2203,6 +2205,9 @@ require "copy_jdk_configs.lua" %endif %changelog +* Fri Dec 10 2021 kuenking111 - 1:1.8.0.312-b07.4 +- add G1Ucommit-Refactor-Trigger-mechanism.patch + * Fri Dec 10 2021 kuenking111 - 1:1.8.0.312-b07.3 - add 8233280-Remove-GCLockerInvokesConcurrent-relative-logic-for-G1.patch -- Gitee