8371985: Parallel: Move should_attempt_scavenge to ParallelScavengeHeap

Reviewed-by: fandreuzzi, iwalulya

Author: albertnetymk

src/hotspot/share/gc/parallel/parallelScavengeHeap.cpp

@@ -370,6 +370,55 @@ void ParallelScavengeHeap::do_full_collection(bool clear_all_soft_refs) {
   PSParallelCompact::invoke(clear_all_soft_refs, should_do_max_compaction);
 }
 
+bool ParallelScavengeHeap::should_attempt_young_gc() const {
+  const bool ShouldRunYoungGC = true;
+  const bool ShouldRunFullGC = false;
+
+  if (!_young_gen->to_space()->is_empty()) {
+    log_debug(gc, ergo)("To-space is not empty; run full-gc instead.");
+    return ShouldRunFullGC;
+  }
+
+  // Check if the predicted promoted bytes will overflow free space in old-gen.
+  PSAdaptiveSizePolicy* policy = _size_policy;
+
+  size_t avg_promoted = (size_t) policy->padded_average_promoted_in_bytes();
+  size_t promotion_estimate = MIN2(avg_promoted, _young_gen->used_in_bytes());
+  // Total free size after possible old gen expansion
+  size_t free_in_old_gen_with_expansion = _old_gen->max_gen_size() - _old_gen->used_in_bytes();
+
+  log_trace(gc, ergo)("average_promoted %zu; padded_average_promoted %zu",
+              (size_t) policy->average_promoted_in_bytes(),
+              (size_t) policy->padded_average_promoted_in_bytes());
+
+  if (promotion_estimate >= free_in_old_gen_with_expansion) {
+    log_debug(gc, ergo)("Run full-gc; predicted promotion size >= max free space in old-gen: %zu >= %zu",
+      promotion_estimate, free_in_old_gen_with_expansion);
+    return ShouldRunFullGC;
+  }
+
+  if (UseAdaptiveSizePolicy) {
+    // Also checking OS has enough free memory to commit and expand old-gen.
+    // Otherwise, the recorded gc-pause-time might be inflated to include time
+    // of OS preparing free memory, resulting in inaccurate young-gen resizing.
+    assert(_old_gen->committed().byte_size() >= _old_gen->used_in_bytes(), "inv");
+    // Use uint64_t instead of size_t for 32bit compatibility.
+    uint64_t free_mem_in_os;
+    if (os::free_memory(free_mem_in_os)) {
+      size_t actual_free = (size_t)MIN2(_old_gen->committed().byte_size() - _old_gen->used_in_bytes() + free_mem_in_os,
+                                        (uint64_t)SIZE_MAX);
+      if (promotion_estimate > actual_free) {
+        log_debug(gc, ergo)("Run full-gc; predicted promotion size > free space in old-gen and OS: %zu > %zu",
+          promotion_estimate, actual_free);
+        return ShouldRunFullGC;
+      }
+    }
+  }
+
+  // No particular reasons to run full-gc, so young-gc.
+  return ShouldRunYoungGC;
+}
+
 static bool check_gc_heap_free_limit(size_t free_bytes, size_t capacity_bytes) {
   return (free_bytes * 100 / capacity_bytes) < GCHeapFreeLimit;
 }
@@ -516,17 +565,18 @@ void ParallelScavengeHeap::collect(GCCause::Cause cause) {
   VMThread::execute(&op);
 }
 
