packages/openjdk-1.8.0
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

I4LXX3: G1Ucommit Refactor Trigger mechanism

Browse Source
This commit is contained in:
kuenking111 2021-12-10 12:19:05 +08:00
parent 85b49acf10
commit 94419d5ddc
2 changed files with 636 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

630
G1Ucommit-Refactor-Trigger-mechanism.patch Executable file
View File

@ -0,0 +1,630 @@
From f6f0d05f65a35672f48f63d7e8f73a8c2f56d1c3 Mon Sep 17 00:00:00 2001
From: mashoubing <mashoubing1@huawei.com>
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

7
openjdk-1.8.0.spec
View File

@ -916,7 +916,7 @@ Provides: java-%{javaver}-%{origin}-accessibility%{?1} = %{epoch}:%{version}-%{r
Name: java-%{javaver}-%{origin} Name: java-%{javaver}-%{origin}
Version: %{javaver}.%{updatever}.%{buildver} Version: %{javaver}.%{updatever}.%{buildver}
Release: 3 Release: 4
# java-1.5.0-ibm from jpackage.org set Epoch to 1 for unknown reasons # 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 # 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 # 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 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 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 Patch223: 8233280-Remove-GCLockerInvokesConcurrent-relative-logic-for-G1.patch
Patch224: G1Ucommit-Refactor-Trigger-mechanism.patch
# 8u312 # 8u312
@ -1586,6 +1587,7 @@ pushd %{top_level_dir_name}
%patch221 -p1 %patch221 -p1
%patch222 -p1 %patch222 -p1
%patch223 -p1 %patch223 -p1
%patch224 -p1
popd popd
# System library fixes # System library fixes
@ -2203,6 +2205,9 @@ require "copy_jdk_configs.lua"
%endif %endif
%changelog %changelog
* Fri Dec 10 2021 kuenking111 <wangkun49@huawei.com> - 1:1.8.0.312-b07.4
- add G1Ucommit-Refactor-Trigger-mechanism.patch
* Fri Dec 10 2021 kuenking111 <wangkun49@huawei.com> - 1:1.8.0.312-b07.3 * Fri Dec 10 2021 kuenking111 <wangkun49@huawei.com> - 1:1.8.0.312-b07.3
- add 8233280-Remove-GCLockerInvokesConcurrent-relative-logic-for-G1.patch - add 8233280-Remove-GCLockerInvokesConcurrent-relative-logic-for-G1.patch