8366881: Parallel: Obsolete HeapMaximumCompactionInterval

albertnetymk · albertnetymk · commit 3e68d7d99fcf · 2025-09-08T19:13:55.000Z
Reviewed-by: iwalulya
diff --git a/src/hotspot/share/gc/parallel/parallelScavengeHeap.cpp b/src/hotspot/share/gc/parallel/parallelScavengeHeap.cpp
@@ -334,7 +334,9 @@ HeapWord* ParallelScavengeHeap::mem_allocate_work(size_t size, bool is_tlab) {
 }
 
 void ParallelScavengeHeap::do_full_collection(bool clear_all_soft_refs) {
-  PSParallelCompact::invoke(clear_all_soft_refs);
+  // No need for max-compaction in this context.
+  const bool should_do_max_compaction = false;
+  PSParallelCompact::invoke(clear_all_soft_refs, should_do_max_compaction);
 }
 
 static bool check_gc_heap_free_limit(size_t free_bytes, size_t capacity_bytes) {
@@ -394,21 +396,11 @@ HeapWord* ParallelScavengeHeap::satisfy_failed_allocation(size_t size, bool is_t
     }
   }
 
-  // If we reach this point, we're really out of memory. Try every trick
-  // we can to reclaim memory. Force collection of soft references. Force
-  // a complete compaction of the heap. Any additional methods for finding
-  // free memory should be here, especially if they are expensive. If this
-  // attempt fails, an OOM exception will be thrown.
+  // Last resort GC; clear soft refs and do max-compaction before throwing OOM.
   {
-    // Make sure the heap is fully compacted
-    uintx old_interval = HeapMaximumCompactionInterval;
-    HeapMaximumCompactionInterval = 0;
-
     const bool clear_all_soft_refs = true;
-    PSParallelCompact::invoke(clear_all_soft_refs);
-
-    // Restore
-    HeapMaximumCompactionInterval = old_interval;
+    const bool should_do_max_compaction = true;
+    PSParallelCompact::invoke(clear_all_soft_refs, should_do_max_compaction);
   }
 
   if (check_gc_overhead_limit()) {
@@ -493,7 +485,8 @@ void ParallelScavengeHeap::collect_at_safepoint(bool full) {
     }
     // Upgrade to Full-GC if young-gc fails
   }
-  PSParallelCompact::invoke(clear_soft_refs);
+  const bool should_do_max_compaction = false;
+  PSParallelCompact::invoke(clear_soft_refs, should_do_max_compaction);
 }
 
 void ParallelScavengeHeap::object_iterate(ObjectClosure* cl) {
diff --git a/src/hotspot/share/gc/parallel/parallel_globals.hpp b/src/hotspot/share/gc/parallel/parallel_globals.hpp
@@ -31,11 +31,6 @@
                           product_pd,                                       \
                           range,                                            \
                           constraint)                                       \
-  product(uintx, HeapMaximumCompactionInterval, 20,                         \
-          "How often should we maximally compact the heap (not allowing "   \
-          "any dead space)")                                                \
-          range(0, max_uintx)                                               \
-                                                                            \
   product(bool, UseMaximumCompactionOnSystemGC, true,                       \
           "Use maximum compaction in the Parallel Old garbage collector "   \
           "for a system GC")                                                \
diff --git a/src/hotspot/share/gc/parallel/psParallelCompact.cpp b/src/hotspot/share/gc/parallel/psParallelCompact.cpp
@@ -826,7 +826,8 @@ void PSParallelCompact::fill_dense_prefix_end(SpaceId id) {
   }
 }
 
