/* * (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()); }