8365880: Shenandoah: Unify memory usage accounting in ShenandoahFreeSet

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

@@ -88,9 +88,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++) {
@@ -133,9 +134,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

@@ -606,12 +606,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;
   }
@@ -683,7 +683,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/shenandoahFullGC.cpp

@@ -237,7 +237,6 @@ void ShenandoahFullGC::do_it(GCCause::Cause gc_cause) {
     worker_slices[i] = new ShenandoahHeapRegionSet();
   }
 
-  ShenandoahGenerationalHeap::TransferResult result;
   {
     // The rest of code performs region moves, where region status is undefined
     // until all phases run together.
@@ -251,14 +250,7 @@ void ShenandoahFullGC::do_it(GCCause::Cause gc_cause) {
 
     phase4_compact_objects(worker_slices);
 
-    result = phase5_epilog();
-  }
-  if (heap->mode()->is_generational()) {
-    LogTarget(Info, gc, ergo) lt;
-    if (lt.is_enabled()) {
-      LogStream ls(lt);
-      result.print_on("Full GC", &ls);
-    }
+    phase5_epilog();
   }
 
   // Resize metaspace
@@ -984,23 +976,6 @@ class ShenandoahPostCompactClosure : public ShenandoahHeapRegionClosure {
     r->set_live_data(live);
     r->reset_alloc_metadata();
   }
-
-  void update_generation_usage() {
-    if (_is_generational) {
-      _heap->old_generation()->establish_usage(_old_regions, _old_usage, _old_humongous_waste);
-      _heap->young_generation()->establish_usage(_young_regions, _young_usage, _young_humongous_waste);
-    } else {
-      assert(_old_regions == 0, "Old regions only expected in generational mode");
-      assert(_old_usage == 0, "Old usage only expected in generational mode");
-      assert(_old_humongous_waste == 0, "Old humongous waste only expected in generational mode");
-    }
-
-    // In generational mode, global usage should be the sum of young and old. This is also true
-    // for non-generational modes except that there are no old regions.
-    _heap->global_generation()->establish_usage(_old_regions + _young_regions,
-                                                _old_usage + _young_usage,
-                                                _old_humongous_waste + _young_humongous_waste);
-  }
 };
 
 void ShenandoahFullGC::compact_humongous_objects() {
@@ -1120,10 +1095,9 @@ void ShenandoahFullGC::phase4_compact_objects(ShenandoahHeapRegionSet** worker_s
   }
 }
 
-ShenandoahGenerationalHeap::TransferResult ShenandoahFullGC::phase5_epilog() {
+void ShenandoahFullGC::phase5_epilog() {
   GCTraceTime(Info, gc, phases) time("Phase 5: Full GC epilog", _gc_timer);
   ShenandoahHeap* heap = ShenandoahHeap::heap();
-  ShenandoahGenerationalHeap::TransferResult result;
 
   // Reset complete bitmap. We're about to reset the complete-top-at-mark-start pointer
   // and must ensure the bitmap is in sync.
@@ -1138,12 +1112,6 @@ ShenandoahGenerationalHeap::TransferResult ShenandoahFullGC::phase5_epilog() {
     ShenandoahGCPhase phase(ShenandoahPhaseTimings::full_gc_copy_objects_rebuild);
     ShenandoahPostCompactClosure post_compact;
     heap->heap_region_iterate(&post_compact);
-    post_compact.update_generation_usage();
-
-    if (heap->mode()->is_generational()) {
-      ShenandoahGenerationalFullGC::balance_generations_after_gc(heap);
-    }
-
     heap->collection_set()->clear();
     size_t young_cset_regions, old_cset_regions;
     size_t first_old, last_old, num_old;
@@ -1166,11 +1134,7 @@ ShenandoahGenerationalHeap::TransferResult ShenandoahFullGC::phase5_epilog() {
   _preserved_marks->restore(heap->workers());
   _preserved_marks->reclaim();
 
-  // We defer generation resizing actions until after cset regions have been recycled.  We do this even following an
-  // abbreviated cycle.
   if (heap->mode()->is_generational()) {
-    result = ShenandoahGenerationalFullGC::balance_generations_after_rebuilding_free_set();
     ShenandoahGenerationalFullGC::rebuild_remembered_set(heap);
   }
-  return result;
 }

src/hotspot/share/gc/shenandoah/shenandoahFullGC.hpp

@@ -82,8 +82,7 @@ class ShenandoahFullGC : public ShenandoahGC {
   void phase2_calculate_target_addresses(ShenandoahHeapRegionSet** worker_slices);
   void phase3_update_references();
   void phase4_compact_objects(ShenandoahHeapRegionSet** worker_slices);
-  ShenandoahGenerationalHeap::TransferResult phase5_epilog();
-
+  void phase5_epilog();
   void distribute_slices(ShenandoahHeapRegionSet** worker_slices);
   void calculate_target_humongous_objects();
   void compact_humongous_objects();