-bool PSParallelCompact::check_maximum_compaction(size_t total_live_words,
+bool PSParallelCompact::check_maximum_compaction(bool should_do_max_compaction,
+                                                 size_t total_live_words,
                                                  MutableSpace* const old_space,
                                                  HeapWord* full_region_prefix_end) {
 
@@ -839,25 +840,17 @@ bool PSParallelCompact::check_maximum_compaction(size_t total_live_words,
   // Check if all live objs are too much for old-gen.
   const bool is_old_gen_too_full = (total_live_words >= old_space->capacity_in_words());
 
-  // JVM flags
-  const uint total_invocations = heap->total_full_collections();
-  assert(total_invocations >= _maximum_compaction_gc_num, "sanity");
-  const size_t gcs_since_max = total_invocations - _maximum_compaction_gc_num;
-  const bool is_interval_ended = gcs_since_max > HeapMaximumCompactionInterval;
-
   // If all regions in old-gen are full
   const bool is_region_full =
     full_region_prefix_end >= _summary_data.region_align_down(old_space->top());
 
-  if (is_max_on_system_gc || is_old_gen_too_full || is_interval_ended || is_region_full) {
-    _maximum_compaction_gc_num = total_invocations;
-    return true;
-  }
-
-  return false;
+  return should_do_max_compaction
+      || is_max_on_system_gc
+      || is_old_gen_too_full
+      || is_region_full;
 }
 
-void PSParallelCompact::summary_phase()
+void PSParallelCompact::summary_phase(bool should_do_max_compaction)
 {
   GCTraceTime(Info, gc, phases) tm("Summary Phase", &_gc_timer);
 
@@ -880,9 +873,10 @@ void PSParallelCompact::summary_phase()
       _space_info[i].set_dense_prefix(space->bottom());
     }
 
-    bool maximum_compaction = check_maximum_compaction(total_live_words,
-                                                       old_space,
-                                                       full_region_prefix_end);
+    should_do_max_compaction = check_maximum_compaction(should_do_max_compaction,
+                                                        total_live_words,
+                                                        old_space,
+                                                        full_region_prefix_end);
     {
       GCTraceTime(Info, gc, phases) tm("Summary Phase: expand", &_gc_timer);
       // Try to expand old-gen in order to fit all live objs and waste.
@@ -891,7 +885,7 @@ void PSParallelCompact::summary_phase()
       ParallelScavengeHeap::heap()->old_gen()->try_expand_till_size(target_capacity_bytes);
     }
 
-    HeapWord* dense_prefix_end = maximum_compaction
+    HeapWord* dense_prefix_end = should_do_max_compaction
                                  ? full_region_prefix_end
                                  : compute_dense_prefix_for_old_space(old_space,
                                                                       full_region_prefix_end);
@@ -961,11 +955,7 @@ void PSParallelCompact::summary_phase()
   }
 }
 
