File _service:tar_scm:8293114-GC-should-trim-the-nat... of Package openjdk-1.8.0

File _service:tar_scm:8293114-GC-should-trim-the-native-heap-and-bug-fix.patch of Package openjdk-1.8.0

From a5edc79220300bce7952feaacf28a832306884d8 Mon Sep 17 00:00:00 2001
From: eapen <zhangyipeng7@huawei.com>
Date: Mon, 12 Dec 2022 19:28:28 +0800
Subject: [PATCH 14/33] I68TO2: 8293114: GC should trim the native heap,8136854：G1 ConcurrentG1RefineThread::stop delays JVM shutdown for >150ms
---
 hotspot/src/os/aix/vm/os_aix.cpp                   |   5 +
 hotspot/src/os/bsd/vm/os_bsd.cpp                   |   5 +
 hotspot/src/os/linux/vm/os_linux.cpp               | 149 ++++++-
 hotspot/src/os/linux/vm/os_linux.hpp               |  57 ++-
 hotspot/src/os/linux/vm/trimCHeapDCmd.cpp          |  59 +--
 hotspot/src/os/windows/vm/os_windows.cpp           |   4 +
 .../vm/gc_implementation/g1/g1CollectedHeap.cpp    |   6 +
 .../parallelScavenge/parallelScavengeHeap.cpp      |   3 +
 .../parallelScavenge/psParallelCompact.cpp         |   6 +
 .../shared/concurrentGCThread.cpp                  |   8 +-
 .../shared/concurrentGCThread.hpp                  |   6 +-
 .../gc_implementation/shared/gcTrimNativeHeap.cpp  | 246 ++++++++++++
 .../gc_implementation/shared/gcTrimNativeHeap.hpp  |  66 ++++
 hotspot/src/share/vm/memory/genCollectedHeap.cpp   |   6 +
 hotspot/src/share/vm/memory/sharedHeap.cpp         |   6 +
 hotspot/src/share/vm/runtime/globals.hpp           |  10 +
 hotspot/src/share/vm/runtime/init.cpp              |   5 +-
 hotspot/src/share/vm/runtime/java.cpp              |   3 +
 hotspot/src/share/vm/runtime/os.hpp                |  11 +
 .../src/share/vm/utilities/globalDefinitions.hpp   |   3 +
 hotspot/test/gc/TestTrimNative.java                | 435 +++++++++++++++++++++
 .../test/serviceability/dcmd/TrimLibcHeapTest.java |   7 +-
 22 files changed, 994 insertions(+), 112 deletions(-)
 create mode 100644 hotspot/src/share/vm/gc_implementation/shared/gcTrimNativeHeap.cpp
 create mode 100644 hotspot/src/share/vm/gc_implementation/shared/gcTrimNativeHeap.hpp
 create mode 100644 hotspot/test/gc/TestTrimNative.java

diff --git a/hotspot/src/os/aix/vm/os_aix.cpp b/hotspot/src/os/aix/vm/os_aix.cpp
index b078bee..519b085 100644
--- a/hotspot/src/os/aix/vm/os_aix.cpp
+++ b/hotspot/src/os/aix/vm/os_aix.cpp
@@ -5266,3 +5266,8 @@ void TestReserveMemorySpecial_test() {
   // No tests available for this platform
 }
 #endif
+
+// stubbed-out trim-native support
+bool os::can_trim_native_heap() { return false; }
+bool os::should_trim_native_heap() { return false; }
+bool os::trim_native_heap(os::size_change_t* rss_change) { return false; }
\ No newline at end of file
diff --git a/hotspot/src/os/bsd/vm/os_bsd.cpp b/hotspot/src/os/bsd/vm/os_bsd.cpp
index 340334c..85e2861 100644
--- a/hotspot/src/os/bsd/vm/os_bsd.cpp
+++ b/hotspot/src/os/bsd/vm/os_bsd.cpp
@@ -4899,3 +4899,8 @@ void TestReserveMemorySpecial_test() {
   // No tests available for this platform
 }
 #endif
+
+// stubbed-out trim-native support
+bool os::can_trim_native_heap() { return false; }
+bool os::should_trim_native_heap() { return false; }
+bool os::trim_native_heap(os::size_change_t* rss_change) { return false; }
\ No newline at end of file
diff --git a/hotspot/src/os/linux/vm/os_linux.cpp b/hotspot/src/os/linux/vm/os_linux.cpp
index 099dafa..abf2031 100644
--- a/hotspot/src/os/linux/vm/os_linux.cpp
+++ b/hotspot/src/os/linux/vm/os_linux.cpp
@@ -153,8 +153,28 @@ const char * os::Linux::_libpthread_version = NULL;
 pthread_condattr_t os::Linux::_condattr[1];

#ifdef __GLIBC__
-os::Linux::mallinfo_func_t os::Linux::_mallinfo = NULL;
-os::Linux::mallinfo2_func_t os::Linux::_mallinfo2 = NULL;
+// We want to be runnable with both old and new glibcs.
+// Old glibcs offer mallinfo(). New glibcs deprecate mallinfo() and offer mallinfo2()
+// as replacement. Future glibc's may remove the deprecated mallinfo().
+// Therefore we may have one, both, or possibly neither (?). Code should tolerate all
+// cases, which is why we resolve the functions dynamically. Outside code should use
+// the Linux::get_mallinfo() utility function which exists to hide this mess.
+struct glibc_mallinfo {
+  int arena;
+  int ordblks;
+  int smblks;
+  int hblks;
+  int hblkhd;
+  int usmblks;
+  int fsmblks;
+  int uordblks;
+  int fordblks;
+  int keepcost;
+};
+typedef struct glibc_mallinfo (*mallinfo_func_t)(void);
+typedef struct os::Linux::glibc_mallinfo2 (*mallinfo2_func_t)(void);
+static mallinfo_func_t g_mallinfo = NULL;
+static mallinfo2_func_t g_mallinfo2 = NULL;
 #endif // __GLIBC__

