/*
* (non-Javadoc)
*
* @see com.orientechnologies.common.test.SpeedTest#startTimer(java.lang.String)
*/
public void startTimer(final String iName) {
Runtime.getRuntime().runFinalization();
Runtime.getRuntime().gc();
try {
Thread.sleep(TIME_WAIT);
} catch (InterruptedException e) {
}
final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
final MemoryUsage heapMemoryUsage = memoryMXBean.getHeapMemoryUsage();
final MemoryUsage nonHeapMemoryUsage = memoryMXBean.getNonHeapMemoryUsage();
currentTestName = iName;
currentTestHeapCommittedMemory = heapMemoryUsage.getCommitted();
currentTestHeapUsedMemory = heapMemoryUsage.getUsed();
currentTestHeapMaxMemory = heapMemoryUsage.getMax();
currentTestNonHeapCommittedMemory = nonHeapMemoryUsage.getCommitted();
currentTestNonHeapUsedMemory = nonHeapMemoryUsage.getUsed();
currentTestNonHeapMaxMemory = nonHeapMemoryUsage.getMax();
System.out.println("-> Started the test of '" + currentTestName + "' (" + cycles + " cycles)");
currentTestTimer = System.currentTimeMillis();
}
private void createRuntimeProps(MemberStateImpl memberState) {
Runtime runtime = Runtime.getRuntime();
ThreadMXBean threadMxBean = ManagementFactory.getThreadMXBean();
RuntimeMXBean runtimeMxBean = ManagementFactory.getRuntimeMXBean();
ClassLoadingMXBean clMxBean = ManagementFactory.getClassLoadingMXBean();
MemoryMXBean memoryMxBean = ManagementFactory.getMemoryMXBean();
MemoryUsage heapMemory = memoryMxBean.getHeapMemoryUsage();
MemoryUsage nonHeapMemory = memoryMxBean.getNonHeapMemoryUsage();
Map<String, Long> map = new HashMap<String, Long>();
map.put(
"runtime.availableProcessors", Integer.valueOf(runtime.availableProcessors()).longValue());
map.put("date.startTime", runtimeMxBean.getStartTime());
map.put("seconds.upTime", runtimeMxBean.getUptime());
map.put("memory.maxMemory", runtime.maxMemory());
map.put("memory.freeMemory", runtime.freeMemory());
map.put("memory.totalMemory", runtime.totalMemory());
map.put("memory.heapMemoryMax", heapMemory.getMax());
map.put("memory.heapMemoryUsed", heapMemory.getUsed());
map.put("memory.nonHeapMemoryMax", nonHeapMemory.getMax());
map.put("memory.nonHeapMemoryUsed", nonHeapMemory.getUsed());
map.put("runtime.totalLoadedClassCount", clMxBean.getTotalLoadedClassCount());
map.put(
"runtime.loadedClassCount", Integer.valueOf(clMxBean.getLoadedClassCount()).longValue());
map.put("runtime.unloadedClassCount", clMxBean.getUnloadedClassCount());
map.put("runtime.totalStartedThreadCount", threadMxBean.getTotalStartedThreadCount());
map.put("runtime.threadCount", Integer.valueOf(threadMxBean.getThreadCount()).longValue());
map.put(
"runtime.peakThreadCount", Integer.valueOf(threadMxBean.getPeakThreadCount()).longValue());
map.put(
"runtime.daemonThreadCount",
Integer.valueOf(threadMxBean.getDaemonThreadCount()).longValue());
memberState.setRuntimeProps(map);
}
public static void main(String args[]) {
MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
MemoryUsage heapMemoryUsage = memoryMXBean.getHeapMemoryUsage();
long init = heapMemoryUsage.getInit();
long used = heapMemoryUsage.getUsed();
long max = heapMemoryUsage.getMax();
long committed = heapMemoryUsage.getCommitted();
long free = max - used;
int usedPercent = (int) (used / max);
int freePercent = (int) (usedPercent / max);
MemoryUsage nonHeapMemoryUsage = memoryMXBean.getNonHeapMemoryUsage();
List<GarbageCollectorMXBean> garbageCollectorMXBeans =
ManagementFactory.getGarbageCollectorMXBeans();
List<MemoryPoolMXBean> memoryPoolMXBeans = ManagementFactory.getMemoryPoolMXBeans();
com.sun.management.OperatingSystemMXBean operatingSystemMXBean =
(com.sun.management.OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
long commitVirtual = operatingSystemMXBean.getCommittedVirtualMemorySize();
println(init, used, max, committed);
println(commitVirtual);
}
private void doMemoryUpdates() {
MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
MemoryUsage memNonHeap = memoryMXBean.getNonHeapMemoryUsage();
MemoryUsage memHeap = memoryMXBean.getHeapMemoryUsage();
metrics.setMetric("memNonHeapUsedM", memNonHeap.getUsed() / M);
metrics.setMetric("memNonHeapCommittedM", memNonHeap.getCommitted() / M);
metrics.setMetric("memHeapUsedM", memHeap.getUsed() / M);
metrics.setMetric("memHeapCommittedM", memHeap.getCommitted() / M);
}
@Override
public void testRunStarted(final Description description) throws Exception {
if (!HybrisJUnit4Test.intenseChecksActivated()) {
return;
}
currentTestClass = description.getDisplayName();
heapAtTestStart = memoryBean.getHeapMemoryUsage();
nonHeapAtTestStart = memoryBean.getNonHeapMemoryUsage();
}
public static JSONObject loadMemoryInfo(String app) {
try {
MemoryMXBean mBean = JMConnManager.getMemoryMBean(app);
MemoryUsage nonHeap = mBean.getNonHeapMemoryUsage();
MemoryUsage heap = mBean.getHeapMemoryUsage();
JSONObject map = new JSONObject(true);
buildMemoryJSon(heap, "heap", map);
buildMemoryJSon(nonHeap, "nonheap", map);
JSONObject heapChild = new JSONObject();
JSONObject nonheapChild = new JSONObject();
JSONObject heapUsed = new JSONObject();
JSONObject heapMax = new JSONObject();
heapUsed.put("used", heap.getUsed());
heapMax.put("used", heap.getCommitted());
heapChild.put("HeapUsed", heapUsed);
heapChild.put("HeapCommit", heapMax);
JSONObject nonheapUsed = new JSONObject();
JSONObject noheapMax = new JSONObject();
nonheapUsed.put("used", nonHeap.getUsed());
noheapMax.put("used", nonHeap.getCommitted());
nonheapChild.put("NonheapUsed", nonheapUsed);
nonheapChild.put("NonheapCommit", noheapMax);
ObjectName obj = new ObjectName("java.lang:type=MemoryPool,*");
MBeanServerConnection conn = JMConnManager.getConn(app);
Set<ObjectInstance> MBeanset = conn.queryMBeans(obj, null);
for (ObjectInstance objx : MBeanset) {
String name = objx.getObjectName().getCanonicalName();
String keyName = objx.getObjectName().getKeyProperty("name");
MemoryPoolMXBean bean = JMConnManager.getServer(app, name, MemoryPoolMXBean.class);
JSONObject item = toJson(bean.getUsage());
if (JMConnManager.HEAP_ITEM.contains(keyName)) {
heapChild.put(keyName, item);
} else {
nonheapChild.put(keyName, item);
}
}
map.getJSONObject("heap").put("childs", heapChild);
map.getJSONObject("nonheap").put("childs", nonheapChild);
return map;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public Map<String, String> getProperties() {
Map<String, String> map = new TreeMap<String, String>();
RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
List<String> aList = runtimeMXBean.getInputArguments();
String parameters = "";
for (int i = 0; i < aList.size(); i++) {
parameters = parameters + " " + aList.get(i);
}
map.put("params", parameters);
map.put("name", runtimeMXBean.getVmName());
map.put("vendor", runtimeMXBean.getVmVendor());
map.put("version", runtimeMXBean.getVmVersion());
map.put("specification", runtimeMXBean.getSpecVersion());
map.put("uptime", DurationFormatUtils.formatDurationHMS(runtimeMXBean.getUptime()));
Date date = new Date(runtimeMXBean.getStartTime());
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
map.put("start time", sdf.format(date));
MemoryMXBean memory = ManagementFactory.getMemoryMXBean();
MemoryUsage heap = memory.getHeapMemoryUsage();
map.put(
"memory. (heap)",
readableFileSize(heap.getUsed())
+ "/"
+ readableFileSize(heap.getCommitted())
+ " min:"
+ readableFileSize(heap.getInit())
+ " max:"
+ readableFileSize(heap.getMax()));
MemoryUsage nonheap = memory.getNonHeapMemoryUsage();
map.put(
"memory (non heap)",
readableFileSize(nonheap.getUsed())
+ "/"
+ readableFileSize(nonheap.getCommitted())
+ " min:"
+ readableFileSize(nonheap.getInit())
+ " max:"
+ readableFileSize(nonheap.getMax()));
return map;
}
@Override
public long[] getMaxSystemParameters() {
long[] systemData = new long[3];
MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
systemData[0] = memoryMXBean.getHeapMemoryUsage().getMax();
systemData[1] = memoryMXBean.getNonHeapMemoryUsage().getMax();
List<MemoryPoolMXBean> mbeans = ManagementFactory.getMemoryPoolMXBeans();
if (mbeans != null) {
for (MemoryPoolMXBean mbean : mbeans) {
MemoryUsage memUsage = mbean.getUsage();
if (mbean.getName().equals(PERMGEN_MEMORY_POOL_NAME)) {
systemData[2] = memUsage.getMax();
}
}
}
return systemData;
}
/**
* Prints the verbose GC log to System.out to list the memory usage of all memory pools as well as
* the GC statistics.
*/
public void printVerboseGc() {
System.out.println("Uptime: " + formatMillis(rmbean.getUptime()));
System.out.println("Heap usage: " + mmbean.getHeapMemoryUsage());
System.out.println("Non-Heap memory usage: " + mmbean.getNonHeapMemoryUsage());
for (GarbageCollectorMXBean gc : gcmbeans) {
System.out.print(" [" + gc.getName() + ": ");
System.out.print("Count=" + gc.getCollectionCount());
System.out.print(" GCTime=" + formatMillis(gc.getCollectionTime()));
System.out.print("]");
}
System.out.println();
for (MemoryPoolMXBean p : pools) {
System.out.print(" [" + p.getName() + ":");
MemoryUsage u = p.getUsage();
System.out.print(" Used=" + formatBytes(u.getUsed()));
System.out.print(" Committed=" + formatBytes(u.getCommitted()));
System.out.println("]");
}
}
@Override
public long[] getSystemStatus() {
long[] systemData = new long[4];
MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
systemData[0] = memoryMXBean.getHeapMemoryUsage().getUsed();
systemData[1] = memoryMXBean.getNonHeapMemoryUsage().getUsed();
List<MemoryPoolMXBean> mbeans = ManagementFactory.getMemoryPoolMXBeans();
if (mbeans != null) {
for (MemoryPoolMXBean mbean : mbeans) {
MemoryUsage memUsage = mbean.getUsage();
if (mbean.getName().equals(PERMGEN_MEMORY_POOL_NAME)) {
systemData[2] = memUsage.getUsed();
}
}
}
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
systemData[3] = threadMXBean.getThreadCount();
return systemData;
}
public static void memUsage(PrintWriter out) {
// Overall
MemoryMXBean memBean = ManagementFactory.getMemoryMXBean();
MemoryUsage heap = memBean.getHeapMemoryUsage();
MemoryUsage nonHeap = memBean.getNonHeapMemoryUsage();
out.println("Heap: " + heap);
out.println("Non-heap: " + nonHeap);
// Generations details
List<MemoryPoolMXBean> memoryPoolMXBeans = ManagementFactory.getMemoryPoolMXBeans();
for (MemoryPoolMXBean mbean : memoryPoolMXBeans) {
println(out, "Memory Group", mbean.getName());
MemoryUsage memUsage = mbean.getUsage();
println(out, "Used", memUsage.getUsed());
println(out, "Committed", memUsage.getCommitted());
println(out, "High water", memUsage.getMax());
out.println();
}
}
private String getMemoryUsageStatsAsString(MemoryMXBean memoryMXBean) {
MemoryUsage heap = memoryMXBean.getHeapMemoryUsage();
MemoryUsage nonHeap = memoryMXBean.getNonHeapMemoryUsage();
int mb = 1 << 20;
int heapUsed = (int) (heap.getUsed() / mb);
int heapCommitted = (int) (heap.getCommitted() / mb);
int heapMax = (int) (heap.getMax() / mb);
int nonHeapUsed = (int) (nonHeap.getUsed() / mb);
int nonHeapCommitted = (int) (nonHeap.getCommitted() / mb);
int nonHeapMax = (int) (nonHeap.getMax() / mb);
String msg =
String.format(
"Memory usage stats: [HEAP: %d/%d/%d MB, NON HEAP: %d/%d/%d MB (used/comitted/max)]",
heapUsed, heapCommitted, heapMax, nonHeapUsed, nonHeapCommitted, nonHeapMax);
return msg;
}
public long getMemNonHeap() {
return memoryBean.getNonHeapMemoryUsage().getUsed();
}
/**
* Retrieve a JVM information text formatted using the given StringManager.
*
* @param requestedSm the StringManager to use
* @return the formatted JVM information text
*/
private static String getVMInfo(StringManager requestedSm) {
StringBuilder sb = new StringBuilder();
synchronized (timeformat) {
sb.append(timeformat.format(new Date()));
}
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoRuntime"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "vmName: " + runtimeMXBean.getVmName() + CRLF);
sb.append(INDENT1 + "vmVersion: " + runtimeMXBean.getVmVersion() + CRLF);
sb.append(INDENT1 + "vmVendor: " + runtimeMXBean.getVmVendor() + CRLF);
sb.append(INDENT1 + "specName: " + runtimeMXBean.getSpecName() + CRLF);
sb.append(INDENT1 + "specVersion: " + runtimeMXBean.getSpecVersion() + CRLF);
sb.append(INDENT1 + "specVendor: " + runtimeMXBean.getSpecVendor() + CRLF);
sb.append(
INDENT1 + "managementSpecVersion: " + runtimeMXBean.getManagementSpecVersion() + CRLF);
sb.append(INDENT1 + "name: " + runtimeMXBean.getName() + CRLF);
sb.append(INDENT1 + "startTime: " + runtimeMXBean.getStartTime() + CRLF);
sb.append(INDENT1 + "uptime: " + runtimeMXBean.getUptime() + CRLF);
sb.append(
INDENT1 + "isBootClassPathSupported: " + runtimeMXBean.isBootClassPathSupported() + CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoOs"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "name: " + operatingSystemMXBean.getName() + CRLF);
sb.append(INDENT1 + "version: " + operatingSystemMXBean.getVersion() + CRLF);
sb.append(INDENT1 + "architecture: " + operatingSystemMXBean.getArch() + CRLF);
sb.append(
INDENT1 + "availableProcessors: " + operatingSystemMXBean.getAvailableProcessors() + CRLF);
sb.append(
INDENT1 + "systemLoadAverage: " + operatingSystemMXBean.getSystemLoadAverage() + CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoThreadMxBean"));
sb.append(":" + CRLF);
sb.append(
INDENT1
+ "isCurrentThreadCpuTimeSupported: "
+ threadMXBean.isCurrentThreadCpuTimeSupported()
+ CRLF);
sb.append(
INDENT1 + "isThreadCpuTimeSupported: " + threadMXBean.isThreadCpuTimeSupported() + CRLF);
sb.append(INDENT1 + "isThreadCpuTimeEnabled: " + threadMXBean.isThreadCpuTimeEnabled() + CRLF);
sb.append(
INDENT1
+ "isObjectMonitorUsageSupported: "
+ threadMXBean.isObjectMonitorUsageSupported()
+ CRLF);
sb.append(
INDENT1
+ "isSynchronizerUsageSupported: "
+ threadMXBean.isSynchronizerUsageSupported()
+ CRLF);
sb.append(
INDENT1
+ "isThreadContentionMonitoringSupported: "
+ threadMXBean.isThreadContentionMonitoringSupported()
+ CRLF);
sb.append(
INDENT1
+ "isThreadContentionMonitoringEnabled: "
+ threadMXBean.isThreadContentionMonitoringEnabled()
+ CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoThreadCounts"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "daemon: " + threadMXBean.getDaemonThreadCount() + CRLF);
sb.append(INDENT1 + "total: " + threadMXBean.getThreadCount() + CRLF);
sb.append(INDENT1 + "peak: " + threadMXBean.getPeakThreadCount() + CRLF);
sb.append(INDENT1 + "totalStarted: " + threadMXBean.getTotalStartedThreadCount() + CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoStartup"));
sb.append(":" + CRLF);
for (String arg : runtimeMXBean.getInputArguments()) {
sb.append(INDENT1 + arg + CRLF);
}
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoPath"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "bootClassPath: " + runtimeMXBean.getBootClassPath() + CRLF);
sb.append(INDENT1 + "classPath: " + runtimeMXBean.getClassPath() + CRLF);
sb.append(INDENT1 + "libraryPath: " + runtimeMXBean.getLibraryPath() + CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoClassLoading"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "loaded: " + classLoadingMXBean.getLoadedClassCount() + CRLF);
sb.append(INDENT1 + "unloaded: " + classLoadingMXBean.getUnloadedClassCount() + CRLF);
sb.append(INDENT1 + "totalLoaded: " + classLoadingMXBean.getTotalLoadedClassCount() + CRLF);
sb.append(INDENT1 + "isVerbose: " + classLoadingMXBean.isVerbose() + CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoClassCompilation"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "name: " + compilationMXBean.getName() + CRLF);
sb.append(
INDENT1 + "totalCompilationTime: " + compilationMXBean.getTotalCompilationTime() + CRLF);
sb.append(
INDENT1
+ "isCompilationTimeMonitoringSupported: "
+ compilationMXBean.isCompilationTimeMonitoringSupported()
+ CRLF);
sb.append(CRLF);
for (MemoryManagerMXBean mbean : memoryManagerMXBeans) {
sb.append(requestedSm.getString("diagnostics.vmInfoMemoryManagers", mbean.getName()));
sb.append(":" + CRLF);
sb.append(INDENT1 + "isValid: " + mbean.isValid() + CRLF);
sb.append(INDENT1 + "mbean.getMemoryPoolNames: " + CRLF);
String[] names = mbean.getMemoryPoolNames();
Arrays.sort(names);
for (String name : names) {
sb.append(INDENT2 + name + CRLF);
}
sb.append(CRLF);
}
for (GarbageCollectorMXBean mbean : garbageCollectorMXBeans) {
sb.append(requestedSm.getString("diagnostics.vmInfoGarbageCollectors", mbean.getName()));
sb.append(":" + CRLF);
sb.append(INDENT1 + "isValid: " + mbean.isValid() + CRLF);
sb.append(INDENT1 + "mbean.getMemoryPoolNames: " + CRLF);
String[] names = mbean.getMemoryPoolNames();
Arrays.sort(names);
for (String name : names) {
sb.append(INDENT2 + name + CRLF);
}
sb.append(INDENT1 + "getCollectionCount: " + mbean.getCollectionCount() + CRLF);
sb.append(INDENT1 + "getCollectionTime: " + mbean.getCollectionTime() + CRLF);
sb.append(CRLF);
}
sb.append(requestedSm.getString("diagnostics.vmInfoMemory"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "isVerbose: " + memoryMXBean.isVerbose() + CRLF);
sb.append(
INDENT1
+ "getObjectPendingFinalizationCount: "
+ memoryMXBean.getObjectPendingFinalizationCount()
+ CRLF);
sb.append(formatMemoryUsage("heap", memoryMXBean.getHeapMemoryUsage()));
sb.append(formatMemoryUsage("non-heap", memoryMXBean.getNonHeapMemoryUsage()));
sb.append(CRLF);
for (MemoryPoolMXBean mbean : memoryPoolMXBeans) {
sb.append(requestedSm.getString("diagnostics.vmInfoMemoryPools", mbean.getName()));
sb.append(":" + CRLF);
sb.append(INDENT1 + "isValid: " + mbean.isValid() + CRLF);
sb.append(INDENT1 + "getType: " + mbean.getType() + CRLF);
sb.append(INDENT1 + "mbean.getMemoryManagerNames: " + CRLF);
String[] names = mbean.getMemoryManagerNames();
Arrays.sort(names);
for (String name : names) {
sb.append(INDENT2 + name + CRLF);
}
sb.append(INDENT1 + "isUsageThresholdSupported: " + mbean.isUsageThresholdSupported() + CRLF);
try {
sb.append(INDENT1 + "isUsageThresholdExceeded: " + mbean.isUsageThresholdExceeded() + CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
sb.append(
INDENT1
+ "isCollectionUsageThresholdSupported: "
+ mbean.isCollectionUsageThresholdSupported()
+ CRLF);
try {
sb.append(
INDENT1
+ "isCollectionUsageThresholdExceeded: "
+ mbean.isCollectionUsageThresholdExceeded()
+ CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
try {
sb.append(INDENT1 + "getUsageThreshold: " + mbean.getUsageThreshold() + CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
try {
sb.append(INDENT1 + "getUsageThresholdCount: " + mbean.getUsageThresholdCount() + CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
try {
sb.append(
INDENT1 + "getCollectionUsageThreshold: " + mbean.getCollectionUsageThreshold() + CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
try {
sb.append(
INDENT1
+ "getCollectionUsageThresholdCount: "
+ mbean.getCollectionUsageThresholdCount()
+ CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
sb.append(formatMemoryUsage("current", mbean.getUsage()));
sb.append(formatMemoryUsage("collection", mbean.getCollectionUsage()));
sb.append(formatMemoryUsage("peak", mbean.getPeakUsage()));
sb.append(CRLF);
}
sb.append(requestedSm.getString("diagnostics.vmInfoSystem"));
sb.append(":" + CRLF);
Map<String, String> props = runtimeMXBean.getSystemProperties();
ArrayList<String> keys = new ArrayList<String>(props.keySet());
Collections.sort(keys);
for (String prop : keys) {
sb.append(INDENT1 + prop + ": " + props.get(prop) + CRLF);
}
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoLogger"));
sb.append(":" + CRLF);
List<String> loggers = loggingMXBean.getLoggerNames();
Collections.sort(loggers);
for (String logger : loggers) {
sb.append(
INDENT1
+ logger
+ ": level="
+ loggingMXBean.getLoggerLevel(logger)
+ ", parent="
+ loggingMXBean.getParentLoggerName(logger)
+ CRLF);
}
sb.append(CRLF);
return sb.toString();
}
/*
* (non-Javadoc)
*
* @see com.orientechnologies.common.test.SpeedTest#collectResults(long)
*/
public void collectResults(final long elapsed) {
Runtime.getRuntime().runFinalization();
Runtime.getRuntime().gc();
final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
final MemoryUsage heapMemoryUsage = memoryMXBean.getHeapMemoryUsage();
final MemoryUsage nonHeapMemoryUsage = memoryMXBean.getNonHeapMemoryUsage();
final int objectsPendingFinalizationCount = memoryMXBean.getObjectPendingFinalizationCount();
final long nowHeapCommittedMemory = heapMemoryUsage.getCommitted();
final long nowHeapUsedMemory = heapMemoryUsage.getUsed();
final long nowHeapMaxMemory = heapMemoryUsage.getMax();
final long heapCommittedMemory = nowHeapCommittedMemory - currentTestHeapCommittedMemory;
final long heapUsedMemory = nowHeapUsedMemory - currentTestHeapUsedMemory;
final long heapMaxMemory = nowHeapMaxMemory - currentTestHeapMaxMemory;
final long nowNonHeapCommittedMemory = nonHeapMemoryUsage.getCommitted();
final long nowNonHeapUsedMemory = nonHeapMemoryUsage.getUsed();
final long nowNonHeapMaxMemory = nonHeapMemoryUsage.getMax();
final long nonHeapCommittedMemory =
nowNonHeapCommittedMemory - currentTestNonHeapCommittedMemory;
final long nonHeapUsedMemory = nowNonHeapUsedMemory - currentTestNonHeapUsedMemory;
final long nonHeapMaxMemory = nowNonHeapMaxMemory - currentTestNonHeapMaxMemory;
if (printResults) {
System.out.println();
System.out.println(
" Completed the test of '"
+ currentTestName
+ "' in "
+ elapsed
+ " ms. Heap memory used: "
+ nowHeapUsedMemory
+ " bytes. Non heap memory used: "
+ nowNonHeapUsedMemory
+ " .");
System.out.println(" Cycles done.......................: " + cyclesDone + "/" + cycles);
System.out.println(" Cycles Elapsed....................: " + cyclesElapsed + " ms");
System.out.println(" Elapsed...........................: " + elapsed + " ms");
System.out.println(
" Medium cycle elapsed:.............: "
+ (cyclesDone > 0 && elapsed > 0
? new BigDecimal((float) elapsed / cyclesDone).toPlainString()
: 0));
System.out.println(
" Cycles per second.................: "
+ new BigDecimal((float) cyclesDone / elapsed * 1000).toPlainString());
System.out.println(
" Committed heap memory diff........: "
+ heapCommittedMemory
+ " ("
+ currentTestHeapCommittedMemory
+ "->"
+ nowHeapCommittedMemory
+ ")");
System.out.println(
" Used heap memory diff.............: "
+ heapUsedMemory
+ " ("
+ currentTestHeapUsedMemory
+ "->"
+ nowHeapUsedMemory
+ ")");
System.out.println(
" Max heap memory diff..............: "
+ heapMaxMemory
+ " ("
+ currentTestHeapMaxMemory
+ "->"
+ nowHeapMaxMemory
+ ")");
System.out.println(
" Committed non heap memory diff....: "
+ nonHeapCommittedMemory
+ " ("
+ currentTestNonHeapCommittedMemory
+ "->"
+ nowNonHeapCommittedMemory
+ ")");
System.out.println(
" Used non heap memory diff.........: "
+ nonHeapUsedMemory
+ " ("
+ currentTestNonHeapUsedMemory
+ "->"
+ nowNonHeapUsedMemory
+ ")");
System.out.println(
" Max non heap memory diff..........: "
+ nonHeapMaxMemory
+ " ("
+ currentTestNonHeapMaxMemory
+ "->"
+ nowNonHeapMaxMemory
+ ")");
System.out.println(
" Objects pending finalization......: " + objectsPendingFinalizationCount);
System.out.println();
}
if (testGroup != null) {
testGroup.setResult("Execution time", currentTestName, elapsed);
testGroup.setResult("Free memory", currentTestName, heapCommittedMemory);
}
currentTestHeapCommittedMemory = heapCommittedMemory;
currentTestHeapUsedMemory = heapUsedMemory;
currentTestHeapMaxMemory = heapMaxMemory;
currentTestNonHeapCommittedMemory = nonHeapCommittedMemory;
currentTestNonHeapUsedMemory = nonHeapUsedMemory;
currentTestNonHeapMaxMemory = nonHeapMaxMemory;
}
@Override
public void testRunFinished(final Result result) throws Exception {
if (!HybrisJUnit4Test.intenseChecksActivated()) {
return;
}
final MemoryUsage heapAtTestEnd = memoryBean.getHeapMemoryUsage();
final MemoryUsage nonHeapAtTestEnd = memoryBean.getNonHeapMemoryUsage();
final long initHeapDiffInK = (heapAtTestEnd.getInit() - heapAtTestStart.getInit()) / 1024;
final long usedHeapDiffInK = (heapAtTestEnd.getUsed() - heapAtTestStart.getUsed()) / 1024;
final long comittedHeapDiffInK =
(heapAtTestEnd.getCommitted() - heapAtTestStart.getCommitted()) / 1024;
final long initNonHeapDiffInK =
(nonHeapAtTestEnd.getInit() - nonHeapAtTestStart.getInit()) / 1024;
final long usedNonHeapDiffInK =
(nonHeapAtTestEnd.getUsed() - nonHeapAtTestStart.getUsed()) / 1024;
final long comittedNonHeapDiffInK =
(nonHeapAtTestEnd.getCommitted() - nonHeapAtTestStart.getCommitted()) / 1024;
LOG.info("+---------------------------- Memory usage after test " + currentTestClass);
LOG.info(
"+ heap: init="
+ (heapAtTestEnd.getInit() / 1024)
+ "K ("
+ initHeapDiffInK
+ "K)\t "
+ //
"used="
+ (heapAtTestEnd.getUsed() / 1024)
+ "K ("
+ usedHeapDiffInK
+ "K)\t "
+ //
"comitted="
+ (heapAtTestEnd.getCommitted() / 1024)
+ "K ("
+ comittedHeapDiffInK
+ "K)");
LOG.info(
"+ non-heap: init="
+ (nonHeapAtTestEnd.getInit() / 1024)
+ "K ("
+ initNonHeapDiffInK
+ "K)\t "
+ //
"used="
+ (nonHeapAtTestEnd.getUsed() / 1024)
+ "K ("
+ usedNonHeapDiffInK
+ "K)\t "
+ //
"comitted="
+ (nonHeapAtTestEnd.getCommitted() / 1024)
+ "K ("
+ comittedNonHeapDiffInK
+ "K)");
LOG.info("+ ObjectPendingFinalizationCount: " + memoryBean.getObjectPendingFinalizationCount());
for (final MemoryPoolMXBean mpbean : ManagementFactory.getMemoryPoolMXBeans()) {
LOG.info(
"+ "
+ mpbean.getName()
+ "("
+ mpbean.getType()
+ "): "
+ mpbean.getCollectionUsage());
}
LOG.info(
"+--------------------------------------------------------------------------------------------------");
}
@BIF
static EObject system_info(EProc proc, EObject type) {
if (type == am_machine) {
// we report BEAM so that the compiler emits BEAM files
return EString.fromString("BEAM");
} else if (type == am_smp_support) {
return ERT.TRUE;
} else if (type == am_schedulers) {
return ERT.box(ERT.threadPoolSize());
} else if (type == am_process_limit) {
return ERT.box(ERT.processLimit());
} else if (type == am_fullsweep_after) {
return ERT.box(65535);
} else if (type == am_schedulers_online) {
return ERT.box(Math.max(1, ERT.threadPoolSize()));
} else if (type == am_threads) {
return ERT.box(true);
} else if (type == am_thread_pool_size) {
return ERT.box(ERT.asyncThreadPoolSize());
} else if (type == am_break_ignored) {
return ERT.box(false);
} else if (type == am_compat_rel) {
// we return same value as R14
return new ESmall(14);
}
ETuple2 tup;
if (type == am_allocated_areas) {
ECons res = ERT.NIL;
List<MemoryPoolMXBean> bean2 = ManagementFactory.getMemoryPoolMXBeans();
if (bean2 == null) {
MemoryMXBean bean = ManagementFactory.getMemoryMXBean();
if (bean != null) {
MemoryUsage mu = bean.getHeapMemoryUsage();
res = res.cons(ETuple.make(am_heap, ERT.box(mu.getCommitted()), ERT.box(mu.getUsed())));
mu = bean.getNonHeapMemoryUsage();
res =
res.cons(ETuple.make(am_non_heap, ERT.box(mu.getCommitted()), ERT.box(mu.getUsed())));
}
return res;
}
for (MemoryPoolMXBean mb : bean2) {
String name = mb.getName();
MemoryUsage mu = mb.getUsage();
if (mu == null) continue;
String name2 = (mb.getType() == MemoryType.HEAP ? "heap:" : "non_heap:") + name;
res =
res.cons(
ETuple.make(
EAtom.intern(name2), ERT.box(mu.getCommitted()), ERT.box(mu.getUsed())));
}
return res;
} else if (type == am_allocator) {
return am_jvm;
} else if (type == am_heap_type) {
return am_shared;
} else if (type == am_smp_support) {
return ERT.TRUE;
} else if (type == am_thread_pool_size) {
// TODO: hook up to thread pool
return new ESmall(ERT.threadPoolSize());
} else if (type == am_os_type) {
String os = System.getProperty("os.name");
if (os.startsWith("Windows")) {
return ETuple.make(am_win32, new EString(os));
} else {
return ETuple.make(am_unix, new EString(os));
}
} else if (type == am_threads) {
return ERT.TRUE;
} else if (type == am_version) {
String erts_version = ERT.runtime_info.erts_version;
// remove prefix
String prefix = "erts-";
if (erts_version.startsWith(prefix)) {
erts_version = erts_version.substring(prefix.length());
}
return EString.fromString(erts_version);
} else if (type == am_otp_release) {
return new EString(ERT.runtime_info.otp_version);
} else if (type == am_logical_processors) {
// TODO: be smarter somehow
return ERT.box(Runtime.getRuntime().availableProcessors());
} else if (type == am_global_heaps_size) {
return ERT.box(Runtime.getRuntime().totalMemory());
} else if (type == am_process_count) {
return ERT.box(EProc.process_count());
} else if (type == am_system_architecture) {
return new EString(Main.SYSTEM_ARCHITECTURE);
} else if (type == am_driver_version) {
// TODO: be smarter somehow
return new EString(Main.DRIVER_VERSION);
} else if (type == am_wordsize) {
return new ESmall(4);
} else if (type == am_debug_compiled || type == am_lock_checking) {
throw ERT.badarg(type);
} else if (type == am_hipe_architecture) {
return am_undefined;
} else if (type == am_build_type) {
return EAtom.intern("opt");
} else if (type == am_system_version) {
return new EString("Erjang [" + ERT.runtime_info.erts_version + "]");
} else if ((tup = ETuple2.cast(type)) != null) {
if (tup.elem1 == am_allocator) {
if (tup.elem2 == am_ets_alloc) {
return ERT.FALSE;
}
} else if (tup.elem1 == am_error_checker) {
throw ERT.badarg(type);
}
return am_undefined;
} else {
log.info("erlang:system_info(" + type + ") unknown");
throw ERT.badarg(type);
}
}
static {
RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
// returns the <process id>@<host>
long pid;
String xPid = runtimeMXBean.getName();
try {
xPid = xPid.split("@")[0];
pid = Long.parseLong(xPid);
} catch (Exception e) {
pid = -1;
}
JvmInfo info = new JvmInfo();
info.pid = pid;
info.startTime = runtimeMXBean.getStartTime();
info.version = System.getProperty("java.version");
info.vmName = runtimeMXBean.getVmName();
info.vmVendor = runtimeMXBean.getVmVendor();
info.vmVersion = runtimeMXBean.getVmVersion();
info.mem = new Mem();
info.mem.heapInit =
memoryMXBean.getHeapMemoryUsage().getInit() < 0
? 0
: memoryMXBean.getHeapMemoryUsage().getInit();
info.mem.heapMax =
memoryMXBean.getHeapMemoryUsage().getMax() < 0
? 0
: memoryMXBean.getHeapMemoryUsage().getMax();
info.mem.nonHeapInit =
memoryMXBean.getNonHeapMemoryUsage().getInit() < 0
? 0
: memoryMXBean.getNonHeapMemoryUsage().getInit();
info.mem.nonHeapMax =
memoryMXBean.getNonHeapMemoryUsage().getMax() < 0
? 0
: memoryMXBean.getNonHeapMemoryUsage().getMax();
try {
Class<?> vmClass = Class.forName("sun.misc.VM");
info.mem.directMemoryMax = (Long) vmClass.getMethod("maxDirectMemory").invoke(null);
} catch (Exception t) {
// ignore
}
info.inputArguments =
runtimeMXBean
.getInputArguments()
.toArray(new String[runtimeMXBean.getInputArguments().size()]);
try {
info.bootClassPath = runtimeMXBean.getBootClassPath();
} catch (UnsupportedOperationException e) {
// oracle java 9
info.bootClassPath = System.getProperty("sun.boot.class.path");
if (info.bootClassPath == null) {
// something else
info.bootClassPath = "<unknown>";
}
}
info.classPath = runtimeMXBean.getClassPath();
info.systemProperties = Collections.unmodifiableMap(runtimeMXBean.getSystemProperties());
List<GarbageCollectorMXBean> gcMxBeans = ManagementFactory.getGarbageCollectorMXBeans();
info.gcCollectors = new String[gcMxBeans.size()];
for (int i = 0; i < gcMxBeans.size(); i++) {
GarbageCollectorMXBean gcMxBean = gcMxBeans.get(i);
info.gcCollectors[i] = gcMxBean.getName();
}
List<MemoryPoolMXBean> memoryPoolMXBeans = ManagementFactory.getMemoryPoolMXBeans();
info.memoryPools = new String[memoryPoolMXBeans.size()];
for (int i = 0; i < memoryPoolMXBeans.size(); i++) {
MemoryPoolMXBean memoryPoolMXBean = memoryPoolMXBeans.get(i);
info.memoryPools[i] = memoryPoolMXBean.getName();
}
try {
@SuppressWarnings("unchecked")
Class<? extends PlatformManagedObject> clazz =
(Class<? extends PlatformManagedObject>)
Class.forName("com.sun.management.HotSpotDiagnosticMXBean");
Class<?> vmOptionClazz = Class.forName("com.sun.management.VMOption");
PlatformManagedObject hotSpotDiagnosticMXBean = ManagementFactory.getPlatformMXBean(clazz);
Method vmOptionMethod = clazz.getMethod("getVMOption", String.class);
Method valueMethod = vmOptionClazz.getMethod("getValue");
try {
Object onError = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "OnError");
info.onError = (String) valueMethod.invoke(onError);
} catch (Exception ignored) {
}
try {
Object onOutOfMemoryError =
vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "OnOutOfMemoryError");
info.onOutOfMemoryError = (String) valueMethod.invoke(onOutOfMemoryError);
} catch (Exception ignored) {
}
try {
Object useCompressedOopsVmOption =
vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseCompressedOops");
info.useCompressedOops = (String) valueMethod.invoke(useCompressedOopsVmOption);
} catch (Exception ignored) {
}
try {
Object useG1GCVmOption = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseG1GC");
info.useG1GC = (String) valueMethod.invoke(useG1GCVmOption);
} catch (Exception ignored) {
}
try {
Object initialHeapSizeVmOption =
vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "InitialHeapSize");
info.configuredInitialHeapSize =
Long.parseLong((String) valueMethod.invoke(initialHeapSizeVmOption));
} catch (Exception ignored) {
}
try {
Object maxHeapSizeVmOption = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "MaxHeapSize");
info.configuredMaxHeapSize =
Long.parseLong((String) valueMethod.invoke(maxHeapSizeVmOption));
} catch (Exception ignored) {
}
} catch (Exception ignored) {
}
INSTANCE = info;
}
/** Exports stats related to the JVM and runtime environment. */
public static void export() {
final OperatingSystemMXBean osMbean = ManagementFactory.getOperatingSystemMXBean();
if (osMbean instanceof com.sun.management.OperatingSystemMXBean) {
final com.sun.management.OperatingSystemMXBean sunOsMbean =
(com.sun.management.OperatingSystemMXBean) osMbean;
Stats.exportAll(
ImmutableList.<Stat<? extends Number>>builder()
.add(
new StatImpl<Long>("system_free_physical_memory_mb") {
@Override
public Long read() {
return sunOsMbean.getFreePhysicalMemorySize() / BYTES_PER_MB;
}
})
.add(
new StatImpl<Long>("system_free_swap_mb") {
@Override
public Long read() {
return sunOsMbean.getFreeSwapSpaceSize() / BYTES_PER_MB;
}
})
.add(
Rate.of(
new StatImpl<Long>("process_cpu_time_nanos") {
@Override
public Long read() {
return sunOsMbean.getProcessCpuTime();
}
})
.withName("process_cpu_cores_utilized")
.withScaleFactor(SECS_PER_NANO)
.build())
.build());
}
if (osMbean instanceof com.sun.management.UnixOperatingSystemMXBean) {
final com.sun.management.UnixOperatingSystemMXBean unixOsMbean =
(com.sun.management.UnixOperatingSystemMXBean) osMbean;
Stats.exportAll(
ImmutableList.<Stat<? extends Number>>builder()
.add(
new StatImpl<Long>("process_max_fd_count") {
@Override
public Long read() {
return unixOsMbean.getMaxFileDescriptorCount();
}
})
.add(
new StatImpl<Long>("process_open_fd_count") {
@Override
public Long read() {
return unixOsMbean.getOpenFileDescriptorCount();
}
})
.build());
}
final Runtime runtime = Runtime.getRuntime();
final ClassLoadingMXBean classLoadingBean = ManagementFactory.getClassLoadingMXBean();
MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
final MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
final MemoryUsage nonHeapUsage = memoryBean.getNonHeapMemoryUsage();
final ThreadMXBean threads = ManagementFactory.getThreadMXBean();
final RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
Stats.exportAll(
ImmutableList.<Stat<? extends Number>>builder()
.add(
new StatImpl<Long>("jvm_time_ms") {
@Override
public Long read() {
return System.currentTimeMillis();
}
})
.add(
new StatImpl<Integer>("jvm_available_processors") {
@Override
public Integer read() {
return runtime.availableProcessors();
}
})
.add(
new StatImpl<Long>("jvm_memory_free_mb") {
@Override
public Long read() {
return runtime.freeMemory() / BYTES_PER_MB;
}
})
.add(
new StatImpl<Long>("jvm_memory_max_mb") {
@Override
public Long read() {
return runtime.maxMemory() / BYTES_PER_MB;
}
})
.add(
new StatImpl<Long>("jvm_memory_mb_total") {
@Override
public Long read() {
return runtime.totalMemory() / BYTES_PER_MB;
}
})
.add(
new StatImpl<Integer>("jvm_class_loaded_count") {
@Override
public Integer read() {
return classLoadingBean.getLoadedClassCount();
}
})
.add(
new StatImpl<Long>("jvm_class_total_loaded_count") {
@Override
public Long read() {
return classLoadingBean.getTotalLoadedClassCount();
}
})
.add(
new StatImpl<Long>("jvm_class_unloaded_count") {
@Override
public Long read() {
return classLoadingBean.getUnloadedClassCount();
}
})
.add(
new StatImpl<Long>("jvm_gc_collection_time_ms") {
@Override
public Long read() {
long collectionTimeMs = 0;
for (GarbageCollectorMXBean bean :
ManagementFactory.getGarbageCollectorMXBeans()) {
collectionTimeMs += bean.getCollectionTime();
}
return collectionTimeMs;
}
})
.add(
new StatImpl<Long>("jvm_gc_collection_count") {
@Override
public Long read() {
long collections = 0;
for (GarbageCollectorMXBean bean :
ManagementFactory.getGarbageCollectorMXBeans()) {
collections += bean.getCollectionCount();
}
return collections;
}
})
.add(
new StatImpl<Long>("jvm_memory_heap_mb_used") {
@Override
public Long read() {
return heapUsage.getUsed() / BYTES_PER_MB;
}
})
.add(
new StatImpl<Long>("jvm_memory_heap_mb_committed") {
@Override
public Long read() {
return heapUsage.getCommitted() / BYTES_PER_MB;
}
})
.add(
new StatImpl<Long>("jvm_memory_heap_mb_max") {
@Override
public Long read() {
return heapUsage.getMax() / BYTES_PER_MB;
}
})
.add(
new StatImpl<Long>("jvm_memory_non_heap_mb_used") {
@Override
public Long read() {
return nonHeapUsage.getUsed() / BYTES_PER_MB;
}
})
.add(
new StatImpl<Long>("jvm_memory_non_heap_mb_committed") {
@Override
public Long read() {
return nonHeapUsage.getCommitted() / BYTES_PER_MB;
}
})
.add(
new StatImpl<Long>("jvm_memory_non_heap_mb_max") {
@Override
public Long read() {
return nonHeapUsage.getMax() / BYTES_PER_MB;
}
})
.add(
new StatImpl<Long>("jvm_uptime_secs") {
@Override
public Long read() {
return runtimeMXBean.getUptime() / 1000;
}
})
.add(
new StatImpl<Double>("system_load_avg") {
@Override
public Double read() {
return osMbean.getSystemLoadAverage();
}
})
.add(
new StatImpl<Integer>("jvm_threads_peak") {
@Override
public Integer read() {
return threads.getPeakThreadCount();
}
})
.add(
new StatImpl<Long>("jvm_threads_started") {
@Override
public Long read() {
return threads.getTotalStartedThreadCount();
}
})
.add(
new StatImpl<Integer>("jvm_threads_daemon") {
@Override
public Integer read() {
return threads.getDaemonThreadCount();
}
})
.add(
new StatImpl<Integer>("jvm_threads_active") {
@Override
public Integer read() {
return threads.getThreadCount();
}
})
.build());
// Export per memory pool gc time and cycle count like Ostrich
// This is based on code in Bridcage: https://cgit.twitter.biz/birdcage/tree/ \
// ostrich/src/main/scala/com/twitter/ostrich/stats/StatsCollection.scala
Stats.exportAll(
Iterables.transform(
ManagementFactory.getGarbageCollectorMXBeans(),
new Function<GarbageCollectorMXBean, Stat<? extends Number>>() {
@Override
public Stat<? extends Number> apply(final GarbageCollectorMXBean gcMXBean) {
return new StatImpl<Long>(
"jvm_gc_" + Stats.normalizeName(gcMXBean.getName()) + "_collection_count") {
@Override
public Long read() {
return gcMXBean.getCollectionCount();
}
};
}
}));
Stats.exportAll(
Iterables.transform(
ManagementFactory.getGarbageCollectorMXBeans(),
new Function<GarbageCollectorMXBean, Stat<? extends Number>>() {
@Override
public Stat<? extends Number> apply(final GarbageCollectorMXBean gcMXBean) {
return new StatImpl<Long>(
"jvm_gc_" + Stats.normalizeName(gcMXBean.getName()) + "_collection_time_ms") {
@Override
public Long read() {
return gcMXBean.getCollectionTime();
}
};
}
}));
Stats.exportString(
new StatImpl<String>("jvm_input_arguments") {
@Override
public String read() {
return runtimeMXBean.getInputArguments().toString();
}
});
for (final String property : System.getProperties().stringPropertyNames()) {
Stats.exportString(
new StatImpl<String>("jvm_prop_" + Stats.normalizeName(property)) {
@Override
public String read() {
return System.getProperty(property);
}
});
}
}
/**
* Returns the size of free non-heap memory.
*
* @return the size of free non-heap memory.
*/
public Number getFree() {
MemoryMXBean memory = ManagementFactory.getMemoryMXBean();
return Long.valueOf(
memory.getNonHeapMemoryUsage().getMax() - memory.getNonHeapMemoryUsage().getUsed());
}