-// This method invokes a full collection. The argument controls whether
-// soft-refs should be cleared or not.
-// Note that this method should only be called from the vm_thread while at a
-// safepoint.
-bool PSParallelCompact::invoke(bool clear_all_soft_refs) {
+bool PSParallelCompact::invoke(bool clear_all_soft_refs, bool should_do_max_compaction) {
   assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");
   assert(Thread::current() == (Thread*)VMThread::vm_thread(),
          "should be in vm thread");
@@ -1020,7 +1010,7 @@ bool PSParallelCompact::invoke(bool clear_all_soft_refs) {
 
     marking_phase(&_gc_tracer);
 
-    summary_phase();
+    summary_phase(should_do_max_compaction);
 
 #if COMPILER2_OR_JVMCI
     assert(DerivedPointerTable::is_active(), "Sanity");
diff --git a/src/hotspot/share/gc/parallel/psParallelCompact.hpp b/src/hotspot/share/gc/parallel/psParallelCompact.hpp
@@ -727,7 +727,8 @@ class PSParallelCompact : AllStatic {
   static void pre_compact();
   static void post_compact();
 
-  static bool check_maximum_compaction(size_t total_live_words,
+  static bool check_maximum_compaction(bool should_do_max_compaction,
+                                       size_t total_live_words,
                                        MutableSpace* const old_space,
                                        HeapWord* full_region_prefix_end);
 
@@ -742,7 +743,7 @@ class PSParallelCompact : AllStatic {
   // make the heap parsable.
   static void fill_dense_prefix_end(SpaceId id);
 
-  static void summary_phase();
+  static void summary_phase(bool should_do_max_compaction);
 
   static void adjust_pointers();
   static void forward_to_new_addr();
@@ -761,7 +762,10 @@ class PSParallelCompact : AllStatic {
 public:
   static void fill_dead_objs_in_dense_prefix(uint worker_id, uint num_workers);
 
-  static bool invoke(bool clear_all_soft_refs);
+  // This method invokes a full collection.
+  // clear_all_soft_refs controls whether soft-refs should be cleared or not.
+  // should_do_max_compaction controls whether all spaces for dead objs should be reclaimed.
+  static bool invoke(bool clear_all_soft_refs, bool should_do_max_compaction);
 
   template<typename Func>
   static void adjust_in_space_helper(SpaceId id, volatile uint* claim_counter, Func&& on_stripe);
diff --git a/src/hotspot/share/runtime/arguments.cpp b/src/hotspot/share/runtime/arguments.cpp
@@ -568,6 +568,7 @@ static SpecialFlag const special_jvm_flags[] = {
   { "UsePSAdaptiveSurvivorSizePolicy",                  JDK_Version::undefined(), JDK_Version::jdk(26), JDK_Version::jdk(27) },
 
   { "PretenureSizeThreshold",       JDK_Version::undefined(), JDK_Version::jdk(26), JDK_Version::jdk(27) },
+  { "HeapMaximumCompactionInterval",JDK_Version::undefined(), JDK_Version::jdk(26), JDK_Version::jdk(27) },
 
 #ifdef ASSERT
   { "DummyObsoleteTestFlag",        JDK_Version::undefined(), JDK_Version::jdk(18), JDK_Version::undefined() },

Original file line number	Diff line number	Diff line change
`@@ -334,7 +334,9 @@ HeapWord* ParallelScavengeHeap::mem_allocate_work(size_t size, bool is_tlab) {`
`334`	`334`	`}`
`335`	`335`
`336`	`336`	`void ParallelScavengeHeap::do_full_collection(bool clear_all_soft_refs) {`
`337`		`- PSParallelCompact::invoke(clear_all_soft_refs);`
	`337`	`+ // No need for max-compaction in this context.`
	`338`	`+ const bool should_do_max_compaction = false;`
	`339`	`+ PSParallelCompact::invoke(clear_all_soft_refs, should_do_max_compaction);`
`338`	`340`	`}`
`339`	`341`
`340`	`342`	`static bool check_gc_heap_free_limit(size_t free_bytes, size_t capacity_bytes) {`
`@@ -394,21 +396,11 @@ HeapWord* ParallelScavengeHeap::satisfy_failed_allocation(size_t size, bool is_t`
`394`	`396`	`}`
`395`	`397`	`}`
`396`	`398`
`397`		`- // If we reach this point, we're really out of memory. Try every trick`
`398`		`- // we can to reclaim memory. Force collection of soft references. Force`
`399`		`- // a complete compaction of the heap. Any additional methods for finding`
`400`		`- // free memory should be here, especially if they are expensive. If this`
`401`		`- // attempt fails, an OOM exception will be thrown.`
	`399`	`+ // Last resort GC; clear soft refs and do max-compaction before throwing OOM.`
`402`	`400`	`{`
`403`		`- // Make sure the heap is fully compacted`
`404`		`- uintx old_interval = HeapMaximumCompactionInterval;`
`405`		`- HeapMaximumCompactionInterval = 0;`
`406`		`-`
`407`	`401`	`const bool clear_all_soft_refs = true;`
`408`		`- PSParallelCompact::invoke(clear_all_soft_refs);`
`409`		`-`
`410`		`- // Restore`
`411`		`- HeapMaximumCompactionInterval = old_interval;`
	`402`	`+ const bool should_do_max_compaction = true;`
	`403`	`+ PSParallelCompact::invoke(clear_all_soft_refs, should_do_max_compaction);`
`412`	`404`	`}`
`413`	`405`
`414`	`406`	`if (check_gc_overhead_limit()) {`
`@@ -493,7 +485,8 @@ void ParallelScavengeHeap::collect_at_safepoint(bool full) {`
`493`	`485`	`}`
`494`	`486`	`// Upgrade to Full-GC if young-gc fails`
`495`	`487`	`}`
`496`		`- PSParallelCompact::invoke(clear_soft_refs);`
	`488`	`+ const bool should_do_max_compaction = false;`
	`489`	`+ PSParallelCompact::invoke(clear_soft_refs, should_do_max_compaction);`
`497`	`490`	`}`
`498`	`491`
`499`	`492`	`void ParallelScavengeHeap::object_iterate(ObjectClosure* cl) {`