8365880: Shenandoah: Unify memory usage accounting in ShenandoahFreeSet

src/hotspot/share/gc/shared/gc_globals.hpp

@@ -469,7 +469,7 @@
                                                                             \
   product(size_t, SoftMaxHeapSize, 0, MANAGEABLE,                           \
           "Soft limit for maximum heap size (in bytes)")                    \
-          constraint(SoftMaxHeapSizeConstraintFunc,AfterMemoryInit)         \
+          constraint(SoftMaxHeapSizeConstraintFunc,AfterErgo)               \
                                                                             \
   product(size_t, NewSize, ScaleForWordSize(1*M),                           \
           "Initial new generation size (in bytes)")                         \

src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.cpp

@@ -91,9 +91,10 @@ void ShenandoahGlobalHeuristics::choose_global_collection_set(ShenandoahCollecti
   size_t min_garbage = (free_target > actual_free) ? (free_target - actual_free) : 0;
 
   log_info(gc, ergo)("Adaptive CSet Selection for GLOBAL. Max Young Evacuation: %zu"
-                     "%s, Max Old Evacuation: %zu%s, Actual Free: %zu%s.",
+                     "%s, Max Old Evacuation: %zu%s, Max Either Evacuation: %zu%s, Actual Free: %zu%s.",
                      byte_size_in_proper_unit(max_young_cset), proper_unit_for_byte_size(max_young_cset),
                      byte_size_in_proper_unit(max_old_cset), proper_unit_for_byte_size(max_old_cset),
+                     byte_size_in_proper_unit(unaffiliated_young_memory), proper_unit_for_byte_size(unaffiliated_young_memory),
                      byte_size_in_proper_unit(actual_free), proper_unit_for_byte_size(actual_free));
 
   for (size_t idx = 0; idx < size; idx++) {
@@ -136,9 +137,8 @@ void ShenandoahGlobalHeuristics::choose_global_collection_set(ShenandoahCollecti
       cset->add_region(r);
     }
   }
-
   if (regions_transferred_to_old > 0) {
-    heap->generation_sizer()->force_transfer_to_old(regions_transferred_to_old);
+    assert(young_evac_reserve > regions_transferred_to_old * region_size_bytes, "young reserve cannot be negative");
     heap->young_generation()->set_evacuation_reserve(young_evac_reserve - regions_transferred_to_old * region_size_bytes);
     heap->old_generation()->set_evacuation_reserve(old_evac_reserve + regions_transferred_to_old * region_size_bytes);
   }

src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.cpp

@@ -602,12 +602,12 @@ void ShenandoahOldHeuristics::set_trigger_if_old_is_fragmented(size_t first_old_
 }
 
 void ShenandoahOldHeuristics::set_trigger_if_old_is_overgrown() {
-  size_t old_used = _old_generation->used() + _old_generation->get_humongous_waste();
+  // used() includes humongous waste
+  size_t old_used = _old_generation->used();
   size_t trigger_threshold = _old_generation->usage_trigger_threshold();
   // Detects unsigned arithmetic underflow
   assert(old_used <= _heap->capacity(),
-         "Old used (%zu, %zu) must not be more than heap capacity (%zu)",
-         _old_generation->used(), _old_generation->get_humongous_waste(), _heap->capacity());
+         "Old used (%zu) must not be more than heap capacity (%zu)", _old_generation->used(), _heap->capacity());
   if (old_used > trigger_threshold) {
     _growth_trigger = true;
   }
@@ -679,7 +679,8 @@ bool ShenandoahOldHeuristics::should_start_gc() {
   if (_growth_trigger) {
     // Growth may be falsely triggered during mixed evacuations, before the mixed-evacuation candidates have been
     // evacuated.  Before acting on a false trigger, we check to confirm the trigger condition is still satisfied.
-    const size_t current_usage = _old_generation->used() + _old_generation->get_humongous_waste();
+    // _old_generation->used() includes humongous waste.
+    const size_t current_usage = _old_generation->used();
     const size_t trigger_threshold = _old_generation->usage_trigger_threshold();
     const size_t heap_size = heap->capacity();
     const size_t ignore_threshold = (ShenandoahIgnoreOldGrowthBelowPercentage * heap_size) / 100;

src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp

@@ -1164,6 +1164,9 @@ void ShenandoahConcurrentGC::op_update_thread_roots() {
 
 void ShenandoahConcurrentGC::op_final_update_refs() {
   ShenandoahHeap* const heap = ShenandoahHeap::heap();
+  bool is_generational = heap->mode()->is_generational();
+  ShenandoahGenerationalHeap* const gen_heap = is_generational? ShenandoahGenerationalHeap::heap(): nullptr;
+
   assert(ShenandoahSafepoint::is_at_shenandoah_safepoint(), "must be at safepoint");
   assert(!heap->_update_refs_iterator.has_next(), "Should have finished update references");
 
@@ -1187,7 +1190,7 @@ void ShenandoahConcurrentGC::op_final_update_refs() {
   heap->set_update_refs_in_progress(false);
   heap->set_has_forwarded_objects(false);
 
-  if (heap->mode()->is_generational() && heap->is_concurrent_old_mark_in_progress()) {
+  if (is_generational && heap->is_concurrent_old_mark_in_progress()) {
     // When the SATB barrier is left on to support concurrent old gen mark, it may pick up writes to
     // objects in the collection set. After those objects are evacuated, the pointers in the
     // SATB are no longer safe. Once we have finished update references, we are guaranteed that
@@ -1206,7 +1209,7 @@ void ShenandoahConcurrentGC::op_final_update_refs() {
 
     // Aging_cycle is only relevant during evacuation cycle for individual objects and during final mark for
     // entire regions.  Both of these relevant operations occur before final update refs.
-    ShenandoahGenerationalHeap::heap()->set_aging_cycle(false);
+    gen_heap->set_aging_cycle(false);
   }
 
   if (ShenandoahVerify) {