@Override public void run() { List<GarbageCollectorMXBean> garbageCollectorMXBeans = ManagementFactory.getGarbageCollectorMXBeans(); GarbageCollectorMXBean garbageCollectorMXBean = CollectionUtils.findFirst(garbageCollectorMXBeans, new Spec<GarbageCollectorMXBean>() { @Override public boolean isSatisfiedBy(GarbageCollectorMXBean mbean) { return mbean.getName().equals(garbageCollector); } }); List<MemoryPoolMXBean> memoryPoolMXBeans = ManagementFactory.getMemoryPoolMXBeans(); for (MemoryPoolMXBean memoryPoolMXBean : memoryPoolMXBeans) { String pool = memoryPoolMXBean.getName(); if (memoryPools.contains(pool)) { GarbageCollectionEvent event = new GarbageCollectionEvent(System.currentTimeMillis(), memoryPoolMXBean.getCollectionUsage(), garbageCollectorMXBean.getCollectionCount()); events.get(pool).slideAndInsert(event); } } }
@Override public void sense(final MetricRecorder.Context metricContext) { List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans(); // sum up metrics for all the garbage collectors //TODO: individual metrics per gc? long totalCollections = 0L; long totalTime = 0L; for (GarbageCollectorMXBean mxBean : gcBeans) { totalCollections += mxBean.getCollectionCount(); totalTime += mxBean.getCollectionTime(); } metricContext.record(COLLECTION_COUNT_TOTAL, totalCollections, Unit.NONE); metricContext.record(COLLECTION_TIME_TOTAL, totalTime, Unit.MILLISECOND); metricContext.record(COLLECTION_COUNT, (totalCollections - prevTotalCollections), Unit.NONE); metricContext.record(COLLECTION_TIME, (totalTime - prevTotalTime), Unit.MILLISECOND); prevTotalCollections = totalCollections; prevTotalTime = totalTime; }
private void getGcUsage(MetricsRecordBuilder rb) { long count = 0; long timeMillis = 0; for (GarbageCollectorMXBean gcBean : gcBeans) { long c = gcBean.getCollectionCount(); long t = gcBean.getCollectionTime(); MetricsInfo[] gcInfo = getGcInfo(gcBean.getName()); rb.addCounter(gcInfo[0], c).addCounter(gcInfo[1], t); count += c; timeMillis += t; } rb.addCounter(GcCount, count) .addCounter(GcTimeMillis, timeMillis); if (pauseMonitor != null) { rb.addCounter(GcNumWarnThresholdExceeded, pauseMonitor.getNumGcWarnThresholdExceeded()); rb.addCounter(GcNumInfoThresholdExceeded, pauseMonitor.getNumGcInfoThresholdExceeded()); rb.addCounter(GcTotalExtraSleepTime, pauseMonitor.getTotalGcExtraSleepTime()); } }
public static void printGCStats() { long totalGarbageCollections = 0; long garbageCollectionTime = 0; for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) { long count = gc.getCollectionCount(); if (count >= 0) { totalGarbageCollections += count; } long time = gc.getCollectionTime(); if (time >= 0) { garbageCollectionTime += time; } } System.out.println("Total Garbage Collections: " + totalGarbageCollections); System.out.println("Total Garbage Collection Time (ms): " + garbageCollectionTime); }
public static void printGCStats(Tracer logger) { long totalGarbageCollections = 0; long garbageCollectionTime = 0; for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) { long count = gc.getCollectionCount(); if (count >= 0) { totalGarbageCollections += count; } long time = gc.getCollectionTime(); if (time >= 0) { garbageCollectionTime += time; } } logger.info("Total Garbage Collections: " + totalGarbageCollections); logger.info("Total Garbage Collection Time (ms): " + garbageCollectionTime); }
private static void installGCMonitoring() { List<GarbageCollectorMXBean> gcbeans = java.lang.management.ManagementFactory.getGarbageCollectorMXBeans(); for (GarbageCollectorMXBean gcbean : gcbeans) { NotificationEmitter emitter = (NotificationEmitter) gcbean; System.out.println(gcbean.getName()); NotificationListener listener = (notification, handback) -> { if (notification.getType().equals(GarbageCollectionNotificationInfo.GARBAGE_COLLECTION_NOTIFICATION)) { GarbageCollectionNotificationInfo info = GarbageCollectionNotificationInfo.from((CompositeData) notification.getUserData()); long duration = info.getGcInfo().getDuration(); String gctype = info.getGcAction(); System.out.println(gctype + ": - " + info.getGcInfo().getId() + ", " + info.getGcName() + " (from " + info.getGcCause() + ") " + duration + " milliseconds"); } }; emitter.addNotificationListener(listener, null, null); } }
GcInfoBuilder(GarbageCollectorMXBean gc, String[] poolNames) { this.gc = gc; this.poolNames = poolNames; this.gcExtItemCount = getNumGcExtAttributes(gc); this.gcExtItemNames = new String[gcExtItemCount]; this.gcExtItemDescs = new String[gcExtItemCount]; this.gcExtItemTypes = new char[gcExtItemCount]; // Fill the information about extension attributes fillGcAttributeInfo(gc, gcExtItemCount, gcExtItemNames, gcExtItemTypes, gcExtItemDescs); // lazily build the CompositeType for the GcInfo // including the GC-specific extension attributes this.gcInfoCompositeType = null; }
/** * Returns the index that immediately follows the given * <var>index</var>. The returned index is strictly greater * than the given <var>index</var>, and is contained in the table. * <br>If the given <var>index</var> is null, returns the first * index in the table. * <br>If there are no index after the given <var>index</var>, * returns null. **/ public SnmpOid getNext(SnmpTableHandler handler, SnmpOid index) { // try to call the optimized method if (handler instanceof SnmpCachedData) return getNext((SnmpCachedData)handler, index); // too bad - revert to non-optimized generic algorithm SnmpOid next = index; do { next = handler.getNext(next); final Object value = handler.getData(next); if (value instanceof GarbageCollectorMXBean) // That's the next! return it return next; // skip to next index... } while (next != null); return null; }
private void getGcUsage(MetricsRecordBuilder rb) { long count = 0; long timeMillis = 0; for (GarbageCollectorMXBean gcBean : gcBeans) { long c = gcBean.getCollectionCount(); long t = gcBean.getCollectionTime(); MetricsInfo[] gcInfo = getGcInfo(gcBean.getName()); rb.addCounter(gcInfo[0], c).addCounter(gcInfo[1], t); count += c; timeMillis += t; } rb.addCounter(GcCount, count) .addCounter(GcTimeMillis, timeMillis); if (pauseMonitor != null) { rb.addCounter(GcNumWarnThresholdExceeded, pauseMonitor.getNumGcWarnThreadholdExceeded()); rb.addCounter(GcNumInfoThresholdExceeded, pauseMonitor.getNumGcInfoThresholdExceeded()); rb.addCounter(GcTotalExtraSleepTime, pauseMonitor.getTotalGcExtraSleepTime()); } }
public static Map<String, Long> readGCUsage(List<GarbageCollectorMXBean> gcmbList) { Map<String, Long> m = new LinkedHashMap<String, Long>(); for (GarbageCollectorMXBean gcmb : gcmbList) { String name = gcmb.getName(); String gcName = null; if (minorGC.contains(name)) { gcName = "mgc"; } else if (fullGC.contains(name)) { gcName = "fgc"; } if (gcName == null) { continue; } m.put(gcName + "_count", gcmb.getCollectionCount()); m.put(gcName + "_time", gcmb.getCollectionTime()); } return m; }
private void readGCUsage(MonitorElementInstance instance) { List<GarbageCollectorMXBean> gcmbList = ManagementFactory.getGarbageCollectorMXBeans(); for (GarbageCollectorMXBean gcmb : gcmbList) { String name = gcmb.getName(); String gcName = null; if (minorGC.contains(name)) { gcName = "mgc"; } else if (fullGC.contains(name)) { gcName = "fgc"; } if (gcName == null) { continue; } instance.setValue(gcName + "_count", gcmb.getCollectionCount()); instance.setValue(gcName + "_time", gcmb.getCollectionTime()); } }
public static void main(String [] args) throws Exception { if (args.length != 1) { throw new IllegalArgumentException("Usage: <MetaspaceSize>"); } WhiteBox wb = WhiteBox.getWhiteBox(); // Allocate past the MetaspaceSize limit. long metaspaceSize = Long.parseLong(args[0]); long allocationBeyondMetaspaceSize = metaspaceSize * 2; long metaspace = wb.allocateMetaspace(null, allocationBeyondMetaspaceSize); // Wait for at least one GC to occur. The caller will parse the log files produced. GarbageCollectorMXBean cmsGCBean = getCMSGCBean(); while (cmsGCBean.getCollectionCount() == 0) { Thread.sleep(100); } wb.freeMetaspace(null, metaspace, metaspace); }
/** * Allocate (<b>ratio</b> * <b>maxSize</b> / 100) bytes of objects * and force at least "MaxTenuringThreshold" minor GCs. * * @param ratio ratio used to calculate how many objects should be allocated * @param maxSize estimated max survivor space size */ public static void allocateMemory(double ratio, long maxSize) throws Exception { GarbageCollectorMXBean youngGCBean = GCTypes.YoungGCType.getYoungGCBean(); long garbageSize = (long) (maxSize * (ratio / 100.0)); int arrayLength = (int) (garbageSize / CHUNK_SIZE); AllocationHelper allocator = new AllocationHelper(1, arrayLength, ARRAY_LENGTH, null); System.out.println(START_TEST); System.gc(); final long initialGcId = youngGCBean.getCollectionCount(); // allocate memory allocator.allocateMemoryAndVerify(); // force minor GC while (youngGCBean.getCollectionCount() <= initialGcId + MAX_TENURING_THRESHOLD * 2) { byte b[] = new byte[ARRAY_LENGTH]; } allocator.release(); System.out.println(END_TEST); }
/** * Check if the tenured generation are currently using a parallel GC. */ protected static boolean isTenuredParallelGC() { // Currently the only parallel GC for the tenured generation is PS MarkSweep. List<String> parallelGCs = Arrays.asList(new String[] { "PS MarkSweep"}); try { List<GarbageCollectorMXBean> beans = ManagementFactory.getGarbageCollectorMXBeans(); for (GarbageCollectorMXBean bean : beans) { if (parallelGCs.contains(bean.getName())) { return true; } } } catch (Exception e) { e.printStackTrace(); } return false; }
/** * Returns a map of garbage collectors and their stats. * The first object in the array is the total count since JVM start and the * second is the total time (ms) since JVM start. * If a garbage collectors does not support the collector MXBean, then it * will not be represented in the map. * @return A non-null map of garbage collectors and their metrics. The map * may be empty. */ public static Map<String, Long[]> getGCStatst() { final List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans(); final Map<String, Long[]> map = new HashMap<String, Long[]>(gcBeans.size()); for (final GarbageCollectorMXBean bean : gcBeans) { if (!bean.isValid() || bean.getCollectionCount() < 0 || bean.getCollectionTime() < 0) { continue; } final Long[] measurements = new Long[]{ bean.getCollectionCount(), bean.getCollectionTime() }; map.put(bean.getName().replace(" ", "_"), measurements); } return map; }
private static void instantiateGarbageCollectorMetrics(MetricGroup metrics) { List<GarbageCollectorMXBean> garbageCollectors = ManagementFactory.getGarbageCollectorMXBeans(); for (final GarbageCollectorMXBean garbageCollector: garbageCollectors) { MetricGroup gcGroup = metrics.addGroup(garbageCollector.getName()); gcGroup.<Long, Gauge<Long>>gauge("Count", new Gauge<Long> () { @Override public Long getValue() { return garbageCollector.getCollectionCount(); } }); gcGroup.<Long, Gauge<Long>>gauge("Time", new Gauge<Long> () { @Override public Long getValue() { return garbageCollector.getCollectionTime(); } }); } }
public static JVMInfo getJVMInfo() { JVMInfo jvmInfo = new JVMInfo(); Runtime runtime = Runtime.getRuntime(); jvmInfo.setFreeMemory(runtime.freeMemory()); jvmInfo.setTotalMemory(runtime.totalMemory()); jvmInfo.setMaxMemory(runtime.maxMemory()); int gcCount = 0; long gcTime = 0; for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) { long count = gc.getCollectionCount(); if (count >= 0) { gcCount += count; } long time = gc.getCollectionTime(); if (time >= 0) { gcTime += time; } } jvmInfo.setGcCount(gcCount); jvmInfo.setGcTime(gcTime); List<String> args = ManagementFactory.getRuntimeMXBean().getInputArguments(); jvmInfo.setArguments(joiner.join(args)); return jvmInfo; }
/** * Gets the garbage collection statistics from the JVM. * * @param gcMXBeans The collection of garbage collector beans. * @return A string denoting the number of times and total elapsed time in garbage collection. */ public static String getGarbageCollectorStatsAsString(List<GarbageCollectorMXBean> gcMXBeans) { StringBuilder bld = new StringBuilder("Garbage collector stats: "); for (GarbageCollectorMXBean bean : gcMXBeans) { bld.append('[').append(bean.getName()).append(", GC TIME (ms): ").append(bean.getCollectionTime()); bld.append(", GC COUNT: ").append(bean.getCollectionCount()).append(']'); bld.append(", "); } if (!gcMXBeans.isEmpty()) { bld.setLength(bld.length() - 2); } return bld.toString(); }
@Override public void handleNotification(Notification notification, Object handback) { try { // Make sure it's the right notification type if (!notification.getType().equals(GarbageCollectionNotificationInfo.GARBAGE_COLLECTION_NOTIFICATION)) return; // Extract the GcInfo as appropriate, working around the OpenJDK // GcInfo cycles/milliseconds bug GarbageCollectorMXBean bean = (GarbageCollectorMXBean) handback; GarbageCollectionNotificationInfo info = getInfo(notification); GcInfo gc = getGcInfo(info, bean); // Call the callback this.callback.onGC(gc); } catch (Exception e) { // swallow } }
public static void shutdown() throws InterruptedException { synchronized (LOCK) { List<GarbageCollectorMXBean> garbageCollectorMXBeans = ManagementFactory .getGarbageCollectorMXBeans(); ThreadRecorder.get().record(ExecutionType.FINAL_METADATA, Recorder.EmptyBlock, new Recorder.Property("build_time", Long.toString(System.currentTimeMillis() - sINSTANCE.startTime)), new Recorder.Property("gc_count", Long.toString(garbageCollectorMXBeans.get(0).getCollectionCount() - sINSTANCE.gcCountAtStart)), new Recorder.Property("gc_time", Long.toString(garbageCollectorMXBeans.get(0).getCollectionTime() - sINSTANCE.gcTimeAtStart))); if (sINSTANCE.isInitialized()) { sINSTANCE.get().finish(); sINSTANCE.uploadData(); } sINSTANCE.processRecorder = null; } }
private void getGCStats() { long currentGcCount = 0; long currentGcDuration = 0; for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) { long count = gc.getCollectionCount(); if (count >= 0) { currentGcCount += count; } long time = gc.getCollectionTime(); if (time >= 0) { currentGcDuration += time; } } logger.trace("number of GCs: " + (currentGcCount - lastGcCount) + " and time spent in GCs: " + (currentGcDuration - lastGcDuration) + "ms"); lastGcCount = currentGcCount; lastGcDuration = currentGcDuration; }
public static void main(String[] args) { Iterator beans = ManagementFactory.getGarbageCollectorMXBeans().iterator(); while (beans.hasNext()) { GarbageCollectorMXBean bean = (GarbageCollectorMXBean) beans.next(); System.out.println("Bean: " + bean); System.out.println("Name: " + bean.getName()); System.out.println("Memory pool names: " + Arrays.toString(bean.getMemoryPoolNames())); System.out.println("Is valid: " + (bean.isValid() ? "yes" : "no")); System.out.println("Collection count: " + bean.getCollectionCount()); System.out.println("Collection time: " + bean.getCollectionTime() + "ms"); } }
@Override public Map<String, Metric> getMetrics() { final Map<String, Metric> metrics = new HashMap(); for (final GarbageCollectorMXBean garbageCollectorMXBean : _garbageCollectorMXBeans) { final String collectorName = garbageCollectorMXBean.getName().replaceAll("[\\s]+", "_"); String timeName = String.format("time[collector:%s]", collectorName); metrics.put(timeName, new Gauge<Long>() { @Override public Long getValue() { return garbageCollectorMXBean.getCollectionTime(); } }); String runsName = String.format("runs[collector:%s]", collectorName); metrics.put(runsName, new Gauge<Long>() { @Override public Long getValue() { return garbageCollectorMXBean.getCollectionCount(); } }); } return metrics; }
@SuppressWarnings("UseOfSystemOutOrSystemErr") public static void reportTestExecutionStatistics() { System.out.println("----- TEST STATISTICS -----"); UsefulTestCase.logSetupTeardownCosts(); System.out.println(String.format("##teamcity[buildStatisticValue key='ideaTests.appInstancesCreated' value='%d']", MockApplication.INSTANCES_CREATED)); System.out.println(String.format("##teamcity[buildStatisticValue key='ideaTests.projectInstancesCreated' value='%d']", ProjectManagerImpl.TEST_PROJECTS_CREATED)); long totalGcTime = 0; for (GarbageCollectorMXBean mxBean : ManagementFactory.getGarbageCollectorMXBeans()) { totalGcTime += mxBean.getCollectionTime(); } System.out.println(String.format("##teamcity[buildStatisticValue key='ideaTests.gcTimeMs' value='%d']", totalGcTime)); System.out.println(String.format("##teamcity[buildStatisticValue key='ideaTests.classesLoaded' value='%d']", ManagementFactory.getClassLoadingMXBean().getTotalLoadedClassCount())); }
private JVMGC() { for (GarbageCollectorMXBean item : ManagementFactory.getGarbageCollectorMXBeans()) { if ("ConcurrentMarkSweep".equals(item.getName()) // || "MarkSweepCompact".equals(item.getName()) // || "PS MarkSweep".equals(item.getName()) // || "G1 Old Generation".equals(item.getName()) // || "Garbage collection optimized for short pausetimes Old Collector".equals(item.getName()) // || "Garbage collection optimized for throughput Old Collector".equals(item.getName()) // || "Garbage collection optimized for deterministic pausetimes Old Collector".equals(item.getName()) // ) { fullGC = item; } else if ("ParNew".equals(item.getName()) // || "Copy".equals(item.getName()) // || "PS Scavenge".equals(item.getName()) // || "G1 Young Generation".equals(item.getName()) // || "Garbage collection optimized for short pausetimes Young Collector".equals(item.getName()) // || "Garbage collection optimized for throughput Young Collector".equals(item.getName()) // || "Garbage collection optimized for deterministic pausetimes Young Collector".equals(item.getName()) // ) { youngGC = item; } } }
public static GcStatistics create(GcMonitorConfiguration configuration) { SortedMap<String, MonitoredCollector> monitoredCollectors = new TreeMap<>(); SortedMap<String, CollectorStatistics> perCollectorStatistics = new TreeMap<>(); List<GarbageCollectorMXBean> garbageCollectorMXBeans = configuration.getGarbageCollectorMXBeans(); long currentTimeMillis = configuration.getClock().currentTimeMillis(); Optional<CollectorStatistics> aggregatedStatistics; if (garbageCollectorMXBeans.size() > 1 && configuration.isAggregateDifferentCollectors()) { aggregatedStatistics = Optional.of(createCollectorStatistics(configuration, currentTimeMillis)); perCollectorStatistics.put(GcMonitorConfiguration.AGGREGATED_COLLECTOR_NAME, aggregatedStatistics.get()); } else { aggregatedStatistics = Optional.empty(); } for (GarbageCollectorMXBean bean : configuration.getGarbageCollectorMXBeans()) { CollectorStatistics collectorStatistics = createCollectorStatistics(configuration, currentTimeMillis); perCollectorStatistics.put(bean.getName(), collectorStatistics); MonitoredCollector monitoredCollector = new MonitoredCollector(bean, aggregatedStatistics, collectorStatistics); monitoredCollectors.put(bean.getName(), monitoredCollector); } return new GcStatistics(configuration, monitoredCollectors, perCollectorStatistics); }
private void checkMbeans(Collection<GarbageCollectorMXBean> garbageCollectorMXBeans) { if (garbageCollectorMXBeans == null) { throw new IllegalArgumentException("garbageCollectorMXBeans should not be null"); } if (garbageCollectorMXBeans.isEmpty()) { throw new IllegalArgumentException("garbageCollectorMXBeans should not be empty"); } Set<String> names = new HashSet<>(); for (GarbageCollectorMXBean bean : garbageCollectorMXBeans) { if (bean == null) { throw new IllegalArgumentException("garbageCollectorMXBeans should not contain null elements"); } String name = bean.getName(); if (names.contains(name)) { throw new IllegalArgumentException("garbageCollectorMXBeans contains two collectors with name [" + name + "]"); } names.add(name); } }
/** * Approx. time spent in gc. See {@link GarbageCollectorMXBean} */ public long getCollectionTime() { long garbageCollectionTime = 0; for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) { long time = gc.getCollectionTime(); if (time >= 0) { garbageCollectionTime += time; } } return garbageCollectionTime; }
