JDK-8293114: GC should trim the native heap

src/hotspot/share/classfile/stringTable.cpp

@@ -37,6 +37,7 @@
 #include "gc/shared/oopStorage.inline.hpp"
 #include "gc/shared/oopStorageSet.hpp"
 #include "gc/shared/stringdedup/stringDedup.hpp"
+#include "gc/shared/trimNative.hpp"
 #include "logging/log.hpp"
 #include "logging/logStream.hpp"
 #include "memory/allocation.inline.hpp"
@@ -456,6 +457,7 @@ void StringTable::clean_dead_entries(JavaThread* jt) {
 
   StringTableDeleteCheck stdc;
   StringTableDoDelete stdd;
+  TrimNative::PauseMark trim_native_pause("stringtable");
   {
     TraceTime timer("Clean", TRACETIME_LOG(Debug, stringtable, perf));
     while(bdt.do_task(jt, stdc, stdd)) {

src/hotspot/share/classfile/symbolTable.cpp

@@ -30,6 +30,7 @@
 #include "classfile/compactHashtable.hpp"
 #include "classfile/javaClasses.hpp"
 #include "classfile/symbolTable.hpp"
+#include "gc/shared/trimNative.hpp"
 #include "memory/allocation.inline.hpp"
 #include "memory/metaspaceClosure.hpp"
 #include "memory/resourceArea.hpp"
@@ -737,6 +738,7 @@ void SymbolTable::clean_dead_entries(JavaThread* jt) {
 
   SymbolTableDeleteCheck stdc;
   SymbolTableDoDelete stdd;
+  TrimNative::PauseMark trim_native_pause("symboltable");
   {
     TraceTime timer("Clean", TRACETIME_LOG(Debug, symboltable, perf));
     while (bdt.do_task(jt, stdc, stdd)) {

src/hotspot/share/gc/g1/g1CollectedHeap.cpp

@@ -91,6 +91,7 @@
 #include "gc/shared/taskqueue.inline.hpp"
 #include "gc/shared/taskTerminator.hpp"
 #include "gc/shared/tlab_globals.hpp"
+#include "gc/shared/trimNative.hpp"
 #include "gc/shared/workerPolicy.hpp"
 #include "gc/shared/weakProcessor.inline.hpp"
 #include "logging/log.hpp"
@@ -914,6 +915,8 @@ bool G1CollectedHeap::do_full_collection(bool clear_all_soft_refs,
     return false;
   }
 
+  TrimNative::PauseMark trim_native_pause("gc");
+
   const bool do_clear_all_soft_refs = clear_all_soft_refs ||
       soft_ref_policy()->should_clear_all_soft_refs();
 
@@ -2549,6 +2552,7 @@ void G1CollectedHeap::retire_tlabs() {
 
 void G1CollectedHeap::do_collection_pause_at_safepoint_helper() {
   ResourceMark rm;
+  TrimNative::PauseMark trim_native_pause("gc");
 
   IsGCActiveMark active_gc_mark;
   GCIdMark gc_id_mark;

src/hotspot/share/gc/g1/g1ConcurrentMark.cpp

@@ -55,6 +55,7 @@
 #include "gc/shared/suspendibleThreadSet.hpp"
 #include "gc/shared/taskTerminator.hpp"
 #include "gc/shared/taskqueue.inline.hpp"
+#include "gc/shared/trimNative.hpp"
 #include "gc/shared/weakProcessor.inline.hpp"
 #include "gc/shared/workerPolicy.hpp"
 #include "jvm.h"
@@ -1234,6 +1235,8 @@ void G1ConcurrentMark::remark() {
     return;
   }
 
+  TrimNative::PauseMark trim_native_pause("gc");
+
   G1Policy* policy = _g1h->policy();
   policy->record_concurrent_mark_remark_start();
 
@@ -1448,6 +1451,8 @@ void G1ConcurrentMark::cleanup() {
     return;
   }
 
+  TrimNative::PauseMark trim_native_pause("gc");
+
   G1Policy* policy = _g1h->policy();
   policy->record_concurrent_mark_cleanup_start();
 

src/hotspot/share/gc/g1/g1FullCollector.cpp

@@ -178,6 +178,7 @@ class PrepareRegionsClosure : public HeapRegionClosure {
 };
 
 void G1FullCollector::prepare_collection() {
+
   _heap->policy()->record_full_collection_start();
 
   // Verification needs the bitmap, so we should clear the bitmap only later.

src/hotspot/share/gc/parallel/psParallelCompact.cpp

@@ -49,6 +49,7 @@
 #include "gc/shared/gcTimer.hpp"
 #include "gc/shared/gcTrace.hpp"
 #include "gc/shared/gcTraceTime.inline.hpp"
+#include "gc/shared/trimNative.hpp"
 #include "gc/shared/isGCActiveMark.hpp"
 #include "gc/shared/oopStorage.inline.hpp"
 #include "gc/shared/oopStorageSet.inline.hpp"
@@ -1709,6 +1710,9 @@ bool PSParallelCompact::invoke_no_policy(bool maximum_heap_compaction) {
     return false;
   }
 
+  // Pause native trimming for the duration of the GC
+  TrimNative::PauseMark trim_native_pause("gc");
+
   ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
 
   GCIdMark gc_id_mark;

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

@@ -690,8 +690,19 @@
   product(uint, GCCardSizeInBytes, 512,                                     \
           "Card table entry size (in bytes) for card based collectors")     \
           range(128, NOT_LP64(512) LP64_ONLY(1024))                         \
-          constraint(GCCardSizeInBytesConstraintFunc,AtParse)
-  // end of GC_FLAGS
+          constraint(GCCardSizeInBytesConstraintFunc,AtParse)               \
+                                                                            \
+  product(bool, TrimNativeHeap, false, EXPERIMENTAL,                        \
+          "GC will attempt to trim the native heap periodically. By "       \
+          "default, the interval time is 60 seconds, but can be "           \
+          "changed using TrimNativeHeapInterval.")                          \
+                                                                            \
+  product(uint, TrimNativeHeapInterval, 60, EXPERIMENTAL,                   \
+          "If TrimNativeHeap is enabled: interval, in seconds, in which "   \
+          "the GC will attempt to trim the native heap.")                   \
+          range(1, UINT_MAX)                                                \
+                                                                            \
+          // end of GC_FLAGS
 
 DECLARE_FLAGS(GC_FLAGS)
 

src/hotspot/share/gc/shared/genCollectedHeap.cpp

@@ -56,6 +56,7 @@
 #include "gc/shared/scavengableNMethods.hpp"
 #include "gc/shared/space.hpp"
 #include "gc/shared/strongRootsScope.hpp"
+#include "gc/shared/trimNative.hpp"
 #include "gc/shared/weakProcessor.hpp"
 #include "gc/shared/workerThread.hpp"
 #include "memory/iterator.hpp"
@@ -442,6 +443,8 @@ void GenCollectedHeap::do_collection(bool           full,
          "the requesting thread should have the Heap_lock");
   guarantee(!is_gc_active(), "collection is not reentrant");
 
+  TrimNative::PauseMark trim_native_pause("gc");
+
   if (GCLocker::check_active_before_gc()) {
     return; // GC is disabled (e.g. JNI GetXXXCritical operation)
   }

src/hotspot/share/gc/shared/trimNative.cpp

@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) 2023 SAP SE. All rights reserved.
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questioSns.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "gc/shared/concurrentGCThread.hpp"
+#include "gc/shared/gc_globals.hpp"
+#include "gc/shared/trimNative.hpp"
+#include "logging/log.hpp"
+#include "runtime/globals_extension.hpp"
+#include "runtime/mutex.hpp"
+#include "runtime/mutexLocker.hpp"
+#include "runtime/os.inline.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+#include "utilities/ticks.hpp"
+
+class NativeTrimmerThread : public ConcurrentGCThread {
+
+  Monitor* _lock;
+
+  int64_t _next_trim_time;
+
+  // Pausing
+  int _pausers;
+  int64_t _next_trim_time_saved;
+
+  static const int64_t never = INT64_MAX;
+
+  static int64_t now() { return os::javaTimeMillis(); }
+
+  void run_service() override {
+
+    log_info(gc, trim)("NativeTrimmer start.");
+
+    int64_t ntt = 0;
+    int64_t tnow = 0;
+
+    for (;;) {
+      // 1 - Wait for _next_trim_time. Handle spurious wakeups and shutdown.
+      {
+        MonitorLocker ml(_lock, Mutex::_no_safepoint_check_flag);
+        do {
+          tnow = now();
+          ntt = _next_trim_time;
+          if (ntt == never) {
+            ml.wait(0); // infinite sleep
+          } else if (ntt > tnow) {
+            ml.wait(ntt - tnow); // sleep till next point
+          }
+          if (should_terminate()) {
+            log_info(gc, trim)("NativeTrimmer stop.");
+            return;
+          }
+          tnow = now();
+          ntt = _next_trim_time;
+        } while (ntt > tnow);
+      }
+
+      // 2 - Trim outside of lock protection.
+      execute_trim_and_log();
+
+      // 3 - Update _next_trim_time; but give concurrent setters preference.
+      {
+        MonitorLocker ml(_lock, Mutex::_no_safepoint_check_flag);
+        tnow = now();
+        int64_t ntt2 = _next_trim_time;
+
+        if (ntt2 == ntt) { // not changed concurrently?
+          _next_trim_time = tnow + (TrimNativeHeapInterval * 1000);
+        }
+      } // Mutex scope
+    }
+  }
+
+  void stop_service() override {
+    MonitorLocker ml(_lock, Mutex::_no_safepoint_check_flag);
+    ml.notify_all();
+  }
+
+  // Execute the native trim, log results.
+  void execute_trim_and_log() const {
+    assert(os::can_trim_native_heap(), "Unexpected");
+    const int64_t tnow = now();
+    os::size_change_t sc;
+    Ticks start = Ticks::now();
+    log_debug(gc, trim)("Trim native heap started...");
+    if (os::trim_native_heap(&sc)) {
+      Tickspan trim_time = (Ticks::now() - start);
+      if (sc.after != SIZE_MAX) {
+        const size_t delta = sc.after < sc.before ? (sc.before - sc.after) : (sc.after - sc.before);
+        const char sign = sc.after < sc.before ? '-' : '+';
+        log_info(gc, trim)("Trim native heap: RSS+Swap: " PROPERFMT "->" PROPERFMT " (%c" PROPERFMT "), %1.3fms",
+                           PROPERFMTARGS(sc.before), PROPERFMTARGS(sc.after), sign, PROPERFMTARGS(delta),
+                           trim_time.seconds() * 1000);
+      } else {
+        log_info(gc, trim)("Trim native heap (no details)");
+      }
+    }
+  }
+
+public:
+
+  NativeTrimmerThread() :
+    _lock(new (std::nothrow) PaddedMonitor(Mutex::nosafepoint, "NativeTrimmer_lock")),
+    _next_trim_time(0),
+    _pausers(0),
+    _next_trim_time_saved(0)
+  {
+    set_name("Native Heap Trimmer");
+    _next_trim_time = now() + TrimNativeHeapInterval * 1000;
+    create_and_start();
+  }
+
+  void pause(const char* reason) {
+    assert(TrimNativeHeap, "Only call if enabled");
+    assert(TrimNativeHeapInterval > 0, "Only call if periodic trimming is enabled");
+    int lvl = 0;
+    {
+      MonitorLocker ml(_lock, Mutex::_no_safepoint_check_flag);
+      if (_pausers == 0) {
+        _next_trim_time_saved = _next_trim_time;
+        _next_trim_time = never;
+      }
+      lvl = ++_pausers;
+      // No need to wakeup trimmer
+    }
+    log_debug(gc, trim)("NativeTrimmer pause (%s) (%d)", reason, lvl);
+  }
+
+  void unpause(const char* reason) {
+    assert(TrimNativeHeap, "Only call if enabled");
+    assert(TrimNativeHeapInterval > 0, "Only call if periodic trimming is enabled");
+    int lvl = 0;
+    {
+      MonitorLocker ml(_lock, Mutex::_no_safepoint_check_flag);
+      lvl = _pausers--;
+      if (_pausers == 0) {
+        _next_trim_time = _next_trim_time_saved;
+        _next_trim_time_saved = 0;
+        ml.notify_all();
+      }
+    }
+    log_debug(gc, trim)("NativeTrimmer unpause (%s) (%d)", reason, lvl);
+  }
+
+}; // NativeTrimmer
+
+static NativeTrimmerThread* g_trimmer_thread = nullptr;
+
+/// GCTrimNative outside facing methods
+
+void TrimNative::initialize() {
+  if (TrimNativeHeap) {
+    if (!os::can_trim_native_heap()) {
+      FLAG_SET_ERGO(TrimNativeHeap, false);
+      log_info(gc, trim)("Native trim not supported on this platform.");
+      return;
+    }
+    g_trimmer_thread = new NativeTrimmerThread();
+    log_info(gc, trim)("Periodic native trim enabled (interval: %u seconds)", TrimNativeHeapInterval);
+  }
+}
+
+void TrimNative::cleanup() {
+  if (g_trimmer_thread != nullptr) {
+    g_trimmer_thread->stop();
+  }
+}
+
+void TrimNative::pause_periodic_trim(const char* reason) {
+  if (g_trimmer_thread != nullptr) {
+    g_trimmer_thread->pause(reason);
+  }
+}
+
+void TrimNative::unpause_periodic_trim(const char* reason) {
+  if (g_trimmer_thread != nullptr) {
+    g_trimmer_thread->unpause(reason);
+  }
+}
+