Work in progress for decoupling memory_pressure_metrics and recording of high usage

Author: jsikstro

src/hotspot/share/gc/z/zAdaptiveHeap.cpp

@@ -372,15 +372,6 @@ ZMemoryPressureMetrics ZAdaptiveHeap::memory_pressure_metrics() {
     container_critical_threshold = machine_critical_threshold;
   }
 
-  // Record sampled memory usage so we can measure memory stability
-  const double machine_usage = double(machine_used_memory) / double(machine_max_memory);
-  ZStatSystemMemoryUsage::record_machine_usage(machine_usage);
-
-  if (is_containerized) {
-    const double container_usage = double(container_used_memory) / double(container_max_memory);
-    ZStatSystemMemoryUsage::record_container_usage(container_usage);
-  }
-
   return {
     unscaled_gc_intensity,
     is_containerized,
@@ -825,6 +816,7 @@ size_t ZAdaptiveHeap::compute_heap_size(ZHeapResizeMetrics* heap_metrics, ZGener
 
   // System memory load
   ZMemoryPressureMetrics mem_metrics = memory_pressure_metrics();
+  ZStatSystemMemoryUsage::record(mem_metrics);
 
   // System CPU load
   ZCpuPressureMetrics cpu_metrics = cpu_pressure_metrics(generation);
@@ -1096,10 +1088,8 @@ static uint64_t system_uncommit_delay(const ZSystemMemoryPressureMetrics& metric
 // How long to wait until it is time to uncommit memory. This goes towards
 // infinity when there is no concerning memory pressure, then from ZUncommitDelay
 // when concerning down to 500 when high, and eventually 0 when critically low.
-uint64_t ZAdaptiveHeap::uncommit_delay() {
+uint64_t ZAdaptiveHeap::uncommit_delay(const ZMemoryPressureMetrics& metrics, size_t capacity) {
   precond(_initialized);
-  ZMemoryPressureMetrics metrics = memory_pressure_metrics();
-  const size_t capacity = ZHeap::heap()->capacity();
 
   const uint64_t machine_uncommit_delay = system_uncommit_delay(metrics._machine, capacity);
 
@@ -1111,6 +1101,17 @@ uint64_t ZAdaptiveHeap::uncommit_delay() {
   return MIN2(machine_uncommit_delay, container_uncommit_delay);
 }
 
+uint64_t ZAdaptiveHeap::uncommit_delay() {
+  precond(_initialized);
+
+  ZMemoryPressureMetrics mem_metrics = memory_pressure_metrics();
+  ZStatSystemMemoryUsage::record(mem_metrics);
+
+  const size_t capacity = ZHeap::heap()->capacity();
+
+  return uncommit_delay(mem_metrics, capacity);
+}
+
 uint64_t ZAdaptiveHeap::soft_ref_delay() {
   precond(_initialized);
   ZStatHeap* const stats = ZGeneration::old()->stat_heap();

src/hotspot/share/gc/z/zAdaptiveHeap.hpp

@@ -150,6 +150,7 @@ class ZAdaptiveHeap : public AllStatic {
   static uint64_t no_uncommit_delay();
   static uint64_t urgent_uncommit_delay();
   static uint64_t critical_uncommit_delay();
+  static uint64_t uncommit_delay(const ZMemoryPressureMetrics& metrics, size_t capacity);
   static uint64_t uncommit_delay();
 
   static uint64_t soft_ref_delay();

src/hotspot/share/gc/z/zMemoryWorker.cpp

@@ -253,10 +253,8 @@ bool ZMemoryWorker::has_uncommit_matured(Ticks now, uint64_t uncommit_delay, siz
   return elapsed >= uncommit_delay;
 }
 
-void ZMemoryWorker::wake_up_if_uncommit_matured() {
+void ZMemoryWorker::wake_up_if_uncommit_matured(uint64_t uncommit_delay) {
   Ticks now = Ticks::now();
-  const uint64_t uncommit_delay = ZAdaptiveHeap::uncommit_delay();
-
   ZLocker<ZConditionLock> locker(&_lock);
   if (has_uncommit_matured(now, uncommit_delay, _target_uncommit_capacity.load_relaxed())) {
     _lock.notify_all();

src/hotspot/share/gc/z/zMemoryWorker.hpp

@@ -104,7 +104,7 @@ class ZMemoryWorker : public ZThread {
   void request_grow_capacity(size_t requested_capacity);
   void request_shrink_capacity(size_t requested_capacity);
   void request_shrink_capacity_granule();
-  void wake_up_if_uncommit_matured();
+  void wake_up_if_uncommit_matured(uint64_t uncommit_delay);
 
   // Heating requests
   void register_heating_request(const ZVirtualMemory& vmem);

src/hotspot/share/gc/z/zPageAllocator.cpp

@@ -1766,25 +1766,31 @@ void ZPageAllocator::heap_truncated(size_t selected_capacity) {
 }
 
 void ZPageAllocator::adjust_capacity(size_t used_soon) {
-  const ZMemoryPressureMetrics mem_pressure = ZAdaptiveHeap::memory_pressure_metrics();
+  const ZMemoryPressureMetrics mem_metrics = ZAdaptiveHeap::memory_pressure_metrics();
+  ZStatSystemMemoryUsage::record(mem_metrics);
+
+  const size_t total_capacity = capacity();
+  const uint64_t uncommit_delay = ZAdaptiveHeap::uncommit_delay(mem_metrics, total_capacity);
+
   ZPerNUMAIterator<ZPartition> iter = partition_iterator();
 
   for (ZPartition* partition; iter.next(&partition);) {
     ZMemoryWorker& mem_worker = partition->memory_worker();
-    const size_t cap = partition->capacity();
+    const size_t partition_capacity = partition->capacity();
 
-    if (ZAdaptiveHeap::is_memory_pressure_high(mem_pressure)) {
+    if (ZAdaptiveHeap::is_memory_pressure_high(mem_metrics)) {
       // When memory usage is high, request uncommitting if possible
       mem_worker.request_shrink_capacity_granule();
     } else {
       // When memory pressure is not high, try to commit memory ahead of mutators.
       const uint32_t numa_id = partition->numa_id();
       const size_t used_soon_share = ZNUMA::calculate_share(numa_id, used_soon);
-      if (used_soon_share > cap) {
+      if (used_soon_share > partition_capacity) {
         mem_worker.request_grow_capacity(used_soon_share);
       }
     }
-    mem_worker.wake_up_if_uncommit_matured();
+
+    mem_worker.wake_up_if_uncommit_matured(uncommit_delay);
   }
 }
 

src/hotspot/share/gc/z/zStat.cpp

@@ -1066,6 +1066,16 @@ void ZStatSystemMemoryUsage::ZSystemMemoryUsage::sample_and_collect() {
   _memory_stability.store_relaxed(sd);
 }
 
+void ZStatSystemMemoryUsage::record(const ZMemoryPressureMetrics& metrics) {
+  const double machine_usage = double(metrics._machine._used_memory) / double(metrics._machine._max_memory);
+  record_machine_usage(machine_usage);
+
+  if (metrics._is_containerized) {
+    const double container_usage = double(metrics._container._used_memory) / double(metrics._container._max_memory);
+    record_container_usage(container_usage);
+  }
+}
+
 void ZStatSystemMemoryUsage::record_container_usage(double usage) {
   _container_usage.record_usage(usage);
 }

src/hotspot/share/gc/z/zStat.hpp

@@ -40,6 +40,7 @@
 
 class GCTracer;
 class ZGeneration;
+struct ZMemoryPressureMetrics;
 class ZPage;
 class ZPageAllocatorStats;
 class ZRelocationSetSelectorGroupStats;
@@ -403,6 +404,7 @@ class ZStatSystemMemoryUsage : public AllStatic {
   static ZSystemMemoryUsage _machine_usage;
 
 public:
+  static void record(const ZMemoryPressureMetrics& metrics);
   static void record_container_usage(double usage);
   static void record_machine_usage(double usage);