-void ParallelScavengeHeap::collect_at_safepoint(bool full) {
+void ParallelScavengeHeap::collect_at_safepoint(bool is_full) {
   assert(!GCLocker::is_active(), "precondition");
   bool clear_soft_refs = GCCause::should_clear_all_soft_refs(_gc_cause);
 
-  if (!full) {
-    bool success = PSScavenge::invoke(clear_soft_refs);
-    if (success) {
+  if (!is_full && should_attempt_young_gc()) {
+    bool young_gc_success = PSScavenge::invoke(clear_soft_refs);
+    if (young_gc_success) {
       return;
     }
-    // Upgrade to Full-GC if young-gc fails
+    log_debug(gc, heap)("Upgrade to Full-GC since Young-gc failed.");
   }
+
   const bool should_do_max_compaction = false;
   PSParallelCompact::invoke(clear_soft_refs, should_do_max_compaction);
 }

src/hotspot/share/gc/parallel/parallelScavengeHeap.hpp

@@ -119,6 +119,9 @@ class ParallelScavengeHeap : public CollectedHeap {
   void print_tracing_info() const override;
   void stop() override {};
 
+  // Returns true if a young GC should be attempted, false if a full GC is preferred.
+  bool should_attempt_young_gc() const;
+
 public:
   ParallelScavengeHeap() :
     CollectedHeap(),

src/hotspot/share/gc/parallel/psScavenge.cpp

@@ -313,12 +313,6 @@ bool PSScavenge::invoke(bool clear_soft_refs) {
   assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");
   assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread");
 
-  // Check for potential problems.
-  if (!should_attempt_scavenge()) {
-    log_info(gc, ergo)("Young-gc might fail so skipping");
-    return false;
-  }
-
   IsSTWGCActiveMark mark;
 
   _gc_timer.register_gc_start();
@@ -336,8 +330,7 @@ bool PSScavenge::invoke(bool clear_soft_refs) {
   PSOldGen* old_gen = heap->old_gen();
   PSAdaptiveSizePolicy* size_policy = heap->size_policy();
 
-  assert(young_gen->to_space()->is_empty(),
-         "Attempt to scavenge with live objects in to_space");
+  assert(young_gen->to_space()->is_empty(), "precondition");
 
   heap->increment_total_collections();
 
@@ -520,59 +513,6 @@ void PSScavenge::clean_up_failed_promotion() {
   NOT_PRODUCT(ParallelScavengeHeap::heap()->reset_promotion_should_fail();)
 }
 
-bool PSScavenge::should_attempt_scavenge() {
-  const bool ShouldRunYoungGC = true;
-  const bool ShouldRunFullGC = false;
-
-  ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
-  PSYoungGen* young_gen = heap->young_gen();
-  PSOldGen* old_gen = heap->old_gen();
-
-  if (!young_gen->to_space()->is_empty()) {
-    log_debug(gc, ergo)("To-space is not empty; run full-gc instead.");
-    return ShouldRunFullGC;
-  }
-
-  // Check if the predicted promoted bytes will overflow free space in old-gen.
-  PSAdaptiveSizePolicy* policy = heap->size_policy();
-
-  size_t avg_promoted = (size_t) policy->padded_average_promoted_in_bytes();
-  size_t promotion_estimate = MIN2(avg_promoted, young_gen->used_in_bytes());
-  // Total free size after possible old gen expansion
-  size_t free_in_old_gen_with_expansion = old_gen->max_gen_size() - old_gen->used_in_bytes();
-
-  log_trace(gc, ergo)("average_promoted %zu; padded_average_promoted %zu",
-              (size_t) policy->average_promoted_in_bytes(),
-              (size_t) policy->padded_average_promoted_in_bytes());
-
-  if (promotion_estimate >= free_in_old_gen_with_expansion) {
-    log_debug(gc, ergo)("Run full-gc; predicted promotion size >= max free space in old-gen: %zu >= %zu",
-      promotion_estimate, free_in_old_gen_with_expansion);
-    return ShouldRunFullGC;
-  }
-
-  if (UseAdaptiveSizePolicy) {
-    // Also checking OS has enough free memory to commit and expand old-gen.
-    // Otherwise, the recorded gc-pause-time might be inflated to include time
-    // of OS preparing free memory, resulting in inaccurate young-gen resizing.
-    assert(old_gen->committed().byte_size() >= old_gen->used_in_bytes(), "inv");
-    // Use uint64_t instead of size_t for 32bit compatibility.
-    uint64_t free_mem_in_os;
-    if (os::free_memory(free_mem_in_os)) {
-      size_t actual_free = (size_t)MIN2(old_gen->committed().byte_size() - old_gen->used_in_bytes() + free_mem_in_os,
-                                        (uint64_t)SIZE_MAX);
-      if (promotion_estimate > actual_free) {
-        log_debug(gc, ergo)("Run full-gc; predicted promotion size > free space in old-gen and OS: %zu > %zu",
-          promotion_estimate, actual_free);
-        return ShouldRunFullGC;
-      }
-    }
-  }
-
-  // No particular reasons to run full-gc, so young-gc.
-  return ShouldRunYoungGC;
-}
-
 // Adaptive size policy support.
 void PSScavenge::set_young_generation_boundary(HeapWord* v) {
   _young_generation_boundary = v;

src/hotspot/share/gc/parallel/psScavenge.hpp

@@ -64,8 +64,6 @@ class PSScavenge: AllStatic {
 
   static void clean_up_failed_promotion();
 
-  static bool should_attempt_scavenge();
-
   // Private accessors
   static PSCardTable* card_table()                 { assert(_card_table != nullptr, "Sanity"); return _card_table; }
   static const ParallelScavengeTracer* gc_tracer() { return &_gc_tracer; }