8342382: Implement JEP 522: G1 GC: Improve Throughput by Reducing Synchronization

src/hotspot/share/gc/g1/g1CollectedHeap.cpp

@@ -62,6 +62,7 @@
 #include "gc/g1/g1RegionPinCache.inline.hpp"
 #include "gc/g1/g1RegionToSpaceMapper.hpp"
 #include "gc/g1/g1RemSet.hpp"
+#include "gc/g1/g1ReviseYoungListTargetLengthTask.hpp"
 #include "gc/g1/g1RootClosures.hpp"
 #include "gc/g1/g1RootProcessor.hpp"
 #include "gc/g1/g1SATBMarkQueueSet.hpp"
@@ -1160,6 +1161,7 @@ G1CollectedHeap::G1CollectedHeap() :
   _service_thread(nullptr),
   _periodic_gc_task(nullptr),
   _free_arena_memory_task(nullptr),
+  _revise_young_length_task(nullptr),
   _workers(nullptr),
   _refinement_epoch(0),
   _last_synchronized_start(0),
@@ -1468,6 +1470,11 @@ jint G1CollectedHeap::initialize() {
   _free_arena_memory_task = new G1MonotonicArenaFreeMemoryTask("Card Set Free Memory Task");
   _service_thread->register_task(_free_arena_memory_task);
 
+  if (policy()->use_adaptive_young_list_length()) {
+    _revise_young_length_task = new G1ReviseYoungLengthTargetLengthTask("Revise Young Length List Task");
+    _service_thread->register_task(_revise_young_length_task);
+  }
+
   // Here we allocate the dummy G1HeapRegion that is required by the
   // G1AllocRegion class.
   G1HeapRegion* dummy_region = _hrm.get_dummy_region();

src/hotspot/share/gc/g1/g1CollectedHeap.hpp

@@ -84,6 +84,7 @@ class MemoryPool;
 class nmethod;
 class PartialArrayStateManager;
 class ReferenceProcessor;
+class G1ReviseYoungLengthTargetLengthTask;
 class STWGCTimer;
 class WorkerThreads;
 
@@ -172,6 +173,7 @@ class G1CollectedHeap : public CollectedHeap {
   G1ServiceThread* _service_thread;
   G1ServiceTask* _periodic_gc_task;
   G1MonotonicArenaFreeMemoryTask* _free_arena_memory_task;
+  G1ReviseYoungLengthTargetLengthTask* _revise_young_length_task;
 
   WorkerThreads* _workers;
 

src/hotspot/share/gc/g1/g1ConcurrentRefine.cpp

@@ -392,7 +392,11 @@ bool G1ConcurrentRefineSweepState::are_java_threads_synched() const {
 uint64_t G1ConcurrentRefine::adjust_threads_period_ms() const {
   // Instead of a fixed value, this could be a command line option.  But then
   // we might also want to allow configuration of adjust_threads_wait_ms().
-  return 50;
+
+  // Use a prime number close to 50ms, different to other components that derive
+  // their wait time from the try_get_available_bytes_estimate() call to minimize
+  // interference.
+  return 53;
 }
 
 static size_t minimum_pending_cards_target() {
@@ -514,14 +518,6 @@ void G1ConcurrentRefine::adjust_after_gc(double logged_cards_time_ms,
   }
 }
 
-// Wake up the control thread less frequently when the time available until
-// the next GC is longer.  But don't increase the wait time too rapidly.
-// This reduces the number of control thread wakeups that just immediately
-// go back to waiting, while still being responsive to behavior changes.
-static uint64_t compute_adjust_wait_time_ms(double available_ms) {
-  return static_cast<uint64_t>(sqrt(available_ms) * 4.0);
-}
-
 uint64_t G1ConcurrentRefine::adjust_threads_wait_ms() const {
   assert_current_thread_is_control_refinement_thread();
   if (is_pending_cards_target_initialized()) {
@@ -531,9 +527,9 @@ uint64_t G1ConcurrentRefine::adjust_threads_wait_ms() const {
     if (_heap_was_locked) {
       return 1;
     }
-    double available_ms = _threads_needed.predicted_time_until_next_gc_ms();
-    uint64_t wait_time_ms = compute_adjust_wait_time_ms(available_ms);
-    return MAX2(wait_time_ms, adjust_threads_period_ms());
+    double available_time_ms = _threads_needed.predicted_time_until_next_gc_ms();
+
+    return _policy->adjust_wait_time_ms(available_time_ms, adjust_threads_period_ms());
   } else {
     // If target not yet initialized then wait forever (until explicitly
     // activated).  This happens during startup, when we don't bother with
@@ -542,55 +538,6 @@ uint64_t G1ConcurrentRefine::adjust_threads_wait_ms() const {
   }
 }
 
-class G1ConcurrentRefine::RemSetSamplingClosure : public G1HeapRegionClosure {
-  size_t _sampled_code_root_rs_length;
-
-public:
-  RemSetSamplingClosure() :
-    _sampled_code_root_rs_length(0) {}
-
-  bool do_heap_region(G1HeapRegion* r) override {
-    G1HeapRegionRemSet* rem_set = r->rem_set();
-    _sampled_code_root_rs_length += rem_set->code_roots_list_length();
-    return false;
-  }
-
-  size_t sampled_code_root_rs_length() const { return _sampled_code_root_rs_length; }
-};
-
-// Adjust the target length (in regions) of the young gen, based on the
-// current length of the remembered sets.
-//
-// At the end of the GC G1 determines the length of the young gen based on
-// how much time the next GC can take, and when the next GC may occur
-// according to the MMU.
-//
-// The assumption is that a significant part of the GC is spent on scanning
-// the remembered sets (and many other components), so this thread constantly
-// reevaluates the prediction for the remembered set scanning costs, and potentially
-// resizes the young gen. This may do a premature GC or even increase the young
-// gen size to keep pause time length goal.
-void G1ConcurrentRefine::adjust_young_list_target_length() {
-  if (_policy->use_adaptive_young_list_length()) {
-    G1CollectedHeap* g1h = G1CollectedHeap::heap();
-    G1CollectionSet* cset = g1h->collection_set();
-    RemSetSamplingClosure cl;
-    cset->iterate(&cl);
-
-    size_t pending_cards;
-    size_t current_to_collection_set_cards;
-    {
-      MutexLocker x(G1RareEvent_lock, Mutex::_no_safepoint_check_flag);
-      G1Policy* p = g1h->policy();
-      pending_cards = p->current_pending_cards();
-      current_to_collection_set_cards = p->current_to_collection_set_cards();
-    }
-    _policy->revise_young_list_target_length(pending_cards,
-                                             current_to_collection_set_cards,
-                                             cl.sampled_code_root_rs_length());
-  }
-}
-
 bool G1ConcurrentRefine::adjust_num_threads_periodically() {
   assert_current_thread_is_control_refinement_thread();
 
@@ -607,18 +554,8 @@ bool G1ConcurrentRefine::adjust_num_threads_periodically() {
 
   // Reset pending request.
   _needs_adjust = false;
-  // Getting used young bytes requires holding Heap_lock.  But we can't use
-  // normal lock and block until available.  Blocking on the lock could
-  // deadlock with a GC VMOp that is holding the lock and requesting a
-  // safepoint.  Instead try to lock, and if fail then skip adjustment for
-  // this iteration and retry the adjustment later.
-  if (Heap_lock->try_lock()) {
-    size_t used_bytes = _policy->estimate_used_young_bytes_locked();
-    Heap_lock->unlock();
-
-    adjust_young_list_target_length();
-    size_t young_bytes = _policy->young_list_target_length() * G1HeapRegion::GrainBytes;
-    size_t available_bytes = young_bytes - MIN2(young_bytes, used_bytes);
+  size_t available_bytes = 0;
+  if (_policy->try_get_available_bytes_estimate(available_bytes)) {
     adjust_threads_wanted(available_bytes);
     _last_adjust = Ticks::now();
   } else {

src/hotspot/share/gc/g1/g1ConcurrentRefine.hpp

@@ -249,9 +249,6 @@ class G1ConcurrentRefine : public CHeapObj<mtGC> {
 
   uint64_t adjust_threads_period_ms() const;
 
-  class RemSetSamplingClosure;  // Helper class for adjusting young length.
-  void adjust_young_list_target_length();
-
   void adjust_threads_wanted(size_t available_bytes);
 
   NONCOPYABLE(G1ConcurrentRefine);

src/hotspot/share/gc/g1/g1ConcurrentRefineThread.cpp

@@ -216,7 +216,7 @@ void G1ConcurrentRefineThread::do_refinement() {
     {
       // The young gen revising mechanism reads the predictor and the values set
       // here. Avoid inconsistencies by locking.
-      MutexLocker x(G1RareEvent_lock, Mutex::_no_safepoint_check_flag);
+      MutexLocker x(G1ReviseYoungLength_lock, Mutex::_no_safepoint_check_flag);
       policy->record_dirtying_stats(TimeHelper::counter_to_millis(G1CollectedHeap::heap()->last_refinement_epoch_start()),
                                     TimeHelper::counter_to_millis(next_epoch_start),
                                     stats->cards_pending(),

src/hotspot/share/gc/g1/g1ConcurrentRefineThreadsNeeded.cpp

@@ -52,28 +52,10 @@ void G1ConcurrentRefineThreadsNeeded::update(uint active_threads,
                                              size_t available_bytes,
                                              size_t num_cards,
                                              size_t target_num_cards) {
-  const G1Analytics* analytics = _policy->analytics();
-
-  // Estimate time until next GC, based on remaining bytes available for
-  // allocation and the allocation rate.
-  double alloc_region_rate = analytics->predict_alloc_rate_ms();
-  double alloc_bytes_rate = alloc_region_rate * G1HeapRegion::GrainBytes;
-  if (alloc_bytes_rate == 0.0) {
-    // A zero rate indicates we don't yet have data to use for predictions.
-    // Since we don't have any idea how long until the next GC, use a time of
-    // zero.
-    _predicted_time_until_next_gc_ms = 0.0;
-  } else {
-    // If the heap size is large and the allocation rate is small, we can get
-    // a predicted time until next GC that is so large it can cause problems
-    // (such as overflow) in other calculations.  Limit the prediction to one
-    // hour, which is still large in this context.
-    const double one_hour_ms = 60.0 * 60.0 * MILLIUNITS;
-    double raw_time_ms = available_bytes / alloc_bytes_rate;
-    _predicted_time_until_next_gc_ms = MIN2(raw_time_ms, one_hour_ms);
-  }
+  _predicted_time_until_next_gc_ms = _policy->predict_time_to_next_gc_ms(available_bytes);
 
   // Estimate number of cards that need to be processed before next GC.
+  const G1Analytics* analytics = _policy->analytics();
 
   double incoming_rate = analytics->predict_dirtied_cards_rate_ms();
   double raw_cards = incoming_rate * _predicted_time_until_next_gc_ms;

src/hotspot/share/gc/g1/g1Policy.cpp

@@ -633,9 +633,9 @@ void G1Policy::record_dirtying_stats(double last_mutator_start_dirty_ms,
                                      double yield_duration_ms,
                                      size_t next_pending_cards_from_gc,
                                      size_t next_to_collection_set_cards) {
-  assert(SafepointSynchronize::is_at_safepoint() || G1RareEvent_lock->is_locked(),
+  assert(SafepointSynchronize::is_at_safepoint() || G1ReviseYoungLength_lock->is_locked(),
          "must be (at safepoint %s locked %s)",
-         BOOL_TO_STR(SafepointSynchronize::is_at_safepoint()), BOOL_TO_STR(G1RareEvent_lock->is_locked()));
+         BOOL_TO_STR(SafepointSynchronize::is_at_safepoint()), BOOL_TO_STR(G1ReviseYoungLength_lock->is_locked()));
   // Record mutator's card logging rate.
 
   // Unlike above for conc-refine rate, here we should not require a
@@ -1433,6 +1433,48 @@ size_t G1Policy::allowed_waste_in_collection_set() const {
   return G1HeapWastePercent * _g1h->capacity() / 100;
 }
 
+bool G1Policy::try_get_available_bytes_estimate(size_t& available_bytes) const {
+  // Getting used young bytes requires holding Heap_lock.  But we can't use
+  // normal lock and block until available.  Blocking on the lock could
+  // deadlock with a GC VMOp that is holding the lock and requesting a
+  // safepoint.  Instead try to lock, and return the result of that attempt,
+  // and the estimate if successful.
+  if (Heap_lock->try_lock()) {
+    size_t used_bytes = estimate_used_young_bytes_locked();
+    Heap_lock->unlock();
+
+    size_t young_bytes = young_list_target_length() * G1HeapRegion::GrainBytes;
+    available_bytes = young_bytes - MIN2(young_bytes, used_bytes);
+    return true;
+  } else {
+    available_bytes = 0;
+    return false;
+  }
+}
+
+double G1Policy::predict_time_to_next_gc_ms(size_t available_bytes) const {
+  double alloc_region_rate = _analytics->predict_alloc_rate_ms();
+  double alloc_bytes_rate = alloc_region_rate * G1HeapRegion::GrainBytes;
+  if (alloc_bytes_rate == 0.0) {
+    // A zero rate indicates we don't yet have data to use for predictions.
+    // Since we don't have any idea how long until the next GC, use a time of
+    // zero.
+    return 0.0;
+  } else {
+    // If the heap size is large and the allocation rate is small, we can get
+    // a predicted time until next GC that is so large it can cause problems
+    // (such as overflow) in other calculations.  Limit the prediction to one
+    // hour, which is still large in this context.
+    const double one_hour_ms = 60.0 * 60.0 * MILLIUNITS;
+    double raw_time_ms = available_bytes / alloc_bytes_rate;
+    return MIN2(raw_time_ms, one_hour_ms);
+  }
+}
+
+uint64_t G1Policy::adjust_wait_time_ms(double wait_time_ms, uint64_t min_time_ms) {
+  return MAX2(static_cast<uint64_t>(sqrt(wait_time_ms) * 4.0), min_time_ms);
+}
+
 double G1Policy::last_mutator_dirty_start_time_ms() {
   return TimeHelper::counter_to_millis(_g1h->last_refinement_epoch_start());
 }

src/hotspot/share/gc/g1/g1Policy.hpp

@@ -335,7 +335,6 @@ class G1Policy: public CHeapObj<mtGC> {
   // Amount of allowed waste in bytes in the collection set.
   size_t allowed_waste_in_collection_set() const;
 
-
 private:
 
   // Predict the number of bytes of surviving objects from survivor and old
@@ -369,10 +368,28 @@ class G1Policy: public CHeapObj<mtGC> {
 
   bool use_adaptive_young_list_length() const;
 
+  // Try to get an estimate of the currently available bytes in the young gen. This
+  // operation considers itself low-priority: if other threads need the resources
+  // required to get the information, return false to indicate that the caller
+  // should retry "soon".
+  bool try_get_available_bytes_estimate(size_t& bytes) const;
+  // Estimate time until next GC, based on remaining bytes available for
+  // allocation and the allocation rate.
+  double predict_time_to_next_gc_ms(size_t available_bytes) const;
+
+  // Adjust wait times to make them less frequent the longer the next GC is away.
+  // But don't increase the wait time too rapidly, further bound it by min_time_ms.
+  // This reduces the number of thread wakeups that just immediately
+  // go back to waiting, while still being responsive to behavior changes.
+  uint64_t adjust_wait_time_ms(double wait_time_ms, uint64_t min_time_ms);
+
+private:
   // Return an estimate of the number of bytes used in young gen.
   // precondition: holding Heap_lock
   size_t estimate_used_young_bytes_locked() const;
 
+public:
+
   void transfer_survivors_to_cset(const G1SurvivorRegions* survivors);
 
   // Record and log stats and pending cards to update predictors.