# HG changeset patch # User Andrew Azores # Date 1544559690 18000 # Tue Dec 11 15:21:30 2018 -0500 # Node ID 34d0714201d4f652251dacfea07ba945e5d3c123 # Parent b1fecedb897e0f392f7c9ccaac3e30e3d90dbedd JMC-5596: Rule to detect if there has been a Full GC with G1 or CMS Contributed-by: Andrew Azores diff --git a/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/memory/CollectorType.java b/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/memory/CollectorType.java --- a/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/memory/CollectorType.java +++ b/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/memory/CollectorType.java @@ -36,20 +36,39 @@ import org.openjdk.jmc.flightrecorder.jdk.JdkAggregators; public enum CollectorType { - SERIAL_OLD, PARALLEL_OLD, G1_OLD, CMS, UNKNOWN; - public static CollectorType getOldCollectorType(IItemCollection items) { - String oc = items.getAggregate(JdkAggregators.OLD_COLLECTOR); + CMS("ConcurrentMarkSweep"), //$NON-NLS-1$ + DEF_NEW("DefNew"), //$NON-NLS-1$ + G1_FULL("G1Full"), //$NON-NLS-1$ + G1_NEW("G1New"), //$NON-NLS-1$ + G1_OLD("G1Old"), //$NON-NLS-1$ + PAR_NEW("ParNew"), //$NON-NLS-1$ + PARALLEL_OLD("ParallelOld"), //$NON-NLS-1$ + PARALLEL_SCAVENGE("ParallelScavenge"), //$NON-NLS-1$ + PS_MARK_SWEEP("PSMarkSweep"), //$NON-NLS-1$ + SERIAL_OLD("SerialOld"), //$NON-NLS-1$, + Z("Z"), //$NON-NLS-1$ + NA("N/A"), //$NON-NLS-1$ + UNKNOWN(""), //$NON-NLS-1$ + ; + + private final String collectorName; + + private CollectorType(final String collectorName) { + this.collectorName = collectorName; + } + + public String getCollectorName() { + return this.collectorName; + } + + public static CollectorType getOldCollectorType(final IItemCollection items) { + final String oc = items.getAggregate(JdkAggregators.OLD_COLLECTOR); if (oc != null) { - switch (oc) { - case "SerialOld": //$NON-NLS-1$ - return CollectorType.SERIAL_OLD; - case "ParallelOld": //$NON-NLS-1$ - return CollectorType.PARALLEL_OLD; - case "ConcurrentMarkSweep": //$NON-NLS-1$ - return CollectorType.CMS; - case "G1Old": //$NON-NLS-1$ - return CollectorType.G1_OLD; + for (final CollectorType collectorType : CollectorType.values()) { + if (collectorType.getCollectorName().equals(oc)) { + return collectorType; + } } } return CollectorType.UNKNOWN; diff --git a/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/memory/FullGcRule.java b/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/memory/FullGcRule.java new file mode 100644 --- /dev/null +++ b/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/memory/FullGcRule.java @@ -0,0 +1,163 @@ +package org.openjdk.jmc.flightrecorder.rules.jdk.memory; + +import static org.openjdk.jmc.common.unit.UnitLookup.NUMBER_UNITY; + +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.concurrent.Callable; +import java.util.concurrent.FutureTask; +import java.util.concurrent.RunnableFuture; + +import org.openjdk.jmc.common.item.Aggregators; +import org.openjdk.jmc.common.item.Aggregators.MergingAggregator; +import org.openjdk.jmc.common.item.IItem; +import org.openjdk.jmc.common.item.IItemCollection; +import org.openjdk.jmc.common.item.IItemConsumer; +import org.openjdk.jmc.common.item.IMemberAccessor; +import org.openjdk.jmc.common.item.IType; +import org.openjdk.jmc.common.unit.IQuantity; +import org.openjdk.jmc.common.unit.UnitLookup; +import org.openjdk.jmc.common.util.IPreferenceValueProvider; +import org.openjdk.jmc.common.util.TypedPreference; +import org.openjdk.jmc.flightrecorder.jdk.JdkAttributes; +import org.openjdk.jmc.flightrecorder.jdk.JdkFilters; +import org.openjdk.jmc.flightrecorder.jdk.JdkTypeIDs; +import org.openjdk.jmc.flightrecorder.rules.IRule; +import org.openjdk.jmc.flightrecorder.rules.Result; +import org.openjdk.jmc.flightrecorder.rules.jdk.messages.internal.Messages; +import org.openjdk.jmc.flightrecorder.rules.util.JfrRuleTopics; +import org.openjdk.jmc.flightrecorder.rules.util.RulesToolkit; +import org.openjdk.jmc.flightrecorder.rules.util.RulesToolkit.EventAvailability; + +public class FullGcRule implements IRule { + private static final String FULL_GC_RESULT_ID = "FullGc"; //$NON-NLS-1$ + + @Override + public RunnableFuture evaluate(final IItemCollection items, final IPreferenceValueProvider valueProvider) { + return new FutureTask<>(new Callable() { + @Override + public Result call() throws Exception { + final CollectorType collectorType = CollectorType.getOldCollectorType(items); + if (!(CollectorType.CMS.equals(collectorType) || CollectorType.G1_OLD.equals(collectorType))) { + return RulesToolkit.getNotApplicableResult( + FullGcRule.this, + Messages.getString(Messages.FullGcRule_OTHER_COLLECTOR_IN_USE) + ); + } + + final String[] eventTypes; + if (CollectorType.CMS.equals(collectorType)) { + eventTypes = new String[] { JdkTypeIDs.GC_COLLECTOR_OLD_GARBAGE_COLLECTION }; + } else { + eventTypes = G1Aggregator.EVENT_TYPES; + } + if (!hasAvailableEvents(items, eventTypes)) { + return RulesToolkit.getEventAvailabilityResult( + FullGcRule.this, + items, + RulesToolkit.getEventAvailability(items, eventTypes), + eventTypes + ); + } + + final int fullGCs; + if (CollectorType.CMS.equals(collectorType)) { + final IQuantity c = items.getAggregate(Aggregators.count(null, null, JdkFilters.CONCURRENT_MODE_FAILURE)); + fullGCs = c == null ? 0 : c.clampedIntFloorIn(NUMBER_UNITY); + } else { + fullGCs = items.getAggregate(new G1Aggregator()).fullGCs; + } + + if (fullGCs > 0) { + return new Result( + FullGcRule.this, 100, + Messages.getString(Messages.FullGcRule_FULL_GC_OCCURRED_TITLE), + Messages.getString(Messages.FullGcRule_FULL_GC_OCCURRED_DESC) + ); + } else { + return new Result( + FullGcRule.this, + 0, + Messages.getString(Messages.FullGcRule_NO_FULL_GC_OCCURRED) + ); + } + } + }); + } + + private boolean hasAvailableEvents(final IItemCollection items, final String[] eventTypes) { + return RulesToolkit.getEventAvailability(items, eventTypes) == EventAvailability.AVAILABLE; + } + + @Override + public Collection> getConfigurationAttributes() { + return Collections.emptyList(); + } + + @Override + public String getId() { + return FULL_GC_RESULT_ID; + } + + @Override + public String getName() { + return Messages.getString(Messages.FullGcRule_RULE_NAME); + } + + @Override + public String getTopic() { + return JfrRuleTopics.GARBAGE_COLLECTION_TOPIC; + } + + private static class G1Aggregator extends MergingAggregator { + static final String[] EVENT_TYPES = new String[] { JdkTypeIDs.GARBAGE_COLLECTION }; + + G1Aggregator() { + super(null, null, UnitLookup.UNKNOWN); + } + + @Override + public final boolean acceptType(final IType type) { + return Arrays.asList(EVENT_TYPES).contains(type.getIdentifier()); + } + + @Override + public G1FullGCInfo newItemConsumer(final IType type) { + return new G1FullGCInfo(JdkAttributes.GC_NAME.getAccessor(type)); + } + + @Override + public G1FullGCInfo getValue(final G1FullGCInfo consumer) { + return consumer == null ? new G1FullGCInfo(null) : consumer; + } + } + + private static class G1FullGCInfo implements IItemConsumer { + private final IMemberAccessor accessor; + + G1FullGCInfo(final IMemberAccessor accessor) { + this.accessor = accessor; + } + + int fullGCs = 0; + + @Override + public G1FullGCInfo merge(final G1FullGCInfo other) { + this.fullGCs += other.fullGCs; + return this; + } + + @Override + public void consume(final IItem item) { + if (this.accessor == null) { + return; + } + final String gcName = this.accessor.getMember(item); + if (gcName.equals(CollectorType.G1_FULL.getCollectorName())) { + this.fullGCs++; + } + } + } + +} diff --git a/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/memory/GarbageCollectionsInfo.java b/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/memory/GarbageCollectionsInfo.java --- a/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/memory/GarbageCollectionsInfo.java +++ b/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/memory/GarbageCollectionsInfo.java @@ -88,7 +88,7 @@ if ("gclocker".equalsIgnoreCase(cause)) { //$NON-NLS-1$ gcLockers++; } - if (!nonRequestedSerialOldGc && "SerialOld".equals(nameAccessor.getMember(item))) { //$NON-NLS-1$ + if (!nonRequestedSerialOldGc && CollectorType.SERIAL_OLD.getCollectorName().equals(nameAccessor.getMember(item))) { nonRequestedSerialOldGc = true; } } diff --git a/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/messages/internal/Messages.java b/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/messages/internal/Messages.java --- a/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/messages/internal/Messages.java +++ b/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/java/org/openjdk/jmc/flightrecorder/rules/jdk/messages/internal/Messages.java @@ -246,6 +246,11 @@ public static final String FlightRecordingSupportRule_TEXT_OK = "FlightRecordingSupportRule_TEXT_OK"; //$NON-NLS-1$ public static final String FlightRecordingSupportRule_UNSUPPORTED_TEXT_WARN_LONG = "FlightRecordingSupportRule_UNSUPPORTED_TEXT_WARN_LONG"; //$NON-NLS-1$ public static final String FlightRecordingSupportRule_UNSUPPORTED_TEXT_WARN_SHORT = "FlightRecordingSupportRule_UNSUPPORTED_TEXT_WARN_SHORT"; //$NON-NLS-1$ + public static final String FullGcRule_RULE_NAME="FullGcRule_RULE_NAME"; //$NON-NLS-1$ + public static final String FullGcRule_OTHER_COLLECTOR_IN_USE="FullGcRule_OTHER_COLLECTOR_IN_USE"; //$NON-NLS-1$ + public static final String FullGcRule_FULL_GC_OCCURRED_TITLE="FullGcRule_FULL_GC_OCCURRED_TITLE"; //$NON-NLS-1$ + public static final String FullGcRule_FULL_GC_OCCURRED_DESC="FullGcRule_FULL_GC_OCCURRED_DESC"; //$NON-NLS-1$ + public static final String FullGcRule_NO_FULL_GC_OCCURRED="FullGcRule_NO_FULL_GC_OCCURRED"; //$NON-NLS-1$ public static final String GcFreedRatioRule_FEW_GCS_LIMIT = "GcFreedRatioRule_FEW_GCS_LIMIT"; //$NON-NLS-1$ public static final String GcFreedRatioRule_FEW_GCS_LIMIT_DESC = "GcFreedRatioRule_FEW_GCS_LIMIT_DESC"; //$NON-NLS-1$ public static final String GcFreedRatioRule_GC_FREED_RATIO_INFO_LIMIT = "GcFreedRatioRule_GC_FREED_RATIO_INFO_LIMIT"; //$NON-NLS-1$ diff --git a/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/resources/META-INF/services/org.openjdk.jmc.flightrecorder.rules.IRule b/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/resources/META-INF/services/org.openjdk.jmc.flightrecorder.rules.IRule --- a/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/resources/META-INF/services/org.openjdk.jmc.flightrecorder.rules.IRule +++ b/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/resources/META-INF/services/org.openjdk.jmc.flightrecorder.rules.IRule @@ -71,6 +71,7 @@ org.openjdk.jmc.flightrecorder.rules.jdk.memory.ApplicationHaltsRule org.openjdk.jmc.flightrecorder.rules.jdk.memory.AutoBoxingRule org.openjdk.jmc.flightrecorder.rules.jdk.memory.CompressedOopsRule +org.openjdk.jmc.flightrecorder.rules.jdk.memory.FullGcRule org.openjdk.jmc.flightrecorder.rules.jdk.memory.GcLockerRule org.openjdk.jmc.flightrecorder.rules.jdk.memory.GcStallRule org.openjdk.jmc.flightrecorder.rules.jdk.memory.GcFreedRatioRule diff --git a/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/resources/org/openjdk/jmc/flightrecorder/rules/jdk/messages/internal/messages.properties b/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/resources/org/openjdk/jmc/flightrecorder/rules/jdk/messages/internal/messages.properties --- a/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/resources/org/openjdk/jmc/flightrecorder/rules/jdk/messages/internal/messages.properties +++ b/core/org.openjdk.jmc.flightrecorder.rules.jdk/src/main/resources/org/openjdk/jmc/flightrecorder/rules/jdk/messages/internal/messages.properties @@ -260,6 +260,12 @@ FlightRecordingSupportRule_UNSUPPORTED_TEXT_WARN_SHORT=The recording is from an unsupported JRE version. FlightRecordingSupportRule_UNSUPPORTED_TEXT_WARN_LONG=This recording is from a runtime with JRE version {0}, before JDK Flight Recorder was fully supported in HotSpot. Versions before 7u40 only have partial support for flight recordings. The automated analysis is not supported, and you may see errors when attempting to analyze this recording. +FullGcRule_RULE_NAME=G1/CMS Full Collection +FullGcRule_OTHER_COLLECTOR_IN_USE=This rule is only valid for CMS and G1 Garbage Collectors, neither of which were detected for this JVM. +FullGcRule_FULL_GC_OCCURRED_TITLE=Full GC detected. +FullGcRule_FULL_GC_OCCURRED_DESC=At least one Full, Stop-The-World Garbage Collection occurred during this recording. For the CMS and G1 collectors, Full GC events are a strong negative performance indicator. Tunable GC parameters can be used to allow the collector to operate in concurrent mode, avoiding Stop-The-World pauses and increasing GC and application performance. +FullGcRule_NO_FULL_GC_OCCURRED=No Stop-the-World, Full GC events detected. + GcFreedRatioRule_RULE_NAME=GC Freed Ratio GcFreedRatioRule_GC_FREED_RATIO_INFO_LIMIT=Memory freed per second compared to liveset size info limit GcFreedRatioRule_GC_FREED_RATIO_INFO_LIMIT_DESC=Ratio between the amount of memory freed by garbage collections per second compared to the liveset needed to trigger an info notice. diff --git a/core/org.openjdk.jmc.flightrecorder/src/main/java/org/openjdk/jmc/flightrecorder/jdk/JdkFilters.java b/core/org.openjdk.jmc.flightrecorder/src/main/java/org/openjdk/jmc/flightrecorder/jdk/JdkFilters.java --- a/core/org.openjdk.jmc.flightrecorder/src/main/java/org/openjdk/jmc/flightrecorder/jdk/JdkFilters.java +++ b/core/org.openjdk.jmc.flightrecorder/src/main/java/org/openjdk/jmc/flightrecorder/jdk/JdkFilters.java @@ -79,6 +79,7 @@ JdkTypeIDs.ALLOC_OUTSIDE_TLAB); public static final IItemFilter REFERENCE_STATISTICS = ItemFilters.type(JdkTypeIDs.GC_REFERENCE_STATISTICS); public static final IItemFilter GARBAGE_COLLECTION = ItemFilters.type(JdkTypeIDs.GARBAGE_COLLECTION); + public static final IItemFilter OLD_GARBAGE_COLLECTION = ItemFilters.type(JdkTypeIDs.GC_COLLECTOR_OLD_GARBAGE_COLLECTION); public static final IItemFilter CONCURRENT_MODE_FAILURE = ItemFilters.type(JdkTypeIDs.CONCURRENT_MODE_FAILURE); public static final IItemFilter ERRORS = ItemFilters.type(JdkTypeIDs.ERRORS_THROWN); public static final IItemFilter EXCEPTIONS = ItemFilters.type(JdkTypeIDs.EXCEPTIONS_THROWN); diff --git a/core/org.openjdk.jmc.flightrecorder/src/main/java/org/openjdk/jmc/flightrecorder/jdk/JdkTypeIDs.java b/core/org.openjdk.jmc.flightrecorder/src/main/java/org/openjdk/jmc/flightrecorder/jdk/JdkTypeIDs.java --- a/core/org.openjdk.jmc.flightrecorder/src/main/java/org/openjdk/jmc/flightrecorder/jdk/JdkTypeIDs.java +++ b/core/org.openjdk.jmc.flightrecorder/src/main/java/org/openjdk/jmc/flightrecorder/jdk/JdkTypeIDs.java @@ -100,6 +100,7 @@ public static final String GC_PAUSE = PREFIX + "GCPhasePause"; public static final String METASPACE_SUMMARY = PREFIX + "MetaspaceSummary"; + public static final String FULL_COLLECTION = PREFIX + "FullCollection"; public static final String GARBAGE_COLLECTION = PREFIX + "GarbageCollection"; public static final String CONCURRENT_MODE_FAILURE = PREFIX + "ConcurrentModeFailure"; diff --git a/core/tests/org.openjdk.jmc.flightrecorder.rules.jdk.test/src/test/resources/baseline/JfrRuleBaseline.xml b/core/tests/org.openjdk.jmc.flightrecorder.rules.jdk.test/src/test/resources/baseline/JfrRuleBaseline.xml --- a/core/tests/org.openjdk.jmc.flightrecorder.rules.jdk.test/src/test/resources/baseline/JfrRuleBaseline.xml +++ b/core/tests/org.openjdk.jmc.flightrecorder.rules.jdk.test/src/test/resources/baseline/JfrRuleBaseline.xml @@ -196,6 +196,13 @@ The JVM version used for this recording has full Flight Recorder support. +FullGc +OK +0.0 +No Stop-the-World, Full GC events detected. +No Stop-the-World, Full GC events detected. + + GcFreedRatio Information 34.4635049904725 @@ -591,6 +598,13 @@ The JVM version used for this recording has full Flight Recorder support. +FullGc +Not Applicable +-1.0 +This rule requires events to be available from the following event types: 'Garbage Collection'. +The G1/CMS Full Collection rule requires events to be available from the following event types: 'Garbage Collection'.<p>They were either disabled during the recording or there might not have happened anything to trigger an event. Event settings like period and threshold may also prevent some events from being emitted. If you are using JMC to create a flight recording, then you can enable and configure event types in the Start Flight Recording wizard. If you are starting the flight recording from the command line, then you can use the settings parameter of <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html">-XX:FlightRecorderOptions</a>. + + GcFreedRatio OK 0.0 @@ -986,6 +1000,13 @@ The JVM version used for this recording has full Flight Recorder support. +FullGc +Not Applicable +-1.0 +This rule requires events to be available from the following event types: 'Garbage Collection'. +The G1/CMS Full Collection rule requires events to be available from the following event types: 'Garbage Collection'.<p>They were either disabled during the recording or there might not have happened anything to trigger an event. Event settings like period and threshold may also prevent some events from being emitted. If you are using JMC to create a flight recording, then you can enable and configure event types in the Start Flight Recording wizard. If you are starting the flight recording from the command line, then you can use the settings parameter of <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html">-XX:FlightRecorderOptions</a>. + + GcFreedRatio OK 0.0 @@ -1381,6 +1402,13 @@ The JVM version used for this recording has full Flight Recorder support. +FullGc +Not Applicable +-1.0 +This rule is only valid for CMS and G1 Garbage Collectors, neither of which were detected for this JVM. +This rule is only valid for CMS and G1 Garbage Collectors, neither of which were detected for this JVM. + + GcFreedRatio Not Applicable -1.0 @@ -1776,6 +1804,13 @@ This recording is from an early access build of the JRE (Java HotSpot(TM) Client VM (25.20-b08) for linux-x86 JRE (1.8.0_20-ea-b08), built on Apr 1 2014 19:40:24 by "java_re" with gcc 4.3.0 20080428 (Red Hat 4.3.0-8)). The automated analysis is not supported, and you may see errors when attempting to analyze the recording. +FullGc +Not Applicable +-1.0 +This rule requires events to be available from the following event types: 'Garbage Collection'. +The G1/CMS Full Collection rule requires events to be available from the following event types: 'Garbage Collection'.<p>They were either disabled during the recording or there might not have happened anything to trigger an event. Event settings like period and threshold may also prevent some events from being emitted. If you are using JMC to create a flight recording, then you can enable and configure event types in the Start Flight Recording wizard. If you are starting the flight recording from the command line, then you can use the settings parameter of <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html">-XX:FlightRecorderOptions</a>. + + GcFreedRatio OK 0.0 @@ -2171,6 +2206,13 @@ This recording is from an early access build of the JRE (Java HotSpot(TM) Client VM (25.20-b08) for linux-x86 JRE (1.8.0_20-ea-b08), built on Apr 1 2014 19:40:24 by "java_re" with gcc 4.3.0 20080428 (Red Hat 4.3.0-8)). The automated analysis is not supported, and you may see errors when attempting to analyze the recording. +FullGc +Not Applicable +-1.0 +This rule is only valid for CMS and G1 Garbage Collectors, neither of which were detected for this JVM. +This rule is only valid for CMS and G1 Garbage Collectors, neither of which were detected for this JVM. + + GcFreedRatio OK 0.0 @@ -2566,6 +2608,13 @@ The JVM version used for this recording has full Flight Recorder support. +FullGc +OK +0.0 +No Stop-the-World, Full GC events detected. +No Stop-the-World, Full GC events detected. + + GcFreedRatio OK 0.0 @@ -2961,6 +3010,13 @@ The JVM version used for this recording has full Flight Recorder support. +FullGc +Not Applicable +-1.0 +This rule is only valid for CMS and G1 Garbage Collectors, neither of which were detected for this JVM. +This rule is only valid for CMS and G1 Garbage Collectors, neither of which were detected for this JVM. + + GcFreedRatio OK 1.4318707405222828 @@ -3358,6 +3414,13 @@ This recording is from an early access build of the JRE (Java HotSpot(TM) 64-Bit Server VM (9-ea+148) for windows-amd64 JRE (9-ea+148), built on Dec 7 2016 18:47:38 by "javare" with MS VC++ 12.0 (VS2013)). The automated analysis is not supported, and you may see errors when attempting to analyze the recording. +FullGc +Not Applicable +-1.0 +This rule is only valid for CMS and G1 Garbage Collectors, neither of which were detected for this JVM. +This rule is only valid for CMS and G1 Garbage Collectors, neither of which were detected for this JVM. + + GcFreedRatio Not Applicable -1.0