代码拉取完成，页面将自动刷新
diff --git a/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_interface/GCCause.java b/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_interface/GCCause.java
index 84f0a4ac..b38ee52e 100644
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_interface/GCCause.java
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_interface/GCCause.java
@@ -54,6 +54,7 @@ public enum GCCause {
_g1_inc_collection_pause ("G1 Evacuation Pause"),
_g1_humongous_allocation ("G1 Humongous Allocation"),
+ _g1_periodic_gc ("G1 Periodic GC"),
_last_ditch_collection ("Last ditch collection"),
_last_gc_cause ("ILLEGAL VALUE - last gc cause - ILLEGAL VALUE");
diff --git a/hotspot/make/bsd/makefiles/mapfile-vers-debug b/hotspot/make/bsd/makefiles/mapfile-vers-debug
index 49a70edc..00651d42 100644
--- a/hotspot/make/bsd/makefiles/mapfile-vers-debug
+++ b/hotspot/make/bsd/makefiles/mapfile-vers-debug
@@ -230,6 +230,10 @@
_JVM_SetPrimitiveArrayElement
_JVM_SetSockOpt
_JVM_SetThreadPriority
+ _JVM_AdaptiveHeapSetG1PeriodicGCInterval
+ _JVM_AdaptiveHeapGetG1PeriodicGCInterval
+ _JVM_AdaptiveHeapSetG1PeriodicGCLoadThreshold
+ _JVM_AdaptiveHeapGetG1PeriodicGCLoadThreshold
_JVM_Sleep
_JVM_Socket
_JVM_SocketAvailable
diff --git a/hotspot/make/bsd/makefiles/mapfile-vers-product b/hotspot/make/bsd/makefiles/mapfile-vers-product
index 50274671..4d51f425 100644
--- a/hotspot/make/bsd/makefiles/mapfile-vers-product
+++ b/hotspot/make/bsd/makefiles/mapfile-vers-product
@@ -230,6 +230,10 @@
_JVM_SetPrimitiveArrayElement
_JVM_SetSockOpt
_JVM_SetThreadPriority
+ _JVM_AdaptiveHeapGetG1PeriodicGCInterval
+ _JVM_AdaptiveHeapGetG1PeriodicGCLoadThreshold
+ _JVM_AdaptiveHeapSetG1PeriodicGCInterval
+ _JVM_AdaptiveHeapSetG1PeriodicGCLoadThreshold
_JVM_Sleep
_JVM_Socket
_JVM_SocketAvailable
diff --git a/hotspot/make/linux/makefiles/mapfile-vers-debug b/hotspot/make/linux/makefiles/mapfile-vers-debug
index 814a32f6..e1bb0c34 100644
--- a/hotspot/make/linux/makefiles/mapfile-vers-debug
+++ b/hotspot/make/linux/makefiles/mapfile-vers-debug
@@ -233,6 +233,10 @@ SUNWprivate_1.1 {
JVM_SetPrimitiveArrayElement;
JVM_SetSockOpt;
JVM_SetThreadPriority;
+ JVM_AdaptiveHeapSetG1PeriodicGCInterval;
+ JVM_AdaptiveHeapGetG1PeriodicGCInterval;
+ JVM_AdaptiveHeapSetG1PeriodicGCLoadThreshold;
+ JVM_AdaptiveHeapGetG1PeriodicGCLoadThreshold;
JVM_Sleep;
JVM_Socket;
JVM_SocketAvailable;
diff --git a/hotspot/make/linux/makefiles/mapfile-vers-product b/hotspot/make/linux/makefiles/mapfile-vers-product
index caf9a1ce..f6aba6ef 100644
--- a/hotspot/make/linux/makefiles/mapfile-vers-product
+++ b/hotspot/make/linux/makefiles/mapfile-vers-product
@@ -233,6 +233,10 @@ SUNWprivate_1.1 {
JVM_SetPrimitiveArrayElement;
JVM_SetSockOpt;
JVM_SetThreadPriority;
+ JVM_AdaptiveHeapSetG1PeriodicGCInterval;
+ JVM_AdaptiveHeapGetG1PeriodicGCInterval;
+ JVM_AdaptiveHeapSetG1PeriodicGCLoadThreshold;
+ JVM_AdaptiveHeapGetG1PeriodicGCLoadThreshold;
JVM_Sleep;
JVM_Socket;
JVM_SocketAvailable;
diff --git a/hotspot/src/os/aix/vm/os_aix.cpp b/hotspot/src/os/aix/vm/os_aix.cpp
index 4abd2f03..b078bee0 100644
--- a/hotspot/src/os/aix/vm/os_aix.cpp
+++ b/hotspot/src/os/aix/vm/os_aix.cpp
@@ -4476,6 +4476,10 @@ bool os::is_thread_cpu_time_supported() {
return true;
}
+double os::get_process_load() {
+ return -1.0;
+}
+
// System loadavg support. Returns -1 if load average cannot be obtained.
// For now just return the system wide load average (no processor sets).
int os::loadavg(double values[], int nelem) {
diff --git a/hotspot/src/os/bsd/vm/os_bsd.cpp b/hotspot/src/os/bsd/vm/os_bsd.cpp
index 6d1009b8..3e4d8c7e 100644
--- a/hotspot/src/os/bsd/vm/os_bsd.cpp
+++ b/hotspot/src/os/bsd/vm/os_bsd.cpp
@@ -4293,6 +4293,10 @@ bool os::is_thread_cpu_time_supported() {
#endif
}
+double os::get_process_load() {
+ return -1.0;
+}
+
// System loadavg support. Returns -1 if load average cannot be obtained.
// Bsd doesn't yet have a (official) notion of processor sets,
// so just return the system wide load average.
diff --git a/hotspot/src/os/linux/vm/os_linux.cpp b/hotspot/src/os/linux/vm/os_linux.cpp
index 5848bd80..0b7f4a6e 100644
--- a/hotspot/src/os/linux/vm/os_linux.cpp
+++ b/hotspot/src/os/linux/vm/os_linux.cpp
@@ -38,6 +38,7 @@
#include "oops/oop.inline.hpp"
#include "os_share_linux.hpp"
#include "osContainer_linux.hpp"
+#include "process_load.hpp"
#include "prims/jniFastGetField.hpp"
#include "prims/jvm.h"
#include "prims/jvm_misc.hpp"
@@ -5892,6 +5893,15 @@ int os::loadavg(double loadavg[], int nelem) {
return ::getloadavg(loadavg, nelem);
}
+double os::get_process_load() {
+ double u, s;
+ u = get_cpuload_internal(-1, &s, CPU_LOAD_VM_ONLY);
+ if (u < 0) {
+ return -1.0;
+ }
+ return u + s;
+}
+
void os::pause() {
char filename[MAX_PATH];
if (PauseAtStartupFile && PauseAtStartupFile[0]) {
diff --git a/hotspot/src/os/linux/vm/process_load.hpp b/hotspot/src/os/linux/vm/process_load.hpp
new file mode 100644
index 00000000..83800b19
--- /dev/null
+++ b/hotspot/src/os/linux/vm/process_load.hpp
@@ -0,0 +1,299 @@
+/*
+ * Copyright (c) 2011, 2015, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 OS_LINUX_VM_PROCESS_LOAD_HPP
+#define OS_LINUX_VM_PROCESS_LOAD_HPP
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/resource.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+#include <pthread.h>
+
+struct ticks {
+ uint64_t used;
+ uint64_t usedKernel;
+ uint64_t total;
+};
+
+typedef struct ticks ticks;
+
+typedef enum {
+ CPU_LOAD_VM_ONLY,
+ CPU_LOAD_GLOBAL,
+} CpuLoadTarget;
+
+static struct perfbuf {
+ int nProcs;
+ ticks jvmTicks;
+ ticks cpuTicks;
+ ticks *cpus;
+} counters;
+
+static void next_line(FILE *f) {
+ while (fgetc(f) != '\n');
+}
+
+/**
+ * Return the total number of ticks since the system was booted.
+ * If the usedTicks parameter is not NULL, it will be filled with
+ * the number of ticks spent on actual processes (user, system or
+ * nice processes) since system boot. Note that this is the total number
+ * of "executed" ticks on _all_ CPU:s, that is on a n-way system it is
+ * n times the number of ticks that has passed in clock time.
+ *
+ * Returns a negative value if the reading of the ticks failed.
+ */
+static int get_totalticks(int which, ticks *pticks) {
+ FILE *fh;
+ uint64_t userTicks, niceTicks, systemTicks, idleTicks;
+ uint64_t iowTicks = 0, irqTicks = 0, sirqTicks= 0;
+ int n;
+
+ if((fh = fopen("/proc/stat", "r")) == NULL) {
+ return -1;
+ }
+
+ n = fscanf(fh, "cpu " UINT64_FORMAT " " UINT64_FORMAT " " UINT64_FORMAT " " UINT64_FORMAT " " UINT64_FORMAT " "
+ UINT64_FORMAT " " UINT64_FORMAT,
+ &userTicks, &niceTicks, &systemTicks, &idleTicks,
+ &iowTicks, &irqTicks, &sirqTicks);
+
+ // Move to next line
+ next_line(fh);
+
+ //find the line for requested cpu faster to just iterate linefeeds?
+ if (which != -1) {
+ int i;
+ for (i = 0; i < which; i++) {
+ if (fscanf(fh, "cpu%*d " UINT64_FORMAT " " UINT64_FORMAT " " UINT64_FORMAT " " UINT64_FORMAT " "
+ UINT64_FORMAT " " UINT64_FORMAT " " UINT64_FORMAT,
+ &userTicks, &niceTicks, &systemTicks, &idleTicks,
+ &iowTicks, &irqTicks, &sirqTicks) < 4) {
+ fclose(fh);
+ return -2;
+ }
+ next_line(fh);
+ }
+ n = fscanf(fh, "cpu%*d " UINT64_FORMAT " " UINT64_FORMAT " " UINT64_FORMAT " " UINT64_FORMAT " "
+ UINT64_FORMAT " " UINT64_FORMAT " " UINT64_FORMAT "\n",
+ &userTicks, &niceTicks, &systemTicks, &idleTicks,
+ &iowTicks, &irqTicks, &sirqTicks);
+ }
+
+ fclose(fh);
+ if (n < 4) {
+ return -2;
+ }
+
+ pticks->used = userTicks + niceTicks;
+ pticks->usedKernel = systemTicks + irqTicks + sirqTicks;
+ pticks->total = userTicks + niceTicks + systemTicks + idleTicks +
+ iowTicks + irqTicks + sirqTicks;
+
+ return 0;
+}
+
+static int vread_statdata(const char *procfile, const char *fmt, va_list args) {
+ FILE *f;
+ int n;
+ char buf[2048];
+
+ if ((f = fopen(procfile, "r")) == NULL) {
+ return -1;
+ }
+
+ if ((n = fread(buf, 1, sizeof(buf), f)) != -1) {
+ char *tmp;
+
+ buf[n-1] = '\0';
+ /** skip through pid and exec name. the exec name _could be wacky_ (renamed) and
+ * make scanf go mupp.
+ */
+ if ((tmp = strrchr(buf, ')')) != NULL) {
+ // skip the ')' and the following space but check that the buffer is long enough
+ tmp += 2;
+ if (tmp < buf + n) {
+ n = vsscanf(tmp, fmt, args);
+ }
+ }
+ }
+
+ fclose(f);
+
+ return n;
+}
+
+static int read_statdata(const char *procfile, const char *fmt, ...) {
+ int n;
+ va_list args;
+
+ va_start(args, fmt);
+ n = vread_statdata(procfile, fmt, args);
+ va_end(args);
+ return n;
+}
+
+/** read user and system ticks from a named procfile, assumed to be in 'stat' format then. */
+static int read_ticks(const char *procfile, uint64_t *userTicks, uint64_t *systemTicks) {
+ return read_statdata(procfile, "%*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u "UINT64_FORMAT" "UINT64_FORMAT,
+ userTicks, systemTicks
+ );
+}
+
+/**
+ * Return the number of ticks spent in any of the processes belonging
+ * to the JVM on any CPU.
+ */
+static int get_jvmticks(ticks *pticks) {
+ uint64_t userTicks;
+ uint64_t systemTicks;
+
+ if (read_ticks("/proc/self/stat", &userTicks, &systemTicks) < 0) {
+ return -1;
+ }
+
+ // get the total
+ if (get_totalticks(-1, pticks) < 0) {
+ return -1;
+ }
+
+ pticks->used = userTicks;
+ pticks->usedKernel = systemTicks;
+
+ return 0;
+}
+
+/**
+ * This method must be called first, before any data can be gathererd.
+ */
+int perfInit() {
+ static int initialized=1;
+
+ if (!initialized) {
+ int i;
+
+ int n = sysconf(_SC_NPROCESSORS_ONLN);
+ if (n <= 0) {
+ n = 1;
+ }
+
+ counters.cpus = (ticks*)calloc(n,sizeof(ticks));
+ if (counters.cpus != NULL) {
+ // For the CPU load
+ get_totalticks(-1, &counters.cpuTicks);
+
+ for (i = 0; i < n; i++) {
+ get_totalticks(i, &counters.cpus[i]);
+ }
+ // For JVM load
+ get_jvmticks(&counters.jvmTicks);
+ initialized = 1;
+ }
+ }
+
+ return initialized ? 0 : -1;
+}
+
+static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+
+/**
+ * Return the load of the CPU as a double. 1.0 means the CPU process uses all
+ * available time for user or system processes, 0.0 means the CPU uses all time
+ * being idle.
+ *
+ * Returns a negative value if there is a problem in determining the CPU load.
+ */
+
+static double get_cpuload_internal(int which, double *pkernelLoad, CpuLoadTarget target) {
+ uint64_t udiff, kdiff, tdiff;
+ ticks *pticks, tmp;
+ double user_load = -1.0;
+ int failed = 0;
+
+ *pkernelLoad = 0.0;
+
+ pthread_mutex_lock(&lock);
+
+ if(perfInit() == 0) {
+
+ if (target == CPU_LOAD_VM_ONLY) {
+ pticks = &counters.jvmTicks;
+ } else if (which == -1) {
+ pticks = &counters.cpuTicks;
+ } else {
+ pticks = &counters.cpus[which];
+ }
+
+ tmp = *pticks;
+
+ if (target == CPU_LOAD_VM_ONLY) {
+ if (get_jvmticks(pticks) != 0) {
+ failed = 1;
+ }
+ } else if (get_totalticks(which, pticks) < 0) {
+ failed = 1;
+ }
+
+ if(!failed) {
+ // seems like we sometimes end up with less kernel ticks when
+ // reading /proc/self/stat a second time, timing issue between cpus?
+ if (pticks->usedKernel < tmp.usedKernel) {
+ kdiff = 0;
+ } else {
+ kdiff = pticks->usedKernel - tmp.usedKernel;
+ }
+ tdiff = pticks->total - tmp.total;
+ udiff = pticks->used - tmp.used;
+
+ if (tdiff == 0) {
+ user_load = 0;
+ } else {
+ if (tdiff < (udiff + kdiff)) {
+ tdiff = udiff + kdiff;
+ }
+ *pkernelLoad = (kdiff / (double)tdiff);
+ // BUG9044876, normalize return values to sane values
+ *pkernelLoad = MAX(*pkernelLoad, 0.0);
+ *pkernelLoad = MIN(*pkernelLoad, 1.0);
+
+ user_load = (udiff / (double)tdiff);
+ user_load = MAX(user_load, 0.0);
+ user_load = MIN(user_load, 1.0);
+ }
+ }
+ }
+ pthread_mutex_unlock(&lock);
+ return user_load;
+}
+
+#endif
diff --git a/hotspot/src/os/solaris/vm/os_solaris.cpp b/hotspot/src/os/solaris/vm/os_solaris.cpp
index 9c9de85a..73253843 100644
--- a/hotspot/src/os/solaris/vm/os_solaris.cpp
+++ b/hotspot/src/os/solaris/vm/os_solaris.cpp
@@ -5709,6 +5709,10 @@ bool os::is_thread_cpu_time_supported() {
}
}
+double os::get_process_load() {
+ return -1.0;
+}
+
// System loadavg support. Returns -1 if load average cannot be obtained.
// Return the load average for our processor set if the primitive exists
// (Solaris 9 and later). Otherwise just return system wide loadavg.
diff --git a/hotspot/src/os/windows/vm/os_windows.cpp b/hotspot/src/os/windows/vm/os_windows.cpp
index 74412a3e..e7ff202a 100644
--- a/hotspot/src/os/windows/vm/os_windows.cpp
+++ b/hotspot/src/os/windows/vm/os_windows.cpp
@@ -4312,6 +4312,10 @@ bool os::is_thread_cpu_time_supported() {
}
}
+double os::get_process_load() {
+ return -1.0;
+}
+
// Windows does't provide a loadavg primitive so this is stubbed out for now.
// It does have primitives (PDH API) to get CPU usage and run queue length.
// "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length"
diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.cpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.cpp
index a42b8ec7..98a43ba6 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.cpp
@@ -25,6 +25,7 @@
#include "precompiled.hpp"
#include "gc_implementation/g1/concurrentG1Refine.hpp"
#include "gc_implementation/g1/concurrentG1RefineThread.hpp"
+#include "gc_implementation/g1/concurrentMarkThread.hpp"
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
#include "gc_implementation/g1/g1CollectorPolicy.hpp"
#include "memory/resourceArea.hpp"
@@ -43,7 +44,8 @@ ConcurrentG1RefineThread(ConcurrentG1Refine* cg1r, ConcurrentG1RefineThread *nex
_next(next),
_monitor(NULL),
_cg1r(cg1r),
- _vtime_accum(0.0)
+ _vtime_accum(0.0),
+ _last_periodic_gc_attempt_s(0.0)
{
// Each thread has its own monitor. The i-th thread is responsible for signalling
@@ -98,6 +100,69 @@ void ConcurrentG1RefineThread::sample_young_list_rs_lengths() {
}
}
+bool ConcurrentG1RefineThread::should_start_periodic_gc() {
+ // If we are currently in a concurrent mark we are going to uncommit memory soon.
+ if (G1CollectedHeap::heap()->concurrent_mark()->cmThread()->during_cycle()) {
+ if (G1UncommitLog) {
+ gclog_or_tty->print_cr("Concurrent cycle in progress. Skipping.");
+ }
+ return false;
+ }
+
+ // Check if enough time has passed since the last GC.
+ uintx time_since_last_gc;
+ if ((time_since_last_gc = (uintx)Universe::heap()->millis_since_last_gc()) < G1PeriodicGCInterval) {
+ if (G1UncommitLog) {
+ gclog_or_tty->print_cr("Last GC occurred " UINTX_FORMAT "ms before which is below threshold " UINTX_FORMAT "ms. Skipping.",
+ time_since_last_gc, G1PeriodicGCInterval);
+ }
+ return false;
+ }
+
+ return true;
+}
+
+void ConcurrentG1RefineThread::check_for_periodic_gc() {
+ if (!G1Uncommit) {
+ return;
+ }
+
+ assert(G1PeriodicGCInterval > 0, "just checking");
+ double recent_load = -1.0;
+ G1CollectedHeap* g1h = G1CollectedHeap::heap();
+ G1CollectorPolicy* g1p = g1h->g1_policy();
+ if (G1PeriodicGCLoadThreshold) {
+ // Sample process load and store it
+ if (G1PeriodicGCProcessLoad) {
+ recent_load = os::get_process_load() * 100;
+ }
+ if (recent_load < 0) {
+ // Fallback to os load
+ G1PeriodicGCProcessLoad = false;
+ if (os::loadavg(&recent_load, 1) != -1) {
+ static int cpu_count = os::active_processor_count();
+ assert(cpu_count > 0, "just checking");
+ recent_load = recent_load * 100 / cpu_count;
+ }
+ }
+ if (recent_load >= 0) {
+ g1p->add_os_load(recent_load);
+ }
+ }
+
+ double now = os::elapsedTime();
+ if (now - _last_periodic_gc_attempt_s > G1PeriodicGCInterval / 1000.0) {
+ if (G1UncommitLog) {
+ recent_load < 0 ? gclog_or_tty->print_cr("Checking for periodic GC.")
+ : gclog_or_tty->print_cr("Checking for periodic GC. Current load %1.2f. Heap total " UINT32_FORMAT " free " UINT32_FORMAT, recent_load, g1h->_hrm.length(), g1h->_hrm.num_free_regions());
+ }
+ if (should_start_periodic_gc()) {
+ g1p->set_periodic_gc();
+ }
+ _last_periodic_gc_attempt_s = now;
+ }
+}
+
void ConcurrentG1RefineThread::run_young_rs_sampling() {
DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
_vtime_start = os::elapsedVTime();
@@ -110,6 +175,8 @@ void ConcurrentG1RefineThread::run_young_rs_sampling() {
_vtime_accum = 0.0;
}
+ check_for_periodic_gc();
+
MutexLockerEx x(_monitor, Mutex::_no_safepoint_check_flag);
if (_should_terminate) {
break;
diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.hpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.hpp
index 05a8dc44..8fa52137 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.hpp
@@ -42,6 +42,8 @@ class ConcurrentG1RefineThread: public ConcurrentGCThread {
uint _worker_id;
uint _worker_id_offset;
+ double _last_periodic_gc_attempt_s;
+
// The refinement threads collection is linked list. A predecessor can activate a successor
// when the number of the rset update buffer crosses a certain threshold. A successor
// would self-deactivate when the number of the buffers falls below the threshold.
@@ -68,6 +70,9 @@ class ConcurrentG1RefineThread: public ConcurrentGCThread {
void activate();
void deactivate();
+ void check_for_periodic_gc();
+ bool should_start_periodic_gc();
+
public:
virtual void run();
// Constructor
diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp
index 14b5749f..ad696e08 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp
@@ -1354,6 +1354,7 @@ void ConcurrentMark::checkpointRootsFinal(bool clear_all_soft_refs) {
satb_mq_set.set_active_all_threads(false, /* new active value */
true /* expected_active */);
+ g1h->extract_uncommit_list();
if (VerifyDuringGC) {
HandleMark hm; // handle scope
Universe::heap()->prepare_for_verify();
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.inline.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.inline.hpp
index 70646a41..ed891c50 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.inline.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.inline.hpp
@@ -47,15 +47,15 @@ G1BlockOffsetTable::block_start_const(const void* addr) const {
}
}
-#define check_index(index, msg) \
- assert((index) < (_reserved.word_size() >> LogN_words), \
- err_msg("%s - index: "SIZE_FORMAT", _vs.committed_size: "SIZE_FORMAT, \
- msg, (index), (_reserved.word_size() >> LogN_words))); \
- assert(G1CollectedHeap::heap()->is_in_exact(address_for_index_raw(index)), \
- err_msg("Index "SIZE_FORMAT" corresponding to "PTR_FORMAT \
- " (%u) is not in committed area.", \
- (index), \
- p2i(address_for_index_raw(index)), \
+#define check_index(index, msg) \
+ assert((index) < (_reserved.word_size() >> LogN_words), \
+ err_msg("%s - index: "SIZE_FORMAT", _vs.committed_size: "SIZE_FORMAT, \
+ msg, (index), (_reserved.word_size() >> LogN_words))); \
+ assert(!G1Uncommit && G1CollectedHeap::heap()->is_in_exact(address_for_index_raw(index)) || G1Uncommit, \
+ err_msg("Index "SIZE_FORMAT" corresponding to "PTR_FORMAT \
+ " (%u) is not in committed area.", \
+ (index), \
+ p2i(address_for_index_raw(index)), \
G1CollectedHeap::heap()->addr_to_region(address_for_index_raw(index))));
u_char G1BlockOffsetSharedArray::offset_array(size_t index) const {
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
index 4eccf980..273a4dd2 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
@@ -1873,6 +1873,7 @@ G1CollectedHeap::G1CollectedHeap(G1CollectorPolicy* policy_) :
_dirty_cards_region_list(NULL),
_worker_cset_start_region(NULL),
_worker_cset_start_region_time_stamp(NULL),
+ _uncommit_thread(NULL),
_gc_timer_stw(new (ResourceObj::C_HEAP, mtGC) STWGCTimer()),
_gc_timer_cm(new (ResourceObj::C_HEAP, mtGC) ConcurrentGCTimer()),
_gc_tracer_stw(new (ResourceObj::C_HEAP, mtGC) G1NewTracer()),
@@ -1952,6 +1953,16 @@ jint G1CollectedHeap::initialize() {
size_t max_byte_size = collector_policy()->max_heap_byte_size();
size_t heap_alignment = collector_policy()->heap_alignment();
+ if (G1Uncommit) {
+ if (G1PeriodicGCInterval == 0) {
+ vm_exit_during_initialization(err_msg("G1Uncommit requires G1PeriodicGCInterval > 0"));
+ return JNI_EINVAL;
+ }
+ if (G1PeriodicGCLoadThreshold < 0 || G1PeriodicGCLoadThreshold > 100) {
+ vm_exit_during_initialization(err_msg("G1Uncommit requires G1PeriodicGCLoadThreshold >= 0 and <= 100"));
+ return JNI_EINVAL;
+ }
+ }
// Ensure that the sizes are properly aligned.
Universe::check_alignment(init_byte_size, HeapRegion::GrainBytes, "g1 heap");
Universe::check_alignment(max_byte_size, HeapRegion::GrainBytes, "g1 heap");
@@ -2148,6 +2159,30 @@ void G1CollectedHeap::stop() {
if (G1StringDedup::is_enabled()) {
G1StringDedup::stop();
}
+ if (G1Uncommit && _uncommit_thread != NULL) {
+ _uncommit_thread->stop();
+ PeriodicGC::stop();
+ }
+}
+
+void G1CollectedHeap::check_trigger_periodic_gc() {
+ if (g1_policy()->should_trigger_periodic_gc()) {
+ collect(GCCause::_g1_periodic_collection);
+ }
+}
+
+void G1CollectedHeap::init_periodic_gc_thread() {
+ if (_uncommit_thread == NULL && G1Uncommit) {
+ PeriodicGC::start();
+ _uncommit_thread = new G1UncommitThread();
+ }
+}
+
+void G1CollectedHeap::extract_uncommit_list() {
+ if (g1_policy()->can_extract_uncommit_list()) {
+ uint count = _hrm.extract_uncommit_list();
+ g1_policy()->record_extract_uncommit_list(count);
+ }
}
size_t G1CollectedHeap::conservative_max_heap_alignment() {
@@ -2335,6 +2370,7 @@ bool G1CollectedHeap::should_do_concurrent_full_gc(GCCause::Cause cause) {
case GCCause::_g1_humongous_allocation: return true;
case GCCause::_update_allocation_context_stats_inc: return true;
case GCCause::_wb_conc_mark: return true;
+ case GCCause::_g1_periodic_collection: return true;
default: return false;
}
}
@@ -2528,6 +2564,7 @@ void G1CollectedHeap::collect(GCCause::Cause cause) {
return;
} else {
if (cause == GCCause::_gc_locker || cause == GCCause::_wb_young_gc
+ || cause == GCCause::_g1_periodic_collection
DEBUG_ONLY(|| cause == GCCause::_scavenge_alot)) {
// Schedule a standard evacuation pause. We're setting word_size
@@ -2925,7 +2962,14 @@ size_t G1CollectedHeap::max_capacity() const {
jlong G1CollectedHeap::millis_since_last_gc() {
// assert(false, "NYI");
- return 0;
+ jlong ret_val = (os::javaTimeNanos() / NANOSECS_PER_MILLISEC) -
+ _g1_policy->collection_pause_end_millis();
+ if (ret_val < 0) {
+ gclog_or_tty->print_cr("millis_since_last_gc() would return : " JLONG_FORMAT
+ ". returning zero instead.", ret_val);
+ return 0;
+ }
+ return ret_val;
}
void G1CollectedHeap::prepare_for_verify() {
@@ -4033,6 +4077,7 @@ G1CollectedHeap::do_collection_pause_at_safepoint(double target_pause_time_ms) {
double pause_start_sec = os::elapsedTime();
+ g1_policy()->record_gc_start(pause_start_sec);
g1_policy()->phase_times()->note_gc_start(active_workers, mark_in_progress());
log_gc_header();
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp
index 4783cbde..bde0ca4d 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp
@@ -35,6 +35,7 @@
#include "gc_implementation/g1/g1InCSetState.hpp"
#include "gc_implementation/g1/g1MonitoringSupport.hpp"
#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
+#include "gc_implementation/g1/g1UncommitThread.hpp"
#include "gc_implementation/g1/g1YCTypes.hpp"
#include "gc_implementation/g1/heapRegionManager.hpp"
#include "gc_implementation/g1/heapRegionSet.hpp"
@@ -74,8 +75,10 @@ class GenerationCounters;
class STWGCTimer;
class G1NewTracer;
class G1OldTracer;
+class G1UncommitThread;
class EvacuationFailedInfo;
class nmethod;
+class ScanRSClosure;
typedef OverflowTaskQueue<StarTask, mtGC> RefToScanQueue;
typedef GenericTaskQueueSet<RefToScanQueue, mtGC> RefToScanQueueSet;
@@ -186,8 +189,12 @@ class G1CollectedHeap : public SharedHeap {
friend class SurvivorGCAllocRegion;
friend class OldGCAllocRegion;
friend class G1Allocator;
+ friend class G1CollectorPolicy;
friend class G1DefaultAllocator;
friend class G1ResManAllocator;
+ friend class ScanRSClosure;
+ friend class G1UncommitThread;
+ friend class ConcurrentG1RefineThread;
// Closures used in implementation.
template <G1Barrier barrier, G1Mark do_mark_object>
@@ -210,6 +217,7 @@ class G1CollectedHeap : public SharedHeap {
friend class G1ParCleanupCTTask;
friend class G1FreeHumongousRegionClosure;
+ friend class FreeRegionList;
// Other related classes.
friend class G1MarkSweep;
@@ -266,6 +274,8 @@ private:
// Class that handles the different kinds of allocations.
G1Allocator* _allocator;
+ G1UncommitThread* _uncommit_thread;
+
// Statistics for each allocation context
AllocationContextStats _allocation_context_stats;
@@ -1002,6 +1012,10 @@ public:
void set_refine_cte_cl_concurrency(bool concurrent);
+ void check_trigger_periodic_gc();
+ void init_periodic_gc_thread();
+ void extract_uncommit_list();
+
RefToScanQueue *task_queue(int i) const;
// A set of cards where updates happened during the GC
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp
index 761b0e95..c41e6b65 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp
@@ -93,6 +93,9 @@ G1CollectorPolicy::G1CollectorPolicy() :
_concurrent_mark_cleanup_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
_alloc_rate_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
+ _heap_size_seq(new TruncatedSeq(TruncatedSeqLength)),
+ _os_load_seq(new TruncatedSeq(TruncatedSeqLength)),
+ _gc_count_seq(new TruncatedSeq(TruncatedSeqLength)),
_prev_collection_pause_end_ms(0.0),
_rs_length_diff_seq(new TruncatedSeq(TruncatedSeqLength)),
_cost_per_card_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
@@ -113,6 +116,13 @@ G1CollectorPolicy::G1CollectorPolicy() :
_pause_time_target_ms((double) MaxGCPauseMillis),
_gcs_are_young(true),
+ _periodic_gc(false),
+ _last_uncommit_attempt_s(0.0),
+ _os_load(-1.0),
+ _uncommit_start_time(0),
+ _gc_count_cancel_extract(false),
+ _gc_count(0),
+ _gc_count_minute(0),
_during_marking(false),
_in_marking_window(false),
@@ -152,7 +162,8 @@ G1CollectorPolicy::G1CollectorPolicy() :
_inc_cset_recorded_rs_lengths_diffs(0),
_inc_cset_predicted_elapsed_time_ms(0.0),
_inc_cset_predicted_elapsed_time_ms_diffs(0.0),
-
+ _collection_pause_end_millis(os::javaTimeNanos() / NANOSECS_PER_MILLISEC),
+ _extract_uncommit_list(0),
#ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away
#pragma warning( disable:4355 ) // 'this' : used in base member initializer list
#endif // _MSC_VER
@@ -975,6 +986,8 @@ void G1CollectorPolicy::record_collection_pause_end(double pause_time_ms, Evacua
}
#endif // PRODUCT
+ _collection_pause_end_millis = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
+
last_pause_included_initial_mark = during_initial_mark_pause();
if (last_pause_included_initial_mark) {
record_concurrent_mark_init_end(0.0);
@@ -1203,6 +1216,7 @@ void G1CollectorPolicy::record_heap_size_info_at_start(bool full) {
_heap_capacity_bytes_before_gc = _g1->capacity();
_heap_used_bytes_before_gc = _g1->used();
_cur_collection_pause_used_regions_at_start = _g1->num_used_regions();
+ _heap_size_seq->add(_cur_collection_pause_used_regions_at_start);
_eden_capacity_bytes_before_gc =
(_young_list_target_length * HeapRegion::GrainBytes) - _survivor_used_bytes_before_gc;
@@ -1246,6 +1260,13 @@ void G1CollectorPolicy::print_detailed_heap_transition(bool full) {
EXT_SIZE_PARAMS(heap_used_bytes_after_gc),
EXT_SIZE_PARAMS(heap_capacity_bytes_after_gc));
+ if (_extract_uncommit_list) {
+ gclog_or_tty->print(" [Uncommit list " UINT32_FORMAT ", remaining " UINT32_FORMAT ", free list " UINT32_FORMAT "]",
+ _extract_uncommit_list,
+ _g1->_hrm.length(),
+ _g1->_hrm.num_free_regions());
+ _extract_uncommit_list = 0;
+ }
if (full) {
MetaspaceAux::print_metaspace_change(_metaspace_used_bytes_before_gc);
}
@@ -2159,6 +2180,53 @@ void G1CollectorPolicy::finalize_cset(double target_pause_time_ms, EvacuationInf
evacuation_info.set_collectionset_regions(cset_region_length());
}
+void G1CollectorPolicy::record_gc_start(double curr_sec) {
+ if (_uncommit_start_time == 0) {
+ _uncommit_start_time = curr_sec + G1UncommitDelay;
+ }
+ long curr = curr_sec / 60;
+ if (curr > _gc_count_minute) {
+ int diff = curr - _gc_count_minute;
+ _gc_count_seq->add(_gc_count);
+ for (int i = 1; i < diff; i++) {
+ _gc_count_seq->add(0.0);
+ }
+ _gc_count_minute = curr;
+ double gc_count_expected = get_new_prediction(_gc_count_seq);
+ // Considering the test result, 15000 is an appropriate value for G1PeriodicGCInterval.
+ _gc_count_cancel_extract = gc_count_expected > MIN2(4.0, 60000.0 / G1PeriodicGCInterval);
+ _gc_count = 0;
+ }
+ _gc_count++;
+}
+
+bool G1CollectorPolicy::should_trigger_periodic_gc() {
+ if (G1PeriodicGCLoadThreshold && _os_load > G1PeriodicGCLoadThreshold) {
+ _periodic_gc = false;
+ } else if (_periodic_gc) {
+ _periodic_gc = false;
+ return true;
+ }
+ return false;
+}
+
+bool G1CollectorPolicy::can_extract_uncommit_list() {
+ double now = os::elapsedTime();
+ if (G1Uncommit && now > _uncommit_start_time) {
+ if (G1PeriodicGCLoadThreshold && _os_load > G1PeriodicGCLoadThreshold) {
+ return false;
+ }
+ G1CollectedHeap* g1h = G1CollectedHeap::heap();
+ if (!_gc_count_cancel_extract || now >= (g1h->millis_since_last_gc() + G1PeriodicGCInterval) / 1000.0) {
+ if (now - _last_uncommit_attempt_s >= G1PeriodicGCInterval / 1000.0) {
+ _last_uncommit_attempt_s = now;
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
void TraceGen0TimeData::record_start_collection(double time_to_stop_the_world_ms) {
if(TraceGen0Time) {
_all_stop_world_times_ms.add(time_to_stop_the_world_ms);
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp
index 02217ce4..1c918070 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp
@@ -183,6 +183,7 @@ private:
CollectionSetChooser* _collectionSetChooser;
+ jlong _collection_pause_end_millis;
double _full_collection_start_sec;
uint _cur_collection_pause_used_regions_at_start;
@@ -243,6 +244,9 @@ private:
TruncatedSeq* _constant_other_time_ms_seq;
TruncatedSeq* _young_other_cost_per_region_ms_seq;
TruncatedSeq* _non_young_other_cost_per_region_ms_seq;
+ TruncatedSeq* _heap_size_seq;
+ TruncatedSeq* _os_load_seq;
+ TruncatedSeq* _gc_count_seq;
TruncatedSeq* _pending_cards_seq;
TruncatedSeq* _rs_lengths_seq;
@@ -264,6 +268,8 @@ private:
uint _free_regions_at_end_of_collection;
+ uint _extract_uncommit_list;
+
size_t _recorded_rs_lengths;
size_t _max_rs_lengths;
double _sigma;
@@ -300,9 +306,21 @@ private:
size_t _pending_cards;
+ size_t _gc_count;
+ long _gc_count_minute;
+ bool _gc_count_cancel_extract;
+
+ volatile bool _periodic_gc;
+ double _last_uncommit_attempt_s;
+ volatile double _os_load;
+ double _uncommit_start_time;
public:
// Accessors
+ void set_periodic_gc() { _periodic_gc = true; }
+ bool can_extract_uncommit_list();
+ bool should_trigger_periodic_gc();
+
void set_region_eden(HeapRegion* hr, int young_index_in_cset) {
hr->set_eden();
hr->install_surv_rate_group(_short_lived_surv_rate_group);
@@ -328,6 +346,17 @@ public:
_max_rs_lengths = rs_lengths;
}
+ size_t predict_heap_size_seq() {
+ return (size_t) get_new_prediction(_heap_size_seq);
+ }
+
+ void add_os_load(double load) {
+ _os_load_seq->add(load);
+ _os_load = get_new_prediction(_os_load_seq);
+ }
+
+ void record_gc_start(double sec);
+
size_t predict_rs_length_diff() {
return (size_t) get_new_prediction(_rs_length_diff_seq);
}
@@ -475,6 +504,8 @@ public:
return _short_lived_surv_rate_group->accum_surv_rate_pred(age);
}
+ jlong collection_pause_end_millis() { return _collection_pause_end_millis; }
+
private:
// Statistics kept per GC stoppage, pause or full.
TruncatedSeq* _recent_prev_end_times_for_all_gcs_sec;
@@ -706,6 +737,8 @@ public:
void record_stop_world_start();
void record_concurrent_pause();
+ void record_extract_uncommit_list(uint count) { _extract_uncommit_list = count; }
+
// Record how much space we copied during a GC. This is typically
// called when a GC alloc region is being retired.
void record_bytes_copied_during_gc(size_t bytes) {
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp
index 4cad9234..2be3ac1b 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp
@@ -206,6 +206,9 @@ public:
#endif
HeapRegion* card_region = _g1h->heap_region_containing(card_start);
+ if (!_g1h->_hrm.is_available(card_region->hrm_index())) {
+ continue;
+ }
_cards++;
if (!card_region->is_on_dirty_cards_region_list()) {
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1UncommitThread.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1UncommitThread.cpp
new file mode 100644
index 00000000..37bdbdb6
--- /dev/null
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1UncommitThread.cpp
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2001, 2019, 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
+ * 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/g1/g1UncommitThread.hpp"
+#include "gc_implementation/g1/g1_globals.hpp"
+#include "runtime/javaCalls.hpp"
+#include "runtime/os.hpp"
+
+#ifdef _WINDOWS
+#pragma warning(disable : 4355)
+#endif
+
+volatile bool PeriodicGC::_should_terminate = false;
+JavaThread* PeriodicGC::_thread = NULL;
+Monitor* PeriodicGC::_monitor = NULL;
+
+bool PeriodicGC::has_error(TRAPS, const char* error) {
+ if (HAS_PENDING_EXCEPTION) {
+ tty->print_cr("%s", error);
+ java_lang_Throwable::print(PENDING_EXCEPTION, tty);
+ tty->cr();
+ CLEAR_PENDING_EXCEPTION;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+void PeriodicGC::start() {
+ _monitor = new Monitor(Mutex::nonleaf, "PeriodicGC::_monitor", Mutex::_allow_vm_block_flag);
+
+ EXCEPTION_MARK;
+ Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK);
+ instanceKlassHandle klass (THREAD, k);
+ instanceHandle thread_oop = klass->allocate_instance_handle(CHECK);
+
+ const char thread_name[] = "periodic gc timer";
+ Handle string = java_lang_String::create_from_str(thread_name, CHECK);
+
+ // Initialize thread_oop to put it into the system threadGroup
+ Handle thread_group (THREAD, Universe::system_thread_group());
+ JavaValue result(T_VOID);
+ JavaCalls::call_special(&result, thread_oop,
+ klass,
+ vmSymbols::object_initializer_name(),
+ vmSymbols::threadgroup_string_void_signature(),
+ thread_group,
+ string,
+ THREAD);
+ if (has_error(THREAD, "Exception in VM (PeriodicGC::start) : ")) {
+ vm_exit_during_initialization("Cannot create periodic gc timer thread.");
+ return;
+ }
+
+ KlassHandle group(THREAD, SystemDictionary::ThreadGroup_klass());
+ JavaCalls::call_special(&result,
+ thread_group,
+ group,
+ vmSymbols::add_method_name(),
+ vmSymbols::thread_void_signature(),
+ thread_oop, // ARG 1
+ THREAD);
+ if (has_error(THREAD, "Exception in VM (PeriodicGC::start) : ")) {
+ vm_exit_during_initialization("Cannot create periodic gc timer thread.");
+ return;
+ }
+
+ {
+ MutexLocker mu(Threads_lock);
+ _thread = new JavaThread(&PeriodicGC::timer_thread_entry);
+ if (_thread == NULL || _thread->osthread() == NULL) {
+ vm_exit_during_initialization("Cannot create PeriodicGC timer thread. Out of system resources.");
+ }
+
+ java_lang_Thread::set_thread(thread_oop(), _thread);
+ java_lang_Thread::set_daemon(thread_oop());
+ _thread->set_threadObj(thread_oop());
+ Threads::add(_thread);
+ Thread::start(_thread);
+ }
+}
+
+void PeriodicGC::timer_thread_entry(JavaThread* thread, TRAPS) {
+ while(!_should_terminate) {
+ assert(!SafepointSynchronize::is_at_safepoint(), "PeriodicGC timer thread is a JavaThread");
+ G1CollectedHeap::heap()->check_trigger_periodic_gc();
+
+ MutexLockerEx x(_monitor);
+ if (_should_terminate) {
+ break;
+ }
+ _monitor->wait(false /* no_safepoint_check */, 200);
+ }
+}
+
+void PeriodicGC::stop() {
+ _should_terminate = true;
+ {
+ MutexLockerEx ml(_monitor, Mutex::_no_safepoint_check_flag);
+ _monitor->notify();
+ }
+}
+
+G1UncommitThread::G1UncommitThread() :
+ ConcurrentGCThread() {
+ if (os::create_thread(this, os::cgc_thread)) {
+ int native_prio;
+ if (G1UncommitThreadPriority) {
+ native_prio = os::java_to_os_priority[CriticalPriority];
+ } else {
+ native_prio = os::java_to_os_priority[NearMaxPriority];
+ }
+ os::set_native_priority(this, native_prio);
+ if (!_should_terminate && !DisableStartThread) {
+ os::start_thread(this);
+ }
+ }
+ if (G1UncommitLog) {
+ gclog_or_tty->print_cr("Periodic GC Thread start");
+ }
+}
+
+G1UncommitThread::~G1UncommitThread() {
+ // This is here so that super is called.
+}
+
+void G1UncommitThread::run() {
+ G1CollectedHeap* heap = G1CollectedHeap::heap();
+ while (!_should_terminate) {
+ heap->_hrm.free_uncommit_list_memory();
+ os::sleep(this, G1PeriodicGCInterval / 10, false);
+ }
+ terminate();
+}
+
+void G1UncommitThread::stop() {
+ {
+ MutexLockerEx ml(Terminator_lock);
+ _should_terminate = true;
+ }
+ {
+ MutexLockerEx ml(Terminator_lock);
+ while (!_has_terminated) {
+ Terminator_lock->wait();
+ }
+ }
+}
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1UncommitThread.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1UncommitThread.hpp
new file mode 100644
index 00000000..883a9a41
--- /dev/null
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1UncommitThread.hpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2013, 2018, Red Hat, Inc. 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.
+ *
+ */
+
+#ifndef SHARE_VM_GC_G1_G1CONCURRENTTHREAD_HPP
+#define SHARE_VM_GC_G1_G1CONCURRENTTHREAD_HPP
+
+#include "gc_implementation/shared/concurrentGCThread.hpp"
+#include "gc_implementation/g1/g1CollectedHeap.hpp"
+#include "gc_implementation/g1/heapRegionSet.hpp"
+
+class PeriodicGC : AllStatic {
+private:
+ volatile static bool _should_terminate;
+ static JavaThread* _thread;
+ static Monitor* _monitor;
+
+public:
+ // Timer thread entry
+ static void timer_thread_entry(JavaThread* thread, TRAPS);
+ static void start();
+ static void stop();
+ static bool has_error(TRAPS, const char* error);
+};
+
+class G1UncommitThread: public ConcurrentGCThread {
+ friend class VMStructs;
+
+public:
+ // Constructor
+ G1UncommitThread();
+ ~G1UncommitThread();
+
+ void run();
+ void stop();
+
+ char* name() const { return (char*)"G1UncommitThread";}
+};
+
+#endif // SHARE_VM_GC_G1_G1CONCURRENTTHREAD_HPP
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp
index e24cc959..db7ddece 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp
@@ -328,7 +328,37 @@
"Verify the code root lists attached to each heap region.") \
\
develop(bool, G1VerifyBitmaps, false, \
- "Verifies the consistency of the marking bitmaps")
+ "Verifies the consistency of the marking bitmaps") \
+ \
+ product(bool, G1Uncommit, false, \
+ "Allow G1 to uncommit unused memory.") \
+ \
+ product(bool, G1UncommitLog, false, \
+ "Enable G1 uncommit logs.") \
+ \
+ manageable(uintx, G1PeriodicGCInterval, 15000, \
+ "Number of milliseconds after a previous GC to wait before " \
+ "triggering a periodic gc. A value of zero disables periodically "\
+ "enforced gc cycles.") \
+ \
+ manageable(uintx, G1PeriodicGCLoadThreshold, 10, \
+ "Percentage of process load or system load." \
+ "Above this value cancels a given periodic GC." \
+ "A value of zero disables load check.") \
+ \
+ experimental(bool, G1PeriodicGCProcessLoad, true, \
+ "if true, use process load, else use system load. which is" \
+ "the 1m value of getloadavg() / CPU core number.") \
+ \
+ experimental(bool, G1UncommitThreadPriority, false, \
+ "G1 uncommit thread runs at critical scheduling priority.") \
+ \
+ experimental(double, G1UncommitPercent, 0.1, \
+ "Percent of free regions to uncommit for one uncommit cycle.") \
+ \
+ experimental(uintx, G1UncommitDelay, 50, \
+ "Starup delay in seconds for periodic uncommit.") \
+ \
G1_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_EXPERIMENTAL_FLAG, DECLARE_NOTPRODUCT_FLAG, DECLARE_MANAGEABLE_FLAG, DECLARE_PRODUCT_RW_FLAG)
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp
index 794911ef..409399fa 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp
@@ -310,7 +310,8 @@ HeapRegion::HeapRegion(uint hrm_index,
#ifdef ASSERT
_containing_set(NULL),
#endif // ASSERT
- _young_index_in_cset(-1), _surv_rate_group(NULL), _age_index(-1),
+ _in_uncommit_list(false),
+ _young_index_in_cset(-1), _surv_rate_group(NULL), _age_index(-1),
_rem_set(NULL), _recorded_rs_length(0), _predicted_elapsed_time_ms(0),
_predicted_bytes_to_copy(0)
{
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp
index 52ef1d0d..9077381b 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp
@@ -227,6 +227,9 @@ class HeapRegion: public G1OffsetTableContigSpace {
// For the start region of a humongous sequence, it's original end().
HeapWord* _orig_end;
+ // True iff the region is in current uncommit_list.
+ bool _in_uncommit_list;
+
// True iff the region is in current collection_set.
bool _in_collection_set;
@@ -427,6 +430,8 @@ class HeapRegion: public G1OffsetTableContigSpace {
return _humongous_start_region;
}
+ void set_uncommit_list(bool in) { _in_uncommit_list = in; }
+ bool in_uncommit_list() { return _in_uncommit_list; }
// Return the number of distinct regions that are covered by this region:
// 1 if the region is not humongous, >= 1 if the region is humongous.
uint region_num() const {
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp
index 14673df7..c4e96fda 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp
@@ -53,12 +53,25 @@ void HeapRegionManager::initialize(G1RegionToSpaceMapper* heap_storage,
_available_map.resize(_regions.length(), false);
_available_map.clear();
+ _uncommit_list_filled = false;
}
bool HeapRegionManager::is_available(uint region) const {
+ HeapRegion* hr = _regions.get_by_index(region);
+ if (hr != NULL && hr->in_uncommit_list()) {
+ return false;
+ }
return _available_map.at(region);
}
+bool HeapRegionManager::can_expand(uint region) const {
+ HeapRegion* hr = _regions.get_by_index(region);
+ if (hr != NULL && hr->in_uncommit_list()) {
+ return false;
+ }
+ return !_available_map.at(region);
+}
+
#ifdef ASSERT
bool HeapRegionManager::is_free(HeapRegion* hr) const {
return _free_list.contains(hr);
@@ -77,7 +90,7 @@ void HeapRegionManager::commit_regions(uint index, size_t num_regions) {
guarantee(num_regions > 0, "Must commit more than zero regions");
guarantee(_num_committed + num_regions <= max_length(), "Cannot commit more than the maximum amount of regions");
- _num_committed += (uint)num_regions;
+ Atomic::add((int)num_regions, (volatile int*)&_num_committed);
_heap_mapper->commit_regions(index, num_regions);
@@ -103,9 +116,9 @@ void HeapRegionManager::uncommit_regions(uint start, size_t num_regions) {
}
}
- _num_committed -= (uint)num_regions;
-
+ Atomic::add(-num_regions, (volatile int*)&_num_committed);
_available_map.par_clear_range(start, start + num_regions, BitMap::unknown_range);
+
_heap_mapper->uncommit_regions(start, num_regions);
// Also uncommit auxiliary data
@@ -197,7 +210,7 @@ uint HeapRegionManager::find_contiguous(size_t num, bool empty_only) {
while (length_found < num && cur < max_length()) {
HeapRegion* hr = _regions.get_by_index(cur);
- if ((!empty_only && !is_available(cur)) || (is_available(cur) && hr != NULL && hr->is_empty())) {
+ if ((!empty_only && can_expand(cur)) || (is_available(cur) && hr != NULL && hr->is_empty())) {
// This region is a potential candidate for allocation into.
length_found++;
} else {
@@ -212,7 +225,7 @@ uint HeapRegionManager::find_contiguous(size_t num, bool empty_only) {
for (uint i = found; i < (found + num); i++) {
HeapRegion* hr = _regions.get_by_index(i);
// sanity check
- guarantee((!empty_only && !is_available(i)) || (is_available(i) && hr != NULL && hr->is_empty()),
+ guarantee((!empty_only && can_expand(i)) || (is_available(i) && hr != NULL && hr->is_empty()),
err_msg("Found region sequence starting at " UINT32_FORMAT ", length " SIZE_FORMAT
" that is not empty at " UINT32_FORMAT ". Hr is " PTR_FORMAT, found, num, i, p2i(hr)));
}
@@ -238,7 +251,8 @@ void HeapRegionManager::iterate(HeapRegionClosure* blk) const {
uint len = max_length();
for (uint i = 0; i < len; i++) {
- if (!is_available(i)) {
+ HeapRegion* r = _regions.get_by_index(i);
+ if (r != NULL && r->in_uncommit_list() || !_available_map.at(i)) {
continue;
}
guarantee(at(i) != NULL, err_msg("Tried to access region %u that has a NULL HeapRegion*", i));
@@ -264,15 +278,15 @@ uint HeapRegionManager::find_unavailable_from_idx(uint start_idx, uint* res_idx)
return num_regions;
}
*res_idx = cur;
- while (cur < max_length() && !is_available(cur)) {
+ while (cur < max_length() && can_expand(cur)) {
cur++;
}
num_regions = cur - *res_idx;
#ifdef ASSERT
for (uint i = *res_idx; i < (*res_idx + num_regions); i++) {
- assert(!is_available(i), "just checking");
+ assert(can_expand(i), "just checking");
}
- assert(cur == max_length() || num_regions == 0 || is_available(cur),
+ assert(cur == max_length() || num_regions == 0 || (!G1Uncommit && is_available(cur)) || G1Uncommit,
err_msg("The region at the current position %u must be available or at the end of the heap.", cur));
#endif
return num_regions;
@@ -293,10 +307,10 @@ void HeapRegionManager::par_iterate(HeapRegionClosure* blk, uint worker_id, uint
const uint index = (start_index + count) % _allocated_heapregions_length;
assert(0 <= index && index < _allocated_heapregions_length, "sanity");
// Skip over unavailable regions
- if (!is_available(index)) {
+ HeapRegion* r = _regions.get_by_index(index);
+ if (r != NULL && r->in_uncommit_list() || !_available_map.at(index)) {
continue;
}
- HeapRegion* r = _regions.get_by_index(index);
// We'll ignore "continues humongous" regions (we'll process them
// when we come across their corresponding "start humongous"
// region) and regions already claimed.
@@ -424,12 +438,12 @@ void HeapRegionManager::verify() {
uint num_committed = 0;
HeapWord* prev_end = heap_bottom();
for (uint i = 0; i < _allocated_heapregions_length; i++) {
- if (!is_available(i)) {
+ HeapRegion* hr = _regions.get_by_index(i);
+ if (hr != NULL && hr->in_uncommit_list() || !_available_map.at(i)) {
prev_committed = false;
continue;
}
num_committed++;
- HeapRegion* hr = _regions.get_by_index(i);
guarantee(hr != NULL, err_msg("invariant: i: %u", i));
guarantee(!prev_committed || hr->bottom() == prev_end,
err_msg("invariant i: %u " HR_FORMAT " prev_end: " PTR_FORMAT,
@@ -453,10 +467,38 @@ void HeapRegionManager::verify() {
guarantee(_regions.get_by_index(i) == NULL, err_msg("invariant i: %u", i));
}
- guarantee(num_committed == _num_committed, err_msg("Found %u committed regions, but should be %u", num_committed, _num_committed));
+ guarantee((!G1Uncommit && num_committed == _num_committed) || G1Uncommit, err_msg("Found %u committed regions, but should be %u", num_committed, _num_committed));
_free_list.verify();
}
+void HeapRegionManager::free_uncommit_list_memory() {
+ if (_uncommit_list_filled) {
+ _uncommit_list.remove_all(true);
+ OrderAccess::storestore();
+ _uncommit_list_filled = false;
+ }
+}
+
+uint HeapRegionManager::extract_uncommit_list()
+{
+ assert_at_safepoint(true /* should_be_vm_thread */);
+ if (!_uncommit_list_filled) {
+ G1CollectedHeap* g1h = G1CollectedHeap::heap();
+ uint dest = ((G1CollectorPolicy*)g1h->collector_policy())->predict_heap_size_seq();
+
+ if (dest < _num_committed) {
+ uint num_regions_to_remove = (_num_committed - dest) * G1UncommitPercent;
+ if (num_regions_to_remove >= 1 && num_regions_to_remove < _free_list.length()) {
+ int count = _free_list.move_regions_to(&_uncommit_list, num_regions_to_remove);
+ OrderAccess::storestore();
+ _uncommit_list_filled = true;
+ return count;
+ }
+ }
+ }
+ return 0;
+}
+
#ifndef PRODUCT
void HeapRegionManager::verify_optional() {
verify();
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.hpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.hpp
index 83996f71..71512218 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.hpp
@@ -67,6 +67,7 @@ class G1HeapRegionTable : public G1BiasedMappedArray<HeapRegion*> {
class HeapRegionManager: public CHeapObj<mtGC> {
friend class VMStructs;
+ friend class FreeRegionList;
G1HeapRegionTable _regions;
@@ -78,6 +79,8 @@ class HeapRegionManager: public CHeapObj<mtGC> {
G1RegionToSpaceMapper* _card_counts_mapper;
FreeRegionList _free_list;
+ FreeRegionList _uncommit_list;
+ bool _uncommit_list_filled;
// Each bit in this bitmap indicates that the corresponding region is available
// for allocation.
@@ -123,17 +126,23 @@ class HeapRegionManager: public CHeapObj<mtGC> {
public:
bool is_free(HeapRegion* hr) const;
#endif
- // Returns whether the given region is available for allocation.
- bool is_available(uint region) const;
+
+ // Returns whether the given region is not available and can be expanded.
+ bool can_expand(uint region) const;
public:
// Empty constructor, we'll initialize it with the initialize() method.
HeapRegionManager() : _regions(), _heap_mapper(NULL), _num_committed(0),
_next_bitmap_mapper(NULL), _prev_bitmap_mapper(NULL), _bot_mapper(NULL),
_allocated_heapregions_length(0), _available_map(),
- _free_list("Free list", new MasterFreeRegionListMtSafeChecker())
+ _free_list("Free list", new MasterFreeRegionListMtSafeChecker()),
+ _uncommit_list("Uncommit list", NULL)
{ }
+ // Returns whether the given region is available for allocation.
+ // !is_available is not allowed
+ bool is_available(uint region) const;
+
void initialize(G1RegionToSpaceMapper* heap_storage,
G1RegionToSpaceMapper* prev_bitmap,
G1RegionToSpaceMapper* next_bitmap,
@@ -141,6 +150,9 @@ public:
G1RegionToSpaceMapper* cardtable,
G1RegionToSpaceMapper* card_counts);
+ uint extract_uncommit_list();
+ void free_uncommit_list_memory();
+
// Return the "dummy" region used for G1AllocRegion. This is currently a hardwired
// new HeapRegion that owns HeapRegion at index 0. Since at the moment we commit
// the heap from the lowest address, this region (and its associated data
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionSet.cpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionSet.cpp
index 213380e7..09d12fd3 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionSet.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionSet.cpp
@@ -109,10 +109,11 @@ void FreeRegionList::fill_in_ext_msg_extra(hrs_ext_msg* msg) {
msg->append(" hd: " PTR_FORMAT " tl: " PTR_FORMAT, _head, _tail);
}
-void FreeRegionList::remove_all() {
+void FreeRegionList::remove_all(bool uncommit) {
check_mt_safety();
verify_optional();
+ G1CollectedHeap* g1h = G1CollectedHeap::heap();
HeapRegion* curr = _head;
while (curr != NULL) {
verify_region(curr);
@@ -121,6 +122,11 @@ void FreeRegionList::remove_all() {
curr->set_next(NULL);
curr->set_prev(NULL);
curr->set_containing_set(NULL);
+ if (uncommit) {
+ g1h->_hrm.uncommit_regions(curr->hrm_index(), 1);
+ OrderAccess::storestore();
+ curr->set_uncommit_list(false);
+ }
curr = next;
}
clear();
@@ -328,6 +334,48 @@ void FreeRegionList::verify_list() {
name(), total_capacity_bytes(), capacity));
}
+uint FreeRegionList::move_regions_to(FreeRegionList* dest, uint num_regions) {
+ check_mt_safety();
+ assert(num_regions >= 1, hrs_ext_msg(this, "pre-condition"));
+ assert(num_regions < length(), hrs_ext_msg(this, "pre-condition"));
+ assert(dest != NULL && dest->is_empty(), hrs_ext_msg(dest, "pre-condition"));
+
+ verify_optional();
+ DEBUG_ONLY(uint old_length = length();)
+ HeapRegion* curr = _tail;
+ uint count = 0;
+ size_t capacity = 0;
+
+ while (count < num_regions) {
+ if (curr->hrm_index() <= InitialHeapSize / HeapRegion::GrainBytes) {
+ break;
+ }
+ if (_last == curr) {
+ _last = NULL;
+ }
+ curr->set_containing_set(NULL);
+ curr->set_containing_set(dest);
+ curr->set_uncommit_list(true);
+ count++;
+ capacity += curr->capacity();
+ curr = curr->prev();
+ assert(curr != NULL, hrs_ext_msg(this, "invariant"));
+ }
+ if (count != 0) {
+ dest->_tail = _tail;
+ dest->_head = curr->next();
+ dest->_head->set_prev(NULL);
+ dest->_count.increment(count, capacity);
+ dest->verify_optional();
+
+ _count.decrement(count, capacity);
+ _tail = curr;
+ _tail->set_next(NULL);
+ verify_optional();
+ }
+ return count;
+}
+
// Note on the check_mt_safety() methods below:
//
// Verification of the "master" heap region sets / lists that are
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionSet.hpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionSet.hpp
index 9a9267c4..ede3136d 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionSet.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionSet.hpp
@@ -249,13 +249,15 @@ public:
void add_ordered(FreeRegionList* from_list);
// It empties the list by removing all regions from it.
- void remove_all();
+ void remove_all(bool uncommit = false);
// Remove all (contiguous) regions from first to first + num_regions -1 from
// this list.
// Num_regions must be > 1.
void remove_starting_at(HeapRegion* first, uint num_regions);
+ uint move_regions_to(FreeRegionList* dest, uint num_regions);
+
virtual void verify();
virtual void print_on(outputStream* out, bool print_contents = false);
diff --git a/hotspot/src/share/vm/gc_interface/gcCause.cpp b/hotspot/src/share/vm/gc_interface/gcCause.cpp
index bdac7cb0..283df9bf 100644
--- a/hotspot/src/share/vm/gc_interface/gcCause.cpp
+++ b/hotspot/src/share/vm/gc_interface/gcCause.cpp
@@ -100,6 +100,9 @@ const char* GCCause::to_string(GCCause::Cause cause) {
case _g1_humongous_allocation:
return "G1 Humongous Allocation";
+ case _g1_periodic_collection:
+ return "G1 Periodic Collection";
+
case _last_ditch_collection:
return "Last ditch collection";
diff --git a/hotspot/src/share/vm/gc_interface/gcCause.hpp b/hotspot/src/share/vm/gc_interface/gcCause.hpp
index 29408d77..5be14548 100644
--- a/hotspot/src/share/vm/gc_interface/gcCause.hpp
+++ b/hotspot/src/share/vm/gc_interface/gcCause.hpp
@@ -72,6 +72,7 @@ class GCCause : public AllStatic {
_g1_inc_collection_pause,
_g1_humongous_allocation,
+ _g1_periodic_collection,
_last_ditch_collection,
_last_gc_cause
diff --git a/hotspot/src/share/vm/prims/jvm.cpp b/hotspot/src/share/vm/prims/jvm.cpp
index de01fefd..e149ca64 100644
--- a/hotspot/src/share/vm/prims/jvm.cpp
+++ b/hotspot/src/share/vm/prims/jvm.cpp
@@ -3286,6 +3286,23 @@ JVM_ENTRY(void, JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio))
}
JVM_END
+JVM_ENTRY(void, JVM_AdaptiveHeapSetG1PeriodicGCInterval(JNIEnv *env, jclass klass, jint interval))
+ JVMWrapper("JVM_AdaptiveHeapSetG1PeriodicGCInterval");
+ G1PeriodicGCInterval = interval;
+JVM_END
+JVM_ENTRY(jint, JVM_AdaptiveHeapGetG1PeriodicGCInterval(JNIEnv *env, jclass klass))
+ JVMWrapper("JVM_AdaptiveHeapGetG1PeriodicGCInterval");
+ return G1PeriodicGCInterval;
+JVM_END
+
+JVM_ENTRY(void, JVM_AdaptiveHeapSetG1PeriodicGCLoadThreshold(JNIEnv *env, jclass clazz, jint loadThreshold))
+ JVMWrapper("JVM_AdaptiveHeapSetG1PeriodicGCLoadThreshold");
+ G1PeriodicGCLoadThreshold = loadThreshold;
+JVM_END
+JVM_ENTRY(jint, JVM_AdaptiveHeapGetG1PeriodicGCLoadThreshold(JNIEnv *env, jclass clazz))
+ JVMWrapper("JVM_AdaptiveHeapgetG1PeriodicGCLoadThreshold");
+ return G1PeriodicGCLoadThreshold;
+JVM_END
JVM_ENTRY(void, JVM_Yield(JNIEnv *env, jclass threadClass))
JVMWrapper("JVM_Yield");
diff --git a/hotspot/src/share/vm/prims/jvm.h b/hotspot/src/share/vm/prims/jvm.h
index 198c52dc..0c0d44a0 100644
--- a/hotspot/src/share/vm/prims/jvm.h
+++ b/hotspot/src/share/vm/prims/jvm.h
@@ -1586,6 +1586,20 @@ JVM_GetResourceLookupCacheURLs(JNIEnv *env, jobject loader);
JNIEXPORT jintArray JNICALL
JVM_GetResourceLookupCache(JNIEnv *env, jobject loader, const char *resource_name);
+/*
+ *com.huawei.management.AdaptiveHeapMXBeanImpl
+ */
+JNIEXPORT void JNICALL
+JVM_AdaptiveHeapSetG1PeriodicGCInterval(JNIEnv *env, jclass klass, jint interval);
+JNIEXPORT jint JNICALL
+JVM_AdaptiveHeapGetG1PeriodicGCInterval(JNIEnv *env, jclass klass);
+
+
+JNIEXPORT void JNICALL
+JVM_AdaptiveHeapSetG1PeriodicGCLoadThreshold(JNIEnv *env, jclass clazz, jint loadThreshold);
+JNIEXPORT jint JNICALL
+JVM_AdaptiveHeapGetG1PeriodicGCLoadThreshold(JNIEnv *env, jclass clazz);
+
/* =========================================================================
* The following defines a private JVM interface that the JDK can query
diff --git a/hotspot/src/share/vm/runtime/os.hpp b/hotspot/src/share/vm/runtime/os.hpp
index ab3148e3..cff2e9c3 100644
--- a/hotspot/src/share/vm/runtime/os.hpp
+++ b/hotspot/src/share/vm/runtime/os.hpp
@@ -823,6 +823,9 @@ class os: AllStatic {
// System loadavg support. Returns -1 if load average cannot be obtained.
static int loadavg(double loadavg[], int nelem);
+ // Process loadavg support. Returns -1 if load average cannot be obtained.
+ static double get_process_load();
+
// Hook for os specific jvm options that we don't want to abort on seeing
static bool obsolete_option(const JavaVMOption *option);
diff --git a/hotspot/src/share/vm/runtime/thread.cpp b/hotspot/src/share/vm/runtime/thread.cpp
index 3db27350..7374eee5 100644
--- a/hotspot/src/share/vm/runtime/thread.cpp
+++ b/hotspot/src/share/vm/runtime/thread.cpp
@@ -99,6 +99,7 @@
#if INCLUDE_ALL_GCS
#include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
#include "gc_implementation/g1/concurrentMarkThread.inline.hpp"
+#include "gc_implementation/g1/g1CollectedHeap.hpp"
#include "gc_implementation/parallelScavenge/pcTasks.hpp"
#endif // INCLUDE_ALL_GCS
#ifdef COMPILER1
@@ -3677,6 +3678,7 @@ jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) {
ConcurrentMarkSweepThread::makeSurrogateLockerThread(THREAD);
} else {
ConcurrentMarkThread::makeSurrogateLockerThread(THREAD);
+ G1CollectedHeap::heap()->init_periodic_gc_thread();
}
if (HAS_PENDING_EXCEPTION) {
vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
diff --git a/jdk/make/CreateJars.gmk b/jdk/make/CreateJars.gmk
index 6e484369..559a62b6 100644
--- a/jdk/make/CreateJars.gmk
+++ b/jdk/make/CreateJars.gmk
@@ -555,7 +555,9 @@ EXCLUDE_PROPWARN_PKGS = com.sun.java.swing.plaf.windows \
# with a new module system (being discussed for JDK 8).
#
EXPORTED_PRIVATE_PKGS = com.oracle.net \
- com.oracle.nio
+ com.oracle.nio \
+ com.huawei.management \
+ com.huawei.jvm.gc
$(IMAGES_OUTPUTDIR)/symbols/_the.symbols: $(IMAGES_OUTPUTDIR)/lib/rt.jar
$(RM) -r $(IMAGES_OUTPUTDIR)/symbols/META-INF/sym
diff --git a/jdk/make/data/classlist/classlist.linux b/jdk/make/data/classlist/classlist.linux
index 2a3915c0..737aefe2 100644
--- a/jdk/make/data/classlist/classlist.linux
+++ b/jdk/make/data/classlist/classlist.linux
@@ -2556,4 +2556,5 @@ javax/swing/plaf/basic/BasicToolBarSeparatorUI
java/awt/event/AdjustmentEvent
java/awt/MenuBar
sun/awt/X11/XErrorEvent
+com/huawei/jvm/gc
# eea35d9d56e0006e
diff --git a/jdk/make/lib/CoreLibraries.gmk b/jdk/make/lib/CoreLibraries.gmk
index 75886a62..ea03025f 100644
--- a/jdk/make/lib/CoreLibraries.gmk
+++ b/jdk/make/lib/CoreLibraries.gmk
@@ -143,6 +143,7 @@ LIBJAVA_SRC_DIRS += $(JDK_TOPDIR)/src/$(OPENJDK_TARGET_OS_API_DIR)/native/java/l
$(JDK_TOPDIR)/src/share/native/common \
$(JDK_TOPDIR)/src/share/native/sun/misc \
$(JDK_TOPDIR)/src/share/native/sun/reflect \
+ $(JDK_TOPDIR)/src/share/native/com/huawei/jvm/gc \
$(JDK_TOPDIR)/src/share/native/java/util \
$(JDK_TOPDIR)/src/share/native/java/util/concurrent/atomic \
$(JDK_TOPDIR)/src/$(OPENJDK_TARGET_OS_API_DIR)/native/common \
diff --git a/jdk/make/mapfiles/libjava/mapfile-linux b/jdk/make/mapfiles/libjava/mapfile-linux
index 509279ca..52959f78 100644
--- a/jdk/make/mapfiles/libjava/mapfile-linux
+++ b/jdk/make/mapfiles/libjava/mapfile-linux
@@ -215,6 +215,7 @@ SUNWprivate_1.1 {
Java_java_lang_System_setErr0;
Java_java_lang_System_setIn0;
Java_java_lang_System_setOut0;
+ Java_com_huawei_jvm_gc_AdaptiveHeapMXBeanImpl_registerNatives;
Java_java_lang_Thread_registerNatives;
Java_java_lang_Throwable_fillInStackTrace;
Java_java_lang_Throwable_getStackTraceDepth;
diff --git a/jdk/make/mapfiles/libjava/mapfile-vers b/jdk/make/mapfiles/libjava/mapfile-vers
index 24454049..58801c19 100644
--- a/jdk/make/mapfiles/libjava/mapfile-vers
+++ b/jdk/make/mapfiles/libjava/mapfile-vers
@@ -215,6 +215,7 @@ SUNWprivate_1.1 {
Java_java_lang_System_setErr0;
Java_java_lang_System_setIn0;
Java_java_lang_System_setOut0;
+ Java_com_huawei_jvm_gc_AdaptiveHeapMXBeanImpl_registerNatives;
Java_java_lang_Thread_registerNatives;
Java_java_lang_Throwable_fillInStackTrace;
Java_java_lang_Throwable_getStackTraceDepth;
diff --git a/jdk/make/mapfiles/libjava/reorder-sparc b/jdk/make/mapfiles/libjava/reorder-sparc
index 96f8e735..95793a5b 100644
--- a/jdk/make/mapfiles/libjava/reorder-sparc
+++ b/jdk/make/mapfiles/libjava/reorder-sparc
@@ -104,3 +104,4 @@ text: .text%Java_java_util_TimeZone_getSystemTimeZoneID;
text: .text%findJavaTZ_md;
text: .text%Java_java_lang_StrictMath_log;
text: .text%Java_java_lang_StrictMath_sqrt;
+text: .text%Java_com_huawei_jvm_gc_AdaptiveHeapMXBeanImpl_registerNatives;
diff --git a/jdk/make/mapfiles/libjava/reorder-x86 b/jdk/make/mapfiles/libjava/reorder-x86
index e0566b32..5b7a7ee1 100644
--- a/jdk/make/mapfiles/libjava/reorder-x86
+++ b/jdk/make/mapfiles/libjava/reorder-x86
@@ -10,6 +10,7 @@ text: .text%collapse: OUTPUTDIR/canonicalize_md.o;
text: .text%Java_java_lang_Object_registerNatives;
text: .text%Java_java_lang_System_registerNatives;
text: .text%Java_java_lang_Thread_registerNatives;
+text: .text%Java_com_huawei_jvm_gc_AdaptiveHeapMXBeanImpl_registerNatives;
text: .text%Java_java_security_AccessController_getStackAccessControlContext;
text: .text%Java_java_security_AccessController_getInheritedAccessControlContext;
text: .text%Java_java_lang_ClassLoader_registerNatives;
diff --git a/jdk/src/share/classes/com/huawei/jvm/gc/AdaptiveHeapMXBeanImpl.java b/jdk/src/share/classes/com/huawei/jvm/gc/AdaptiveHeapMXBeanImpl.java
new file mode 100644
index 00000000..c23dd231
--- /dev/null
+++ b/jdk/src/share/classes/com/huawei/jvm/gc/AdaptiveHeapMXBeanImpl.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2020, 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 com.huawei.jvm.gc;
+import com.huawei.management.AdaptiveHeapMXBean;
+import sun.management.Util;
+import javax.management.ObjectName;
+
+public class AdaptiveHeapMXBeanImpl implements AdaptiveHeapMXBean {
+ private static native void registerNatives();
+
+ static {
+ registerNatives();
+ }
+
+ private final static String ADAPTIVE_HEAP_MXBEAN_NAME = "com.huawei.management:type=AdaptiveHeap";
+ @Override
+ public void setG1PeriodicGCInterval(int interval) {
+ setG1PeriodicGCIntervalImpl(interval);
+ }
+ @Override
+ public void setG1PeriodicGCLoadThreshold(int loadThreshold) {
+ setG1PeriodicGCLoadThresholdImpl(loadThreshold);
+ }
+ @Override
+ public int getG1PeriodicGCInterval() {
+ return getG1PeriodicGCIntervalImpl();
+ }
+ @Override
+ public int getG1PeriodicGCLoadThreshold() {
+ return getG1PeriodicGCLoadThresholdImpl();
+ }
+ @Override
+ public ObjectName getObjectName() {
+ return Util.newObjectName(ADAPTIVE_HEAP_MXBEAN_NAME);
+ }
+
+
+ private static native void setG1PeriodicGCIntervalImpl(int interval);
+ private static native void setG1PeriodicGCLoadThresholdImpl(int loadThreshold);
+ private static native int getG1PeriodicGCIntervalImpl();
+ private static native int getG1PeriodicGCLoadThresholdImpl();
+}
diff --git a/jdk/src/share/classes/com/huawei/management/AdaptiveHeapMXBean.java b/jdk/src/share/classes/com/huawei/management/AdaptiveHeapMXBean.java
new file mode 100644
index 00000000..a8cce6eb
--- /dev/null
+++ b/jdk/src/share/classes/com/huawei/management/AdaptiveHeapMXBean.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2020, 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 com.huawei.management;
+
+import java.lang.management.PlatformManagedObject;
+import java.util.List;
+public interface AdaptiveHeapMXBean extends PlatformManagedObject {
+ void setG1PeriodicGCInterval(int interval);
+ void setG1PeriodicGCLoadThreshold(int loadThreshold);
+ int getG1PeriodicGCInterval();
+ int getG1PeriodicGCLoadThreshold();
+}
diff --git a/jdk/src/share/classes/java/lang/management/PlatformComponent.java b/jdk/src/share/classes/java/lang/management/PlatformComponent.java
index 0c67543e..afc48d24 100644
--- a/jdk/src/share/classes/java/lang/management/PlatformComponent.java
+++ b/jdk/src/share/classes/java/lang/management/PlatformComponent.java
@@ -37,6 +37,7 @@ import javax.management.ObjectName;
import com.sun.management.HotSpotDiagnosticMXBean;
import com.sun.management.UnixOperatingSystemMXBean;
+import com.huawei.management.AdaptiveHeapMXBean;
import sun.management.ManagementFactoryHelper;
import sun.management.Util;
@@ -270,9 +271,20 @@ enum PlatformComponent {
public List<HotSpotDiagnosticMXBean> getMXBeans() {
return Collections.singletonList(ManagementFactoryHelper.getDiagnosticMXBean());
}
+ }),
+ /**
+ * ADAPTIVE Heap.
+ */
+ ADAPTIVE_HEAP(
+ "com.huawei.management.AdaptiveHeapMXBean",
+ "com.huawei.management", "AdaptiveHeap", defaultKeyProperties(),
+ true,
+ new MXBeanFetcher<AdaptiveHeapMXBean>() {
+ public List<AdaptiveHeapMXBean> getMXBeans() {
+ return Collections.singletonList(ManagementFactoryHelper.getAdaptiveHeapMXBean());
+ }
});
-
/**
* A task that returns the MXBeans for a component.
*/
diff --git a/jdk/src/share/classes/sun/management/ManagementFactoryHelper.java b/jdk/src/share/classes/sun/management/ManagementFactoryHelper.java
index be82ddae..d5df523e 100644
--- a/jdk/src/share/classes/sun/management/ManagementFactoryHelper.java
+++ b/jdk/src/share/classes/sun/management/ManagementFactoryHelper.java
@@ -48,6 +48,9 @@ import java.util.List;
import com.sun.management.DiagnosticCommandMBean;
import com.sun.management.HotSpotDiagnosticMXBean;
+import com.huawei.management.AdaptiveHeapMXBean;
+import com.huawei.jvm.gc.AdaptiveHeapMXBeanImpl;
+
import static java.lang.management.ManagementFactory.*;
/**
@@ -65,6 +68,7 @@ public class ManagementFactoryHelper {
private static RuntimeImpl runtimeMBean = null;
private static CompilationImpl compileMBean = null;
private static OperatingSystemImpl osMBean = null;
+ private static AdaptiveHeapMXBeanImpl adaptiveHeapMXBean = null;
public static synchronized ClassLoadingMXBean getClassLoadingMXBean() {
if (classMBean == null) {
@@ -108,6 +112,13 @@ public class ManagementFactoryHelper {
return osMBean;
}
+ public static synchronized AdaptiveHeapMXBean getAdaptiveHeapMXBean() {
+ if (adaptiveHeapMXBean == null) {
+ adaptiveHeapMXBean = new AdaptiveHeapMXBeanImpl();
+ }
+ return adaptiveHeapMXBean;
+ }
+
public static List<MemoryPoolMXBean> getMemoryPoolMXBeans() {
MemoryPoolMXBean[] pools = MemoryImpl.getMemoryPools();
List<MemoryPoolMXBean> list = new ArrayList<>(pools.length);
diff --git a/jdk/src/share/javavm/export/jvm.h b/jdk/src/share/javavm/export/jvm.h
index 6e64cb0d..9eafbbb8 100644
--- a/jdk/src/share/javavm/export/jvm.h
+++ b/jdk/src/share/javavm/export/jvm.h
@@ -1430,6 +1430,21 @@ JNIEXPORT jintArray JNICALL
JVM_GetResourceLookupCache(JNIEnv *env, jobject loader, const char *resource_name);
+/*
+ *com.huawei.management.AdaptiveHeapMXBeanImpl
+ */
+JNIEXPORT void JNICALL
+JVM_AdaptiveHeapSetG1PeriodicGCInterval(JNIEnv *env, jclass klass, jint interval);
+JNIEXPORT jint JNICALL
+JVM_AdaptiveHeapGetG1PeriodicGCInterval(JNIEnv *env, jclass klass);
+
+
+JNIEXPORT void JNICALL
+JVM_AdaptiveHeapSetG1PeriodicGCLoadThreshold(JNIEnv *env, jclass clazz, jint loadThreshold);
+JNIEXPORT jint JNICALL
+JVM_AdaptiveHeapGetG1PeriodicGCLoadThreshold(JNIEnv *env, jclass clazz);
+
+
/* =========================================================================
* The following defines a private JVM interface that the JDK can query
* for the JVM version and capabilities. sun.misc.Version defines
diff --git a/jdk/src/share/native/com/huawei/jvm/gc/AdaptiveHeapMXBeanImpl.c b/jdk/src/share/native/com/huawei/jvm/gc/AdaptiveHeapMXBeanImpl.c
new file mode 100644
index 00000000..7647daaa
--- /dev/null
+++ b/jdk/src/share/native/com/huawei/jvm/gc/AdaptiveHeapMXBeanImpl.c
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020, 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. Alibaba designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+#include "jni.h"
+#include "jvm.h"
+#include "com_huawei_jvm_gc_AdaptiveHeapMXBeanImpl.h"
+
+#define ARRAY_LENGTH(a) (sizeof(a)/sizeof(a[0]))
+
+static JNINativeMethod methods[] = {
+ {"setG1PeriodicGCIntervalImpl", "(I)V", (void *)&JVM_AdaptiveHeapSetG1PeriodicGCInterval},
+ {"getG1PeriodicGCIntervalImpl", "()I", (void *)&JVM_AdaptiveHeapGetG1PeriodicGCInterval},
+ {"setG1PeriodicGCLoadThresholdImpl", "(I)V", (void *)&JVM_AdaptiveHeapSetG1PeriodicGCLoadThreshold},
+ {"getG1PeriodicGCLoadThresholdImpl", "()I", (void *)&JVM_AdaptiveHeapGetG1PeriodicGCLoadThreshold},
+
+};
+
+JNIEXPORT void JNICALL
+Java_com_huawei_jvm_gc_AdaptiveHeapMXBeanImpl_registerNatives(JNIEnv *env, jclass cls)
+{
+ (*env)->RegisterNatives(env, cls, methods, ARRAY_LENGTH(methods));
+}
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。