8356716: ZGC: Cleanup Uncommit Logic

Reviewed-by: eosterlund, jsikstro

Author: xmas92

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

@@ -405,7 +405,7 @@ ZVirtualMemory ZMappedCache::remove_vmem(ZMappedCacheEntry* const entry, size_t
 
   // Update statistics
   _size -= to_remove;
-  _min = MIN2(_size, _min);
+  _min_size_watermark = MIN2(_size, _min_size_watermark);
 
   postcond(to_remove == vmem.size());
   return vmem;
@@ -558,7 +558,7 @@ ZMappedCache::ZMappedCache()
   : _tree(),
     _size_class_lists(),
     _size(0),
-    _min(_size) {}
+    _min_size_watermark(_size) {}
 
 void ZMappedCache::insert(const ZVirtualMemory& vmem) {
   _size += vmem.size();
@@ -688,17 +688,15 @@ size_t ZMappedCache::remove_discontiguous(size_t size, ZArray<ZVirtualMemory>* o
   return remove_discontiguous_with_strategy<RemovalStrategy::SizeClasses>(size, out);
 }
 
-size_t ZMappedCache::reset_min() {
-  const size_t old_min = _min;
-
-  _min = _size;
-
-  return old_min;
+void ZMappedCache::reset_min_size_watermark() {
+  _min_size_watermark = _size;
 }
 
-size_t ZMappedCache::remove_from_min(size_t max_size, ZArray<ZVirtualMemory>* out) {
-  const size_t size = MIN2(_min, max_size);
+size_t ZMappedCache::min_size_watermark() {
+  return _min_size_watermark;
+}
 
+size_t ZMappedCache::remove_for_uncommit(size_t size, ZArray<ZVirtualMemory>* out) {
   if (size == 0) {
     return 0;
   }

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

@@ -92,7 +92,7 @@ class ZMappedCache {
   Tree          _tree;
   SizeClassList _size_class_lists[NumSizeClasses];
   size_t        _size;
-  size_t        _min;
+  size_t        _min_size_watermark;
 
   static int size_class_index(size_t size);
   static int guaranteed_size_class_index(size_t size);
@@ -132,8 +132,10 @@ class ZMappedCache {
   ZVirtualMemory remove_contiguous_power_of_2(size_t min_size, size_t max_size);
   size_t remove_discontiguous(size_t size, ZArray<ZVirtualMemory>* out);
 
-  size_t reset_min();
-  size_t remove_from_min(size_t max_size, ZArray<ZVirtualMemory>* out);
+  // ZUncommitter support
+  void reset_min_size_watermark();
+  size_t min_size_watermark();
+  size_t remove_for_uncommit(size_t size, ZArray<ZVirtualMemory>* out);
 
   void print_on(outputStream* st) const;
   void print_extended_on(outputStream* st) const;

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

@@ -630,9 +630,6 @@ ZPartition::ZPartition(uint32_t numa_id, ZPageAllocator* page_allocator)
     _capacity(0),
     _claimed(0),
     _used(0),
-    _last_commit(0.0),
-    _last_uncommit(0.0),
-    _to_uncommit(0),
     _numa_id(numa_id) {}
 
 uint32_t ZPartition::numa_id() const {
@@ -650,9 +647,7 @@ size_t ZPartition::increase_capacity(size_t size) {
     // Update atomically since we have concurrent readers
     Atomic::add(&_capacity, increased);
 
-    _last_commit = os::elapsedTime();
-    _last_uncommit = 0;
-    _cache.reset_min();
+    _uncommitter.cancel_uncommit_cycle();
   }
 
   return increased;
@@ -787,101 +782,6 @@ bool ZPartition::claim_capacity_fast_medium(ZMemoryAllocation* allocation) {
   return true;
 }
 
-size_t ZPartition::uncommit(uint64_t* timeout) {
-  ZArray<ZVirtualMemory> flushed_vmems;
-  size_t flushed = 0;
-
-  {
-    // We need to join the suspendible thread set while manipulating capacity
-    // and used, to make sure GC safepoints will have a consistent view.
-    SuspendibleThreadSetJoiner sts_joiner;
-    ZLocker<ZLock> locker(&_page_allocator->_lock);
-
-    const double now = os::elapsedTime();
-    const double time_since_last_commit = std::floor(now - _last_commit);
-    const double time_since_last_uncommit = std::floor(now - _last_uncommit);
-
-    if (time_since_last_commit < double(ZUncommitDelay)) {
-      // We have committed within the delay, stop uncommitting.
-      *timeout = uint64_t(double(ZUncommitDelay) - time_since_last_commit);
-      return 0;
-    }
-
-    // We flush out and uncommit chunks at a time (~0.8% of the max capacity,
-    // but at least one granule and at most 256M), in case demand for memory
-    // increases while we are uncommitting.
-    const size_t limit_upper_bound = MAX2(ZGranuleSize, align_down(256 * M / ZNUMA::count(), ZGranuleSize));
-    const size_t limit = MIN2(align_up(_current_max_capacity >> 7, ZGranuleSize), limit_upper_bound);
-
-    if (limit == 0) {
-      // This may occur if the current max capacity for this partition is 0
-
-      // Set timeout to ZUncommitDelay
-      *timeout = ZUncommitDelay;
-      return 0;
-    }
-
-    if (time_since_last_uncommit < double(ZUncommitDelay)) {
-      // We are in the uncommit phase
-      const size_t num_uncommits_left = _to_uncommit / limit;
-      const double time_left = double(ZUncommitDelay) - time_since_last_uncommit;
-      if (time_left < *timeout * num_uncommits_left) {
-        // Running out of time, speed up.
-        uint64_t new_timeout = uint64_t(std::floor(time_left / double(num_uncommits_left + 1)));
-        *timeout = new_timeout;
-      }
-    } else {
-      // We are about to start uncommitting
-      _to_uncommit = _cache.reset_min();
-      _last_uncommit = now;
-
-      const size_t split = _to_uncommit / limit + 1;
-      uint64_t new_timeout = ZUncommitDelay / split;
-      *timeout = new_timeout;
-    }
-
-    // Never uncommit below min capacity.
-    const size_t retain = MAX2(_used, _min_capacity);
-    const size_t release = _capacity - retain;
-    const size_t flush = MIN3(release, limit, _to_uncommit);
-
-    if (flush == 0) {
-      // Nothing to flush
-      return 0;
-    }
-
-    // Flush memory from the mapped cache to uncommit
-    flushed = _cache.remove_from_min(flush, &flushed_vmems);
-    if (flushed == 0) {
-      // Nothing flushed
-      return 0;
-    }
-
-    // Record flushed memory as claimed and how much we've flushed for this partition
-    Atomic::add(&_claimed, flushed);
-    _to_uncommit -= flushed;
-  }
-
-  // Unmap and uncommit flushed memory
-  for (const ZVirtualMemory vmem : flushed_vmems) {
-    unmap_virtual(vmem);
-    uncommit_physical(vmem);
-    free_physical(vmem);
-    free_virtual(vmem);
-  }
-
-  {
-    SuspendibleThreadSetJoiner sts_joiner;
-    ZLocker<ZLock> locker(&_page_allocator->_lock);
-
-    // Adjust claimed and capacity to reflect the uncommit
-    Atomic::sub(&_claimed, flushed);
-    decrease_capacity(flushed, false /* set_max_capacity */);
-  }
-
-  return flushed;
-}
-
 void ZPartition::sort_segments_physical(const ZVirtualMemory& vmem) {
   verify_virtual_memory_association(vmem, true /* check_multi_partition */);
 

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

@@ -57,6 +57,7 @@ class ZWorkers;
 class ZPartition {
   friend class VMStructs;
   friend class ZPageAllocator;
+  friend class ZUncommitter;
 
 private:
   ZPageAllocator* const _page_allocator;
@@ -68,9 +69,6 @@ class ZPartition {
   volatile size_t       _capacity;
   volatile size_t       _claimed;
   size_t                _used;
-  double                _last_commit;
-  double                _last_uncommit;
-  size_t                _to_uncommit;
   const uint32_t        _numa_id;
 
   const ZVirtualMemoryManager& virtual_memory_manager() const;
@@ -103,8 +101,6 @@ class ZPartition {
   bool claim_capacity(ZMemoryAllocation* allocation);
   bool claim_capacity_fast_medium(ZMemoryAllocation* allocation);
 
-  size_t uncommit(uint64_t* timeout);
-
   void sort_segments_physical(const ZVirtualMemory& vmem);
 
   void claim_physical(const ZVirtualMemory& vmem);

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

@@ -113,6 +113,11 @@ void ZPhysicalMemoryManager::try_enable_uncommit(size_t min_capacity, size_t max
     return;
   }
 
+  const size_t max_delay_without_overflow = std::numeric_limits<uint64_t>::max() / MILLIUNITS;
+  if (ZUncommitDelay > max_delay_without_overflow) {
+    FLAG_SET_ERGO(ZUncommitDelay, max_delay_without_overflow);
+  }
+
   log_info_p(gc, init)("Uncommit: Enabled");
   log_info_p(gc, init)("Uncommit Delay: %zus", ZUncommitDelay);
 }