static jlong initial_time_count=0;
@@ -2348,23 +2368,21 @@ void os::Linux::print_process_memory_info(outputStream* st) {
   // Print glibc outstanding allocations.
   // (note: there is no implementation of mallinfo for muslc)
 #ifdef __GLIBC__
-  size_t total_allocated = 0;
   bool might_have_wrapped = false;
-  if (_mallinfo2 != NULL) {
-    struct glibc_mallinfo2 mi = _mallinfo2();
-    total_allocated = mi.uordblks;
-  } else if (_mallinfo != NULL) {
-    // mallinfo is an old API. Member names mean next to nothing and, beyond that, are int.
-    // So values may have wrapped around. Still useful enough to see how much glibc thinks
-    // we allocated.
-    struct glibc_mallinfo mi = _mallinfo();
-    total_allocated = (size_t)(unsigned)mi.uordblks;
-    // Since mallinfo members are int, glibc values may have wrapped. Warn about this.
-    might_have_wrapped = (info.vmrss * K) > UINT_MAX && (info.vmrss * K) > (total_allocated + UINT_MAX);
-  }
-  if (_mallinfo2 != NULL || _mallinfo != NULL) {
-    st->print_cr("C-Heap outstanding allocations: " SIZE_FORMAT "K%s",
-                 total_allocated / K,
+  glibc_mallinfo2 mi;
+  mallinfo_retval_t mirc = os::Linux::get_mallinfo(&mi);
+  if (mirc != os::Linux::error) {
+    size_t total_allocated = mi.uordblks + mi.hblkhd;
+    size_t free_retained = mi.fordblks;
+#ifdef _LP64
+    // If all we had is old mallinf(3), the values may have wrapped. Since that can confuse readers
+    // of this output, print a hint.
+    // We do this by checking virtual size of the process: if that is <4g, we could not have wrapped.
+    might_have_wrapped = (mirc == os::Linux::ok_but_possibly_wrapped) &&
+                         ((info.vmsize * K) > UINT_MAX);
+#endif
+    st->print_cr("C-Heap outstanding allocations: " SIZE_FORMAT "K, retained: " SIZE_FORMAT "K%s",
+                 total_allocated / K, free_retained / K,
                  might_have_wrapped ? " (may have wrapped)" : "");
   }

@@ -5187,8 +5205,8 @@ void os::init(void) {
   Linux::initialize_system_info();

#ifdef __GLIBC__
-  Linux::_mallinfo = CAST_TO_FN_PTR(Linux::mallinfo_func_t, dlsym(RTLD_DEFAULT, "mallinfo"));
-  Linux::_mallinfo2 = CAST_TO_FN_PTR(Linux::mallinfo2_func_t, dlsym(RTLD_DEFAULT, "mallinfo2"));
+  g_mallinfo = CAST_TO_FN_PTR(mallinfo_func_t, dlsym(RTLD_DEFAULT, "mallinfo"));
+  g_mallinfo2 = CAST_TO_FN_PTR(mallinfo2_func_t, dlsym(RTLD_DEFAULT, "mallinfo2"));
 #endif // __GLIBC__

// _main_thread points to the thread that created/loaded the JVM.
@@ -6820,3 +6838,94 @@ void TestReserveMemorySpecial_test() {
 }

#endif
+
+#ifdef __GLIBC__
+os::Linux::mallinfo_retval_t os::Linux::get_mallinfo(glibc_mallinfo2* out) {
+  if (g_mallinfo2) {
+    glibc_mallinfo2 mi = g_mallinfo2();
+    *out = mi;
+    return os::Linux::ok;
+  } else if (g_mallinfo) {
+    // mallinfo() returns 32-bit values. Not perfect but still useful if
+    // process virt size < 4g
+    glibc_mallinfo mi = g_mallinfo();
+    out->arena = (int) mi.arena;
+    out->ordblks = (int) mi.ordblks;
+    out->smblks = (int) mi.smblks;
+    out->hblks = (int) mi.hblks;
+    out->hblkhd = (int) mi.hblkhd;
+    out->usmblks = (int) mi.usmblks;
+    out->fsmblks = (int) mi.fsmblks;
+    out->uordblks = (int) mi.uordblks;
+    out->fordblks = (int) mi.fordblks;
+    out->keepcost = (int) mi.keepcost;
+    return os::Linux::ok_but_possibly_wrapped;
+  }
+  return os::Linux::ok;
+}
+#endif // __GLIBC__
+
+// Trim-native support
+bool os::can_trim_native_heap() {
+#ifdef __GLIBC__
+  return true;
+#else
+  return false; // musl
+#endif
+}
+
+static const size_t retain_size = 2 * M;
+
+bool os::should_trim_native_heap() {
+#ifdef __GLIBC__
+  bool rc = true;
+  // We try, using mallinfo, to predict whether a malloc_trim(3) will be beneficial.
+  //
+  // "mallinfo::keepcost" is no help even if manpage claims this to be the projected
+  // trim size. In practice it is just a very small value with no relation to the actual
+  // effect trimming will have.
+  //
+  // Our best bet is "mallinfo::fordblks", the total chunk size of free blocks. Since
+  // only free blocks can be trimmed, a very low bar is to require their combined size
+  // to be higher than our retain size. Note, however, that "mallinfo::fordblks" includes
+  // already-trimmed blocks, since glibc trims by calling madvice(MADV_DONT_NEED) on free
+  // chunks but does not update its bookkeeping.
+  //
+  // In the end we want to prevent obvious bogus attempts to trim, and for that fordblks
+  // is good enough.
+  os::Linux::glibc_mallinfo2 mi;
+  os::Linux::mallinfo_retval_t mirc = os::Linux::get_mallinfo(&mi);
+  const size_t total_free = mi.fordblks;
+  if (mirc == os::Linux::ok) {
+    rc = retain_size < total_free;
+  }
+  return rc;
+#else
+  return false; // musl
+#endif
+}
+
+bool os::trim_native_heap(os::size_change_t* rss_change) {
+#ifdef __GLIBC__
+  os::Linux::meminfo_t info1;
+  os::Linux::meminfo_t info2;
+
+  bool have_info1 = os::Linux::query_process_memory_info(&info1);
+  ::malloc_trim(retain_size);
+  bool have_info2 = have_info1 && os::Linux::query_process_memory_info(&info2);
+
+  if (have_info1 && have_info2 &&
+    info1.vmrss != -1 && info2.vmrss != -1 &&
+    info1.vmswap != -1 && info2.vmswap != -1) {
+    // Note: query_process_memory_info returns values in K
+    rss_change->before = (info1.vmrss + info1.vmswap) * K;
+    rss_change->after = (info2.vmrss + info2.vmswap) * K;
+  } else {
+    rss_change->after = rss_change->before = SIZE_MAX;
+  }
+
+  return true;
+#else
+  return false; // musl
+#endif
+}
\ No newline at end of file
diff --git a/hotspot/src/os/linux/vm/os_linux.hpp b/hotspot/src/os/linux/vm/os_linux.hpp
index 2bb3fd2..6c27bcb 100644
--- a/hotspot/src/os/linux/vm/os_linux.hpp
+++ b/hotspot/src/os/linux/vm/os_linux.hpp
@@ -243,7 +243,7 @@ class Linux {
   public:
   static pthread_condattr_t* condAttr() { return _condattr; }

-  // Output structure for query_process_memory_info()
+  // Output structure for query_process_memory_info() (all values in KB)
   struct meminfo_t {
     ssize_t vmsize;     // current virtual size
     ssize_t vmpeak;     // peak virtual size
@@ -338,40 +338,6 @@ private:
   };
   static NumaAllocationPolicy _current_numa_policy;

-#ifdef __GLIBC__
-  struct glibc_mallinfo {
-    int arena;
-    int ordblks;
-    int smblks;
-    int hblks;
-    int hblkhd;
-    int usmblks;
-    int fsmblks;
-    int uordblks;
-    int fordblks;
-    int keepcost;
-  };
-
-  struct glibc_mallinfo2 {
-    size_t arena;
-    size_t ordblks;
-    size_t smblks;
-    size_t hblks;
-    size_t hblkhd;
-    size_t usmblks;
-    size_t fsmblks;
-    size_t uordblks;
-    size_t fordblks;
-    size_t keepcost;
-  };
-
-  typedef struct glibc_mallinfo (*mallinfo_func_t)(void);
-  typedef struct glibc_mallinfo2 (*mallinfo2_func_t)(void);
-
-  static mallinfo_func_t _mallinfo;
-  static mallinfo2_func_t _mallinfo2;
-#endif
-
 public:
   static int sched_getcpu()  { return _sched_getcpu != NULL ? _sched_getcpu() : -1; }
   static int numa_node_to_cpus(int node, unsigned long *buffer, int bufferlen) {
@@ -484,6 +450,27 @@ public:
       return false;
     }
   }
+
+#ifdef __GLIBC__
+  struct glibc_mallinfo2 {
+    size_t arena;
+    size_t ordblks;
+    size_t smblks;
+    size_t hblks;
+    size_t hblkhd;
+    size_t usmblks;
+    size_t fsmblks;
+    size_t uordblks;
+    size_t fordblks;
+    size_t keepcost;
+  };
+  enum mallinfo_retval_t { ok, error, ok_but_possibly_wrapped };
+  // get_mallinfo() is a wrapper for mallinfo/mallinfo2. It will prefer mallinfo2() if found.
+  // If we only have mallinfo(), values may be 32-bit truncated, which is signaled via
+  // "ok_but_possibly_wrapped".
+  static mallinfo_retval_t get_mallinfo(glibc_mallinfo2* out);
+#endif
+
 };

diff --git a/hotspot/src/os/linux/vm/trimCHeapDCmd.cpp b/hotspot/src/os/linux/vm/trimCHeapDCmd.cpp
index 95d03d9..39d47a3 100644
--- a/hotspot/src/os/linux/vm/trimCHeapDCmd.cpp
+++ b/hotspot/src/os/linux/vm/trimCHeapDCmd.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 SAP SE. All rights reserved.
+ * Copyright (c) 2022 SAP SE. All rights reserved.
  * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
@@ -25,53 +25,28 @@

#include "precompiled.hpp"
 #include "runtime/os.hpp"
+#include "trimCHeapDCmd.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/ostream.hpp"
-#include "trimCHeapDCmd.hpp"
+#include "utilities/globalDefinitions.hpp"

#include <malloc.h>

void TrimCLibcHeapDCmd::execute(DCmdSource source, TRAPS) {
-#ifdef __GLIBC__
-  stringStream ss_report(1024); // Note: before calling trim
-
-  os::Linux::meminfo_t info1;
-  os::Linux::meminfo_t info2;
-  // Query memory before...
-  bool have_info1 = os::Linux::query_process_memory_info(&info1);
-
-  _output->print_cr("Attempting trim...");
-  ::malloc_trim(0);
-  _output->print_cr("Done.");
-
-  // ...and after trim.
-  bool have_info2 = os::Linux::query_process_memory_info(&info2);
-
-  // Print report both to output stream as well to UL
-  bool wrote_something = false;
-  if (have_info1 && have_info2) {
-    if (info1.vmsize != -1 && info2.vmsize != -1) {
-      ss_report.print_cr("Virtual size before: " SSIZE_FORMAT "k, after: " SSIZE_FORMAT "k, (" SSIZE_FORMAT "k)",
-                         info1.vmsize, info2.vmsize, (info2.vmsize - info1.vmsize));
-      wrote_something = true;
-    }
-    if (info1.vmrss != -1 && info2.vmrss != -1) {
-      ss_report.print_cr("RSS before: " SSIZE_FORMAT "k, after: " SSIZE_FORMAT "k, (" SSIZE_FORMAT "k)",
-                         info1.vmrss, info2.vmrss, (info2.vmrss - info1.vmrss));
-      wrote_something = true;
-    }
-    if (info1.vmswap != -1 && info2.vmswap != -1) {
-      ss_report.print_cr("Swap before: " SSIZE_FORMAT "k, after: " SSIZE_FORMAT "k, (" SSIZE_FORMAT "k)",
-                         info1.vmswap, info2.vmswap, (info2.vmswap - info1.vmswap));
-      wrote_something = true;
+  if (os::can_trim_native_heap()) {
+    os::size_change_t sc;
+    if (os::trim_native_heap(&sc)) {
+      _output->print("Trim native heap: ");
+      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 ? '-' : '+';
+        _output->print_cr("RSS+Swap: " PROPERFMT "->" PROPERFMT " (%c" PROPERFMT ")",
+                          PROPERFMTARGS(sc.before), PROPERFMTARGS(sc.after), sign, PROPERFMTARGS(delta));
+      } else {
+        _output->print_cr("(no details available).");
+      }
     }
+  } else {
+    _output->print_cr("Not available.");
   }
-  if (!wrote_something) {
-    ss_report.print_raw("No details available.");
-  }
-
-  _output->print_raw(ss_report.base());
-#else
-  _output->print_cr("Not available.");
-#endif
 }
diff --git a/hotspot/src/os/windows/vm/os_windows.cpp b/hotspot/src/os/windows/vm/os_windows.cpp
index 500a412..25122de 100644
--- a/hotspot/src/os/windows/vm/os_windows.cpp
+++ b/hotspot/src/os/windows/vm/os_windows.cpp
@@ -5957,3 +5957,7 @@ void TestReserveMemorySpecial_test() {
 }
 #endif // PRODUCT

+// stubbed-out trim-native support
+bool os::can_trim_native_heap() { return false; }
+bool os::should_trim_native_heap() { return false; }
+bool os::trim_native_heap(os::size_change_t* rss_change) { return false; }
\ No newline at end of file
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
index ba156a2..7188925 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
@@ -53,6 +53,7 @@
 #include "gc_implementation/shared/gcTimer.hpp"
 #include "gc_implementation/shared/gcTrace.hpp"
 #include "gc_implementation/shared/gcTraceTime.hpp"
+#include "gc_implementation/shared/gcTrimNativeHeap.hpp"
 #include "gc_implementation/shared/isGCActiveMark.hpp"
 #include "memory/allocation.hpp"
 #include "memory/heapInspection.hpp"
@@ -1304,6 +1305,9 @@ bool G1CollectedHeap::do_collection(bool explicit_gc,
       TraceCollectorStats tcs(g1mm()->full_collection_counters());
       TraceMemoryManagerStats tms(true /* fullGC */, gc_cause());

+      // Pause native trimming for the duration of the GC
+      GCTrimNative::pause_periodic_trim();
+
       double start = os::elapsedTime();
       g1_policy()->record_full_collection_start();

@@ -1546,6 +1550,8 @@ bool G1CollectedHeap::do_collection(bool explicit_gc,

gc_timer->register_gc_end();
     gc_tracer->report_gc_end(gc_timer->gc_end(), gc_timer->time_partitions());
+
+    GCTrimNative::schedule_trim();
   }
   return true;
 }
diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp
index 74c1584..1c47125 100644
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp
@@ -36,6 +36,7 @@
 #include "gc_implementation/parallelScavenge/psScavenge.hpp"
 #include "gc_implementation/parallelScavenge/vmPSOperations.hpp"
 #include "gc_implementation/shared/gcHeapSummary.hpp"
+#include "gc_implementation/shared/gcTrimNativeHeap.hpp"
 #include "gc_implementation/shared/gcWhen.hpp"
 #include "memory/gcLocker.inline.hpp"
 #include "oops/oop.inline.hpp"
@@ -147,6 +148,8 @@ void ParallelScavengeHeap::post_initialize() {
     PSMarkSweep::initialize();
   }
   PSPromotionManager::initialize();
+
+  GCTrimNative::initialize(true);
 }

void ParallelScavengeHeap::update_counters() {
diff --git a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
index 3f103ee..26d64a1 100644
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
@@ -42,6 +42,7 @@
 #include "gc_implementation/shared/gcTimer.hpp"
 #include "gc_implementation/shared/gcTrace.hpp"
 #include "gc_implementation/shared/gcTraceTime.hpp"
+#include "gc_implementation/shared/gcTrimNativeHeap.hpp"
 #include "gc_implementation/shared/isGCActiveMark.hpp"
 #include "gc_interface/gcCause.hpp"
 #include "memory/gcLocker.inline.hpp"
@@ -2008,6 +2009,9 @@ bool PSParallelCompact::invoke_no_policy(bool maximum_heap_compaction) {
     return false;
   }

+  // Pause native trimming for the duration of the GC
+  GCTrimNative::pause_periodic_trim();
+
   ParallelScavengeHeap* heap = gc_heap();

_gc_timer.register_gc_start();
@@ -2182,6 +2186,8 @@ bool PSParallelCompact::invoke_no_policy(bool maximum_heap_compaction) {
     // Resize the metaspace capactiy after a collection
     MetaspaceGC::compute_new_size();

+    GCTrimNative::schedule_trim();
+
     if (TraceGen1Time) accumulated_time()->stop();

if (PrintGC) {
diff --git a/hotspot/src/share/vm/gc_implementation/shared/concurrentGCThread.cpp b/hotspot/src/share/vm/gc_implementation/shared/concurrentGCThread.cpp
index e39fd7a..024499a 100644
--- a/hotspot/src/share/vm/gc_implementation/shared/concurrentGCThread.cpp
+++ b/hotspot/src/share/vm/gc_implementation/shared/concurrentGCThread.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -40,12 +40,12 @@ ConcurrentGCThread::ConcurrentGCThread() :
   _should_terminate(false), _has_terminated(false) {
 };

-void ConcurrentGCThread::create_and_start() {
+void ConcurrentGCThread::create_and_start(ThreadPriority prio) {
   if (os::create_thread(this, os::cgc_thread)) {
     // XXX: need to set this to low priority
     // unless "agressive mode" set; priority
     // should be just less than that of VMThread.
-    os::set_priority(this, NearMaxPriority);
+    os::set_priority(this, prio);
     if (!_should_terminate && !DisableStartThread) {
       os::start_thread(this);
     }
@@ -63,7 +63,7 @@ void ConcurrentGCThread::initialize_in_thread() {
 void ConcurrentGCThread::wait_for_universe_init() {
   MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag);
   while (!is_init_completed() && !_should_terminate) {
-    CGC_lock->wait(Mutex::_no_safepoint_check_flag, 200);
+    CGC_lock->wait(Mutex::_no_safepoint_check_flag, 1);
   }
 }

diff --git a/hotspot/src/share/vm/gc_implementation/shared/concurrentGCThread.hpp b/hotspot/src/share/vm/gc_implementation/shared/concurrentGCThread.hpp
index e87228b..1e16bf7 100644
--- a/hotspot/src/share/vm/gc_implementation/shared/concurrentGCThread.hpp
+++ b/hotspot/src/share/vm/gc_implementation/shared/concurrentGCThread.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -33,7 +33,7 @@ class ConcurrentGCThread: public NamedThread {
   friend class VMStructs;

protected:
-  bool _should_terminate;
+  bool volatile _should_terminate;
   bool _has_terminated;

enum CGC_flag_type {
@@ -50,7 +50,7 @@ protected:
   static int reset_CGC_flag(int b)         { return _CGC_flag &= ~b; }

// Create and start the thread (setting it's priority high.)
-  void create_and_start();
+  void create_and_start(ThreadPriority prio = NearMaxPriority);

// Do initialization steps in the thread: record stack base and size,
   // init thread local storage, set JNI handle block.
diff --git a/hotspot/src/share/vm/gc_implementation/shared/gcTrimNativeHeap.cpp b/hotspot/src/share/vm/gc_implementation/shared/gcTrimNativeHeap.cpp
new file mode 100644
index 0000000..b9bac56
--- /dev/null
+++ b/hotspot/src/share/vm/gc_implementation/shared/gcTrimNativeHeap.cpp
@@ -0,0 +1,246 @@
+/*
+ * Copyright (c) 2022 SAP SE. All rights reserved.
+ * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, Huawei Technologies Co., Ltd. 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
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "gc_implementation/shared/concurrentGCThread.hpp"
+#include "gc_implementation/shared/gcTrimNativeHeap.hpp"
+#include "gc_implementation/g1/g1_globals.hpp"
+#include "runtime/globals.hpp"
+#include "runtime/globals_extension.hpp"
+#include "runtime/mutex.hpp"
+#include "runtime/mutexLocker.hpp"
+#include "runtime/os.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+#include "utilities/ostream.hpp"
+#include "utilities/ticks.hpp"
+
+bool GCTrimNative::_async_mode = false;
+double GCTrimNative::_next_trim_not_before = 0;
+
+// GCTrimNative works in two modes:
+//
+// - async mode, where GCTrimNative runs a trimmer thread on behalf of the GC.
+//   The trimmer thread will be doing all the trims, both periodically and
+//   triggered from outside via GCTrimNative::schedule_trim().
+//
+// - synchronous mode, where the GC does the trimming itself in its own thread,
+//   via GCTrimNative::should_trim() and GCTrimNative::execute_trim().
+//
+// The mode is set as argument to GCTrimNative::initialize().
+
+class NativeTrimmer : public ConcurrentGCThread {
+
+  Monitor* _lock;
+  volatile jlong _paused;
+  static NativeTrimmer* _the_trimmer;
+
+public:
+
+  virtual void run() {
+    initialize_in_thread();
+    wait_for_universe_init();
+
+    assert(GCTrimNativeHeap, "Sanity");
+    assert(os::can_trim_native_heap(), "Sanity");
+
+    gclog_or_tty->print_cr("NativeTrimmer started.");
+
+    // Note: GCTrimNativeHeapInterval=0 -> zero wait time -> indefinite waits, disabling periodic trim
+    const int64_t delay_ms = GCTrimNativeHeapInterval * 1000;
+    for (;;) {
+      MonitorLockerEx ml(_lock, Mutex::_no_safepoint_check_flag);
+      ml.wait(Mutex::_no_safepoint_check_flag, delay_ms);
+      if (_should_terminate) {
+        gclog_or_tty->print_cr("NativeTrimmer stopped.");
+        break;
+      }
+      jlong paused = Atomic::load(&_paused);
+      if (!paused && os::should_trim_native_heap()) {
+        GCTrimNative::do_trim();
+      }
+    }
+
+    terminate();
+  }
+
+  void stop() {
+    {
+      MutexLockerEx ml(Terminator_lock);
+      _should_terminate = true;
+    }
+
+    wakeup();
+
+    {
+      MutexLockerEx ml(Terminator_lock);
+      while (!_has_terminated) {
+        Terminator_lock->wait();
+      }
+    }
+  }
+
+protected:
+
+  void wakeup() {
+    MonitorLockerEx ml(_lock, Mutex::_no_safepoint_check_flag);
+    ml.notify_all();
+  }
+
+  void pause() {
+    Atomic::store(1, &_paused);
+    debug_only(gclog_or_tty->print_cr("NativeTrimmer paused"));
+  }
+
+  void unpause() {
+    Atomic::store(0, &_paused);
+    debug_only(gclog_or_tty->print_cr("NativeTrimmer unpaused"));
+  }
+
+public:
+
+  NativeTrimmer() :
+    _paused(0)
+  {
+    //Mutex::leaf+8 just for NativeTrimmer_lock
+    _lock = new (std::nothrow) Monitor(Mutex::leaf+8, "NativeTrimmer_lock", true);
+    set_name("NativeTrimmer Thread");
+  }
+
+  static bool is_enabled() {
+    return _the_trimmer != NULL;
+  }
+
+  static void start_trimmer() {
+    _the_trimmer = new NativeTrimmer();
+    _the_trimmer->create_and_start(NormPriority);
+  }
+
+  static void stop_trimmer() {
+    _the_trimmer->stop();
+  }
+
+  static void pause_periodic_trim() {
+    _the_trimmer->pause();
+  }
+
+  static void unpause_periodic_trim() {
+    _the_trimmer->unpause();
+  }
+
+  static void schedule_trim_now() {
+    _the_trimmer->unpause();
+    _the_trimmer->wakeup();
+  }
+
+}; // NativeTrimmer
+
+NativeTrimmer* NativeTrimmer::_the_trimmer = NULL;
+
+void GCTrimNative::do_trim() {
+  Ticks start = Ticks::now();
+  os::size_change_t sc;
+  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 ? '-' : '+';
+      gclog_or_tty->print_cr("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 {
+      gclog_or_tty->print_cr("Trim native heap (no details)");
+    }
+  }
+}
+
+/// GCTrimNative outside facing methods
+
+void GCTrimNative::initialize(bool async_mode) {
+
+  if (GCTrimNativeHeap) {
+
+    if (!os::can_trim_native_heap()) {
+      FLAG_SET_ERGO(bool, GCTrimNativeHeap, false);
+      gclog_or_tty->print_cr("GCTrimNativeHeap disabled - trim-native not supported on this platform.");
+      return;
+    }
+
+    debug_only(gclog_or_tty->print_cr("GCTrimNativeHeap enabled."));
+
+    _async_mode = async_mode;
+
+    // If we are to run the trimmer on behalf of the GC:
+    if (_async_mode) {
+      NativeTrimmer::start_trimmer();
+    }
+
+    _next_trim_not_before = GCTrimNativeHeapInterval;
+  }
+}
+
+void GCTrimNative::cleanup() {
+  if (GCTrimNativeHeap) {
+    if (_async_mode) {
+      NativeTrimmer::stop_trimmer();
+    }
+  }
+}
+
+bool GCTrimNative::should_trim(bool ignore_delay) {
+  return
+      GCTrimNativeHeap && os::can_trim_native_heap() &&
+      (ignore_delay || (GCTrimNativeHeapInterval > 0 && os::elapsedTime() > _next_trim_not_before)) &&
+      os::should_trim_native_heap();
+}
+
+void GCTrimNative::execute_trim() {
+  if (GCTrimNativeHeap) {
+    assert(!_async_mode, "Only call for non-async mode");
+    do_trim();
+    _next_trim_not_before = os::elapsedTime() + GCTrimNativeHeapInterval;
+  }
+}
+
+void GCTrimNative::pause_periodic_trim() {
+  if (GCTrimNativeHeap) {
+    assert(_async_mode, "Only call for async mode");
+    NativeTrimmer::pause_periodic_trim();
+  }
+}
+
+void GCTrimNative::unpause_periodic_trim() {
+  if (GCTrimNativeHeap) {
+    assert(_async_mode, "Only call for async mode");
+    NativeTrimmer::unpause_periodic_trim();
+  }
+}
+
+void GCTrimNative::schedule_trim() {
+  if (GCTrimNativeHeap) {
+    assert(_async_mode, "Only call for async mode");
+    NativeTrimmer::schedule_trim_now();
+  }
+}
diff --git a/hotspot/src/share/vm/gc_implementation/shared/gcTrimNativeHeap.hpp b/hotspot/src/share/vm/gc_implementation/shared/gcTrimNativeHeap.hpp
new file mode 100644
index 0000000..f586093
--- /dev/null
+++ b/hotspot/src/share/vm/gc_implementation/shared/gcTrimNativeHeap.hpp
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2022 SAP SE. All rights reserved.
+ * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, Huawei Technologies Co., Ltd. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * 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
+ * questions.
+ *
+ */
+
+#ifndef SHARE_GC_SHARED_GCTRIMNATIVEHEAP_HPP
+#define SHARE_GC_SHARED_GCTRIMNATIVEHEAP_HPP
+
+#include "memory/allocation.hpp"
+
+class NativeTrimmer;
+
+class GCTrimNative : public AllStatic {
+  friend class NativeTrimmer;
+
+  static bool _async_mode;
+  static double _next_trim_not_before;
+
+  static void do_trim();
+
+public:
+
+  static void initialize(bool async_mode);
+  static void cleanup();
+
+  // Returns true if:
+  // - trimming is enabled and possible
+  // - trimming may have an actual effect (guess)
+  // - delay timer has expired (unless ignore_delay is true)
+  static bool should_trim(bool ignore_delay);
+
+  // Execute trim-native in this thread
+  static void execute_trim();
+
+  // Pause/unpause periodic trim
+  static void pause_periodic_trim();
+  static void unpause_periodic_trim();
+
+  // Schedule an explicit trim now; if periodic trims had been
+  // paused, they are unpaused.
+  static void schedule_trim();
+
+};
+
+#endif // SHARE_GC_SHARED_GCTRIMNATIVEHEAP_HPP
diff --git a/hotspot/src/share/vm/memory/genCollectedHeap.cpp b/hotspot/src/share/vm/memory/genCollectedHeap.cpp
index 20fbbfd..7df3d68 100644
--- a/hotspot/src/share/vm/memory/genCollectedHeap.cpp
+++ b/hotspot/src/share/vm/memory/genCollectedHeap.cpp
@@ -58,6 +58,7 @@
 #if INCLUDE_ALL_GCS
 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
 #include "gc_implementation/concurrentMarkSweep/vmCMSOperations.hpp"
+#include "gc_implementation/shared/gcTrimNativeHeap.hpp"
 #endif // INCLUDE_ALL_GCS
 #if INCLUDE_JFR
 #include "jfr/jfr.hpp"
@@ -572,6 +573,11 @@ void GenCollectedHeap::do_collection(bool  full,
       update_full_collections_completed();
     }

+    // Trim the native heap, without a delay since this is a full gc
+    if (full && GCTrimNative::should_trim(true)) {
+      GCTrimNative::execute_trim();
+    }
+
     // Track memory usage and detect low memory after GC finishes
     MemoryService::track_memory_usage();

diff --git a/hotspot/src/share/vm/memory/sharedHeap.cpp b/hotspot/src/share/vm/memory/sharedHeap.cpp
index ef22f01..8c02320 100644
--- a/hotspot/src/share/vm/memory/sharedHeap.cpp
+++ b/hotspot/src/share/vm/memory/sharedHeap.cpp
@@ -26,6 +26,7 @@
 #include "classfile/symbolTable.hpp"
 #include "classfile/systemDictionary.hpp"
 #include "code/codeCache.hpp"
+#include "gc_implementation/shared/gcTrimNativeHeap.hpp"
 #include "gc_interface/collectedHeap.inline.hpp"
 #include "memory/sharedHeap.hpp"
 #include "oops/oop.inline.hpp"
@@ -104,6 +105,11 @@ void SharedHeap::set_barrier_set(BarrierSet* bs) {
 void SharedHeap::post_initialize() {
   CollectedHeap::post_initialize();
   ref_processing_init();
+  if (!UseSerialGC) {
+      GCTrimNative::initialize(true);
+  } else {
+      GCTrimNative::initialize(false); // false since we will call trim inside the collecting thread
+  }
 }

void SharedHeap::ref_processing_init() {}
diff --git a/hotspot/src/share/vm/runtime/globals.hpp b/hotspot/src/share/vm/runtime/globals.hpp
index 0dab18e..ec48c48 100644
--- a/hotspot/src/share/vm/runtime/globals.hpp
+++ b/hotspot/src/share/vm/runtime/globals.hpp
@@ -3387,6 +3387,16 @@ class CommandLineFlags {
           "Number of entries we will try to leave on the stack "            \
           "during parallel gc")                                             \
                                                                             \
+  experimental(bool, GCTrimNativeHeap, false,                               \
+          "GC will attempt to trim the native heap periodically and at "    \
+          "full GCs.")                                                      \
+                                                                            \
+  experimental(uintx, GCTrimNativeHeapInterval, 60,                          \
+          "If GCTrimNativeHeap is enabled: interval time, in seconds, in "  \
+          "which the VM will attempt to trim the native heap. A value of "  \
+          "0 disables periodic trimming while leaving trimming at full gc " \
+          "enabled.")                                                       \
+                                                                            \
   /* stack parameters */                                                    \
   product_pd(intx, StackYellowPages,                                        \
           "Number of yellow zone (recoverable overflows) pages")            \
diff --git a/hotspot/src/share/vm/runtime/init.cpp b/hotspot/src/share/vm/runtime/init.cpp
index d15e40d..d2e0f22 100644
--- a/hotspot/src/share/vm/runtime/init.cpp
+++ b/hotspot/src/share/vm/runtime/init.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -166,8 +166,7 @@ void exit_globals() {
   }
 }

-
-static bool _init_completed = false;
+static volatile bool _init_completed = false;

bool is_init_completed() {
   return _init_completed;
diff --git a/hotspot/src/share/vm/runtime/java.cpp b/hotspot/src/share/vm/runtime/java.cpp
index 4f290c8..54b980d 100644
--- a/hotspot/src/share/vm/runtime/java.cpp
+++ b/hotspot/src/share/vm/runtime/java.cpp
@@ -30,6 +30,7 @@
 #include "code/codeCache.hpp"
 #include "compiler/compileBroker.hpp"
 #include "compiler/compilerOracle.hpp"
+#include "gc_implementation/shared/gcTrimNativeHeap.hpp"
 #include "interpreter/bytecodeHistogram.hpp"
 #include "jfr/jfrEvents.hpp"
 #include "jfr/support/jfrThreadId.hpp"
@@ -509,6 +510,8 @@ void before_exit(JavaThread * thread) {
   StatSampler::disengage();
   StatSampler::destroy();

+  GCTrimNative::cleanup();
+
   // Stop concurrent GC threads
   Universe::heap()->stop();

diff --git a/hotspot/src/share/vm/runtime/os.hpp b/hotspot/src/share/vm/runtime/os.hpp
index 7ae49fd..acc57f4 100644
--- a/hotspot/src/share/vm/runtime/os.hpp
+++ b/hotspot/src/share/vm/runtime/os.hpp
@@ -333,6 +333,17 @@ class os: AllStatic {
   static bool   uncommit_memory(char* addr, size_t bytes);
   static bool   release_memory(char* addr, size_t bytes);

+  // Does the platform support trimming the native heap?
+  static bool can_trim_native_heap();
+
+  // Does the platform recommend trimming?
+  static bool should_trim_native_heap();
+
+  // Trim the C-heap. Returns RSS size change and optionally return the rss size change.
+  // If trim was done but size change could not be obtained, SIZE_MAX is returned for after size.
+  struct size_change_t { size_t before; size_t after; };
+  static bool trim_native_heap(size_change_t* rss_change);
+
   // Touch memory pages that cover the memory range from start to end (exclusive)
   // to make the OS back the memory range with actual memory.
   // Current implementation may not touch the last page if unaligned addresses
diff --git a/hotspot/src/share/vm/utilities/globalDefinitions.hpp b/hotspot/src/share/vm/utilities/globalDefinitions.hpp
index 25f6f02..12eea20 100644
--- a/hotspot/src/share/vm/utilities/globalDefinitions.hpp
+++ b/hotspot/src/share/vm/utilities/globalDefinitions.hpp
@@ -260,6 +260,9 @@ inline T byte_size_in_proper_unit(T s) {
   }
 }

+#define PROPERFMT             SIZE_FORMAT "%s"
+#define PROPERFMTARGS(S)      byte_size_in_proper_unit(S), proper_unit_for_byte_size(S)
+
 //----------------------------------------------------------------------------------------------------
 // VM type definitions

diff --git a/hotspot/test/gc/TestTrimNative.java b/hotspot/test/gc/TestTrimNative.java
new file mode 100644
index 0000000..58d5405
--- /dev/null
+++ b/hotspot/test/gc/TestTrimNative.java
@@ -0,0 +1,435 @@
+/*
+ * Copyright (c) 2022 SAP SE. All rights reserved.
+ * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, Huawei Technologies Co., Ltd. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * 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
+ * questions.
+ *
+ */
+
+package gc;
+
+/*
+ * All these tests test the trim-native feature for all GCs.
+ * Trim-native is the ability to trim the C-heap as part of the GC cycle.
+ * This feature is controlled by -XX:+GCTrimNativeHeap (by default off).
+ * Trimming happens on full gc for all gcs. Shenandoah and G1 also support
+ * concurrent trimming (Shenandoah supports this without any ties to java
+ * heap occupancy).
+ *
+ */
+
+//// full gc tests /////
+
+/*
+ * @test id=fullgc-serial
+ * @summary Test that GCTrimNativeHeap works with Serial
+ * @requires vm.gc=="Serial"
+ * @requires os.family=="linux"
+ * @modules java.base/jdk.internal.misc
+ * @library /testlibrary
+ * @run driver gc.TestTrimNative test-fullgc serial
+ */
+
+/*
+ * @test id=fullgc-parallel
+ * @summary Test that GCTrimNativeHeap works with Parallel
+ * @requires vm.gc=="Parallel"
+ * @requires os.family=="linux"
+ * @modules java.base/jdk.internal.misc
+ * @library /testlibrary
+ * @run driver gc.TestTrimNative test-fullgc parallel
+ */
+
+/*
+ * @test id=fullgc-g1
+ * @summary Test that GCTrimNativeHeap works with G1
+ * @requires vm.gc=="G1"
+ * @requires os.family=="linux"
+ * @modules java.base/jdk.internal.misc
+ * @library /testlibrary
+ * @run driver gc.TestTrimNative test-fullgc g1
+ */
+
+//// auto mode tests /////
+
+// Note: not serial, since it does not do periodic trimming, only trimming on full gc
+
+/*
+ * @test id=auto-parallel
+ * @summary Test that GCTrimNativeHeap works with Parallel
+ * @requires vm.gc=="Parallel"
+ * @requires os.family=="linux"
+ * @modules java.base/jdk.internal.misc
+ * @library /testlibrary
+ * @run driver gc.TestTrimNative test-auto parallel
+ */
+
+/*
+ * @test id=auto-g1
+ * @summary Test that GCTrimNativeHeap works with G1
+ * @requires vm.gc=="G1"
+ * @requires os.family=="linux"
+ * @modules java.base/jdk.internal.misc
+ * @library /testlibrary
+ * @run driver gc.TestTrimNative test-auto g1
+ */
+
+
+//// test-auto-high-interval interval test /////
+
+// Note: not serial, since it does not do periodic trimming, only trimming on full gc
+
+/*
+ * @test id=auto-high-interval-parallel
+ * @summary Test that a high GCTrimNativeHeapInterval effectively disables automatic trimming
+ * @requires vm.gc=="Parallel"
+ * @requires os.family=="linux"
+ * @modules java.base/jdk.internal.misc
+ * @library /testlibrary
+ * @run driver gc.TestTrimNative test-auto-high-interval parallel
+ */
+
+/*
+ * @test id=auto-high-interval-g1
+ * @summary Test that a high GCTrimNativeHeapInterval effectively disables automatic trimming
+ * @requires vm.gc=="G1"
+ * @requires os.family=="linux"
+ * @modules java.base/jdk.internal.misc
+ * @library /testlibrary
+ * @run driver gc.TestTrimNative test-auto-high-interval g1
+ */
+
+//// test-auto-interval-0 test /////
+
+// Note: not serial, since it does not do periodic trimming, only trimming on full gc
+
+/*
+ * @test id=auto-zero-interval-parallel
+ * @summary Test that a GCTrimNativeHeapInterval=0 disables periodic trimming
+ * @requires vm.gc=="Parallel"
+ * @requires os.family=="linux"
+ * @modules java.base/jdk.internal.misc
+ * @library /testlibrary
+ * @run driver gc.TestTrimNative test-auto-zero-interval parallel
+ */
+
+/*
+ * @test id=auto-zero-interval-g1
+ * @summary Test that a GCTrimNativeHeapInterval=0 disables periodic trimming
+ * @requires vm.gc=="G1"
+ * @requires os.family=="linux"
+ * @modules java.base/jdk.internal.misc
+ * @library /testlibrary
+ * @run driver gc.TestTrimNative test-auto-zero-interval g1
+ */
+
+// Other tests
+
+/*
+ * @test id=off-explicit
+ * @summary Test that -GCTrimNative disables the feature
+ * @requires os.family=="linux"
+ * @modules java.base/jdk.internal.misc
+ * @library /testlibrary
+ * @run driver gc.TestTrimNative test-off-explicit
+ */
+
+/*
+ * @test id=off-by-default
+ * @summary Test that GCTrimNative is off by default
+ * @requires os.family=="linux"
+ * @modules java.base/jdk.internal.misc
+ * @library /testlibrary
+ * @run driver gc.TestTrimNative test-off-by-default
+ */
+
+/*
+ * @test id=off-on-other-platforms
+ * @summary Test that GCTrimNative is off on unsupportive platforms
+ * @requires os.family!="linux"
+ * @modules java.base/jdk.internal.misc
+ * @library /testlibrary
+ * @run driver gc.TestTrimNative test-off-on-other-platforms
+ */
+
+import sun.misc.Unsafe;
+import com.oracle.java.testlibrary.*;
+
+import java.lang.reflect.Field;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class TestTrimNative {
+
+    // Actual RSS increase is a lot larger than 4 MB. Depends on glibc overhead, and NMT malloc headers in debug VMs.
+    // We need small-grained allocations to make sure they actually increase RSS (all touched) and to see the
+    // glibc-retaining-memory effect.
+    static final int szAllocations = 16;
+    static final int totalAllocationsSize = 16 * 1024 * 1024; // 16 MB total
+    static final int numAllocations = totalAllocationsSize / szAllocations;
+
+    static long[] ptrs = new long[numAllocations];
+
+    enum Unit {
+        B(1), K(1024), M(1024*1024), G(1024*1024*1024);
+        public final long size;
+        Unit(long size) { this.size = size; }
+    }
+
+    enum GC {
+        serial, parallel, g1, shenandoah, z;
+        String getSwitchName() {
+            String s = name();
+            return "-XX:+Use" + s.substring(0, 1).toUpperCase() + s.substring(1) + "GC";
+        }
+        boolean isZ() { return this == GC.z; }
+        boolean isSerial() { return this == GC.serial; }
+        boolean isParallel() { return this == GC.parallel; }
+        boolean isG1() { return this == GC.g1; }
+        boolean isShenandoah() { return this == GC.shenandoah; }
+    }
+
+    static private boolean usesNativeTrimmer(GC gc) {
+        return gc.isG1() || gc.isParallel() || gc.isZ();
+    }
+
+    static private final OutputAnalyzer runTestWithOptions(String[] extraOptions, String[] testArgs) throws Exception {
+
+        List<String> allOptions = new ArrayList<String>();
+        allOptions.add("-XX:+UnlockExperimentalVMOptions");
+        allOptions.addAll(Arrays.asList(extraOptions));
+        allOptions.add("-Xmx128m");
+        allOptions.add("-Xms128m"); // Stabilize RSS
+        allOptions.add("-XX:+AlwaysPreTouch"); // Stabilize RSS
+
+        allOptions.add(TestTrimNative.class.getName());
+        allOptions.add("RUN");
+        allOptions.addAll(Arrays.asList(testArgs));
+        ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(allOptions.toArray(new String[0]));
+        OutputAnalyzer output = new OutputAnalyzer(pb.start());
+        output.shouldHaveExitValue(0);
+        return output;
+
+    }
+
+    /**
+     * Given JVM output, look for a log line that describes a successful negative trim in the megabyte range
+     * like this:
+     * "[2.053s][debug][gc,trim] Trim native heap (retain size: 5120K): RSS+Swap: 271M->223M (-49112K), 2.834ms"
+     * (Note: we use the "properXXX" print routines, therefore units can differ)
+     * Check that the sum of all trim log lines comes to a total RSS reduction in the MB range
+     * @param output
+     * @param minExpected min number of trim lines expected in UL log
+     * @param maxExpected max number of trim lines expected in UL log
+     */
+    private final static void parseOutputAndLookForNegativeTrim(OutputAnalyzer output, int minExpected, int maxExpected) {
+        output.reportDiagnosticSummary();
+        List<String> lines = output.asLines();
+        Pattern pat = Pattern.compile(".*\\[gc,trim\\] Trim native heap.*RSS\\+Swap: (\\d+)([KMB])->(\\d+)([KMB]).*");
+        int numTrimsFound = 0;
+        long rssReductionTotal = 0;
+        for (String line : lines) {
+            Matcher mat = pat.matcher(line);
+            if (mat.matches()) {
+                long rss1 = Long.parseLong(mat.group(1)) * Unit.valueOf(mat.group(2)).size;
+                long rss2 = Long.parseLong(mat.group(3)) * Unit.valueOf(mat.group(4)).size;
+                System.out.println("Parsed Trim Line. rss1: " + rss1 + " rss2: " + rss2);
+                if (rss1 > rss2) {
+                    rssReductionTotal += (rss1 - rss2);
+                }
+                numTrimsFound ++;
+            }
+            if (numTrimsFound > maxExpected) {
+                throw new RuntimeException("Abnormal high number of trim attempts found (more than " + maxExpected +
+                                            "). Does the interval setting not work?");
+            }
+        }
+        if (numTrimsFound < minExpected) {
+            throw new RuntimeException("We found fewer trim lines in UL log than expected (expected " + minExpected +
+                    ", found " + numTrimsFound + ".");
+        }
+        // This is very fuzzy. We malloced X, free'd X, trimmed, measured the combined effect of all reductions.
+        // This does not take into effect mallocs or frees that may happen concurrently. But we expect to see *some*
+        // reduction somewhere. Test with a fudge factor.
+        float fudge = 0.8f;
+        long expectedMinimalReduction = (long) (totalAllocationsSize * fudge);
+        if (rssReductionTotal < expectedMinimalReduction) {
+            throw new RuntimeException("We did not see the expected RSS reduction in the UL log. Expected (with fudge)" +
+                                       " to see at least a combined reduction of " + expectedMinimalReduction + ".");
+        }
+    }
+
+    // Test that GCTrimNativeHeap=1 causes a trim-native on full gc
+    static private final void testWithFullGC(GC gc) throws Exception {
+        System.out.println("testWithFullGC");
+        int sleeptime_secs = 2;
+        OutputAnalyzer output = runTestWithOptions (
+                new String[] { gc.getSwitchName(), "-XX:+GCTrimNativeHeap" },
+                new String[] { "true" /* full gc */, String.valueOf(sleeptime_secs * 1000) /* ms after peak */ }
+        );
+        // With default interval time of 30 seconds, auto trimming should never kick in, so the only
+        // log line we expect to see is the one from the full-gc induced trim.
+        parseOutputAndLookForNegativeTrim(output, 1, 1);
+        // For GCs that use the NativeTrimmer, we want to see the NativeTrimmer paused during the GC, as well as
+        // started and shut down properly.
+        if (usesNativeTrimmer(gc)) {
+            output.shouldContain("NativeTrimmer started");
+            output.shouldContain("NativeTrimmer paused");
+            output.shouldContain("NativeTrimmer unpaused");
+            output.shouldContain("NativeTrimmer stopped");
+        } else {
+            output.shouldNotContain("NativeTrimmer");
+        }
+    }
+
+    // Test that GCTrimNativeHeap=1 causes a trim-native automatically, without GC (for now, shenandoah only)
+    static private final void testAuto(GC gc) throws Exception {
+        System.out.println("testAuto");
+        long t1 = System.currentTimeMillis();
+        int sleeptime_secs = 4;
+        OutputAnalyzer output = runTestWithOptions (
+                new String[] { gc.getSwitchName(), "-XX:+GCTrimNativeHeap", "-XX:GCTrimNativeHeapInterval=1" },
+                new String[] { "false" /* full gc */, String.valueOf(sleeptime_secs * 1000) /* ms after peak */ }
+        );
+        long t2 = System.currentTimeMillis();
+        int runtime_s = (int)((t2 - t1) / 1000);
+        // With an interval time of 1 second and a runtime of 6..x seconds we expect to see x log lines (+- fudge factor).
+        parseOutputAndLookForNegativeTrim(output, runtime_s - 4, runtime_s + 2);
+    }
+
+    // Test that trim-native correctly honors interval
+    static private final void testAutoWithHighInterval(GC gc) throws Exception {
+        // We pass a very high interval. This should disable the feature for this short-lived test, we should see no trim
+        System.out.println("testAutoWithHighInterval");
+        OutputAnalyzer output = runTestWithOptions (
+                new String[] { gc.getSwitchName(), "-XX:+GCTrimNativeHeap", "-XX:GCTrimNativeHeapInterval=30" },
+                new String[] { "false" /* full gc */, "6000" /* ms after peak */ }
+        );
+        output.shouldNotContain("Trim native heap");
+    }
+
+    // Test that trim-native correctly honors interval
+    static private final void testAutoWithZeroInterval(GC gc) throws Exception {
+        // We pass a very high interval. This should disable the feature for this short-lived test, we should see no trim
+        System.out.println("testAutoWithHighInterval");
+        OutputAnalyzer output = runTestWithOptions (
+                new String[] { gc.getSwitchName(), "-XX:+GCTrimNativeHeap", "-XX:GCTrimNativeHeapInterval=0" },
+                new String[] { "false" /* full gc */, "6000" /* ms after peak */ }
+        );
+        output.shouldNotContain("Trim native heap");
+    }
+
+    // Test that trim-native gets disabled on platforms that don't support it.
+    static private final void testOffOnNonCompliantPlatforms() throws Exception {
+        // Logic is shared, so no need to test with every GC. Just use the default GC.
+        System.out.println("testOffOnNonCompliantPlatforms");
+        OutputAnalyzer output = runTestWithOptions (
+                new String[] { "-XX:+GCTrimNativeHeap" },
+                new String[] { "true" /* full gc */, "2000" /* ms after peak */ }
+        );
+        output.shouldContain("GCTrimNativeHeap disabled");
+        output.shouldNotContain("Trim native heap");
+    }
+
+    // Test that GCTrimNativeHeap=0 switches trim-native off
+    static private final void testOffExplicit() throws Exception {
+        // Logic is shared, so no need to test with every GC. Just use the default GC.
+        System.out.println("testOffExplicit");
+        OutputAnalyzer output = runTestWithOptions (
+                new String[] { "-XX:-GCTrimNativeHeap" },
+                new String[] { "true" /* full gc */, "2000" /* ms after peak */ }
+        );
+        output.shouldNotContain("Trim native heap");
+    }
+
+    // Test that trim-native is disabled by default
+    static private final void testOffByDefault() throws Exception {
+        // Logic is shared, so no need to test with every GC. Just use the default GC.
+        System.out.println("testOffByDefault");
+        OutputAnalyzer output = runTestWithOptions (
+                new String[] { },
+                new String[] { "true" /* full gc */, "2000" /* ms after peak */ }
+        );
+        output.shouldNotContain("Trim native heap");
+    }
+
+    public static void main(String[] args) throws Exception {
+
+        if (args.length == 0) {
+            throw new RuntimeException("Argument error");
+        }
+
+        if (args[0].equals("RUN")) {
+            boolean doFullGC = Boolean.parseBoolean(args[1]);
+
+            System.out.println("Will spike now...");
+            Field field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            Unsafe unsafe = (Unsafe) field.get(null);
+            for (int i = 0; i < numAllocations; i++) {
+                ptrs[i] = unsafe.allocateMemory(szAllocations);
+                unsafe.putByte(ptrs[i], (byte)0);
+                unsafe.putByte(ptrs[i] + szAllocations / 2, (byte)0);
+            }
+            for (int i = 0; i < numAllocations; i++) {
+                unsafe.freeMemory(ptrs[i]);
+            }
+            System.out.println("Done spiking.");
+
+            if (doFullGC) {
+                System.out.println("GC...");
+                System.gc();
+            }
+
+            // give GC time to react
+            int time = Integer.parseInt(args[2]);
+            System.out.println("Sleeping...");
+            Thread.sleep(time);
+            System.out.println("Done.");
+
+            return;
+
+        } else if (args[0].equals("test-fullgc")) {
+            final GC gc = GC.valueOf(args[1]);
+            testWithFullGC(gc);
+        } else if (args[0].equals("test-auto")) {
+            final GC gc = GC.valueOf(args[1]);
+            testAuto(gc);
+        } else if (args[0].equals("test-auto-high-interval")) {
+            final GC gc = GC.valueOf(args[1]);
+            testAutoWithHighInterval(gc);
+        } else if (args[0].equals("test-auto-zero-interval")) {
+            final GC gc = GC.valueOf(args[1]);
+            testAutoWithZeroInterval(gc);
+        } else if (args[0].equals("test-off-explicit")) {
+            testOffExplicit();
+        } else if (args[0].equals("test-off-by-default")) {
+            testOffByDefault();
+        } else if (args[0].equals("test-off-on-other-platforms")) {
+            testOffOnNonCompliantPlatforms();
+        } else {
+            throw new RuntimeException("Invalid test " + args[0]);
+        }
+
+    }
+
+}
\ No newline at end of file
diff --git a/hotspot/test/serviceability/dcmd/TrimLibcHeapTest.java b/hotspot/test/serviceability/dcmd/TrimLibcHeapTest.java
index 0fe8e35..131fa4c 100644
--- a/hotspot/test/serviceability/dcmd/TrimLibcHeapTest.java
+++ b/hotspot/test/serviceability/dcmd/TrimLibcHeapTest.java
@@ -29,7 +29,7 @@ import com.oracle.java.testlibrary.*;
  * @test
  * @summary Test of diagnostic command VM.trim_libc_heap
  * @library /testlibrary
- * @requires os.family == "linux"
+ * @requires os.family=="linux"
  * @modules java.base/jdk.internal.misc
  *          java.compiler
  *          java.management
@@ -40,10 +40,7 @@ public class TrimLibcHeapTest {
     public void run(CommandExecutor executor) {
         OutputAnalyzer output = executor.execute("System.trim_native_heap");
         output.reportDiagnosticSummary();
-        output.shouldMatch("(Done|Not available)"); // Not available could happen on Linux + non-glibc (eg. muslc)
-        if (output.firstMatch("Done") != null) {
-            output.shouldMatch("(Virtual size before|RSS before|Swap before|No details available)");
-        }
+        output.shouldMatch(".*Trim native heap: RSS\\+Swap: \\d+[BKM]->\\d+[BKM].*");
     }

@Test
--
1.8.3.1