From b55dafeae44c1f507a2e9e7c46e2493c131404f2 Mon Sep 17 00:00:00 2001 From: Kirk Pepperdine Date: Wed, 27 Mar 2024 07:07:36 -0700 Subject: [PATCH] I need a title (#344) * bug: intermediate commit to allow work on another bug * bug: add more robust handling of IllegalArgumentException in GCToolKit::analyize * tidy: remove debug to stdout to logging framework * refactor: Ensure DateTimeStamp cannot be malformed and it behaves if the timestamp is missing * refactor: update pom for new GC log test data bundle * tidy: address comments from PR * Update parser/src/main/java/com/microsoft/gctoolkit/parser/GCLogParser.java * feature: first push to combine CMS parser with GenerationalHeapParser * depreciate: depreciated the CMS preunified event source * refactor: get all tests to pass * refactor: continue to get tests to pass * refactor: continue to get tests to pass * refactor: collapse CMS phases parser into generational parser * refactor: GenerationalHeapParser was duplicating CMF failures under certain conditions * refactor: ensure GC log is closed when discovering the format * refactor: add test for reported bug * refactor: add ability to parse very simple logs preunified logs * refactor: remove no longer needed print statement * refactor: tidy from review --------- Co-authored-by: Martijn Verburg --- .../aggregation/CMSCycleAggregator.java | 2 +- .../gctoolkit/integration/CMSEventsTest.java | 4 +- .../com/microsoft/gctoolkit/io/GCLogFile.java | 4 +- .../com/microsoft/gctoolkit/jvm/Diarizer.java | 2 - .../gctoolkit/parser/AbstractLogTrace.java | 19 +- .../parser/GenerationalHeapParser.java | 10 +- .../parser/jvm/PreUnifiedDiarizer.java | 499 +++++++++--------- .../gctoolkit/parser/jvm/UnifiedDiarizer.java | 91 ++-- .../parser/GenerationalHeapParserTest.java | 143 +++-- .../gctoolkit/parser/ParserTest.java | 4 + .../parser/UnifiedG1GCParserFragmentTest.java | 96 ++++ .../gctoolkit/parser/diary/LogDiaryTest.java | 2 +- .../parser/unittests/CMSParNewParserTest.java | 16 +- .../unittests/ICMSParNewParserTest.java | 17 +- .../parser/unittests/ParserTest.java | 2 - 15 files changed, 546 insertions(+), 365 deletions(-) create mode 100644 parser/src/test/java/com/microsoft/gctoolkit/parser/UnifiedG1GCParserFragmentTest.java diff --git a/IT/src/main/java/com/microsoft/gctoolkit/integration/aggregation/CMSCycleAggregator.java b/IT/src/main/java/com/microsoft/gctoolkit/integration/aggregation/CMSCycleAggregator.java index b37455ef..d4d4f9a7 100644 --- a/IT/src/main/java/com/microsoft/gctoolkit/integration/aggregation/CMSCycleAggregator.java +++ b/IT/src/main/java/com/microsoft/gctoolkit/integration/aggregation/CMSCycleAggregator.java @@ -7,6 +7,7 @@ import com.microsoft.gctoolkit.event.generational.CMSRemark; import com.microsoft.gctoolkit.event.generational.InitialMark; + @Aggregates({EventSource.GENERATIONAL}) public class CMSCycleAggregator extends Aggregator { @@ -26,7 +27,6 @@ public void count(InitialMark event) { } public void count(CMSRemark event) { - System.out.println(event.toString()); if ( event.equals(lastRemark)) return; lastRemark = event; aggregation().remark(); diff --git a/IT/src/test/java/com/microsoft/gctoolkit/integration/CMSEventsTest.java b/IT/src/test/java/com/microsoft/gctoolkit/integration/CMSEventsTest.java index 6a8f6227..ba5af07a 100644 --- a/IT/src/test/java/com/microsoft/gctoolkit/integration/CMSEventsTest.java +++ b/IT/src/test/java/com/microsoft/gctoolkit/integration/CMSEventsTest.java @@ -51,8 +51,8 @@ public void analyze(String gcLogFile) { machine.getAggregation(CMSCycleAggregation.class).ifPresent(cmsCycleCounts -> { Assertions.assertEquals( 1, cmsCycleCounts.getInitialMark(), "Initial Mark events count"); - //Assertions.assertEquals( 1, cmsCycleCounts.getRemark(), "Remark events count"); - //Assertions.assertEquals( 4, cmsCycleCounts.getConcurrentEvent(), "concurrent phase events count"); + Assertions.assertEquals( 1, cmsCycleCounts.getRemark(), "Remark events count"); + Assertions.assertEquals( 5, cmsCycleCounts.getConcurrentEvent(), "concurrent phase events count"); }); } diff --git a/api/src/main/java/com/microsoft/gctoolkit/io/GCLogFile.java b/api/src/main/java/com/microsoft/gctoolkit/io/GCLogFile.java index bbe7d09a..cf0e7e63 100644 --- a/api/src/main/java/com/microsoft/gctoolkit/io/GCLogFile.java +++ b/api/src/main/java/com/microsoft/gctoolkit/io/GCLogFile.java @@ -127,8 +127,8 @@ public final String endOfData() { * @throws IOException Thrown from reading the stream. */ private TripleState discoverFormat() { - try { - boolean isUnified = firstNLines(stream(), SHOULD_HAVE_SEEN_A_UNIFIED_DECORATOR_BY_THIS_LINE_IN_THE_LOG) + try (Stream stream = stream()) { // contribution from MansuyDavid @github + boolean isUnified = firstNLines(stream, SHOULD_HAVE_SEEN_A_UNIFIED_DECORATOR_BY_THIS_LINE_IN_THE_LOG) .map(LINE_STARTS_WITH_DECORATOR::matcher) .anyMatch(Matcher::find); return TripleState.valueOf(isUnified); diff --git a/api/src/main/java/com/microsoft/gctoolkit/jvm/Diarizer.java b/api/src/main/java/com/microsoft/gctoolkit/jvm/Diarizer.java index 4ddb8adf..89329a57 100644 --- a/api/src/main/java/com/microsoft/gctoolkit/jvm/Diarizer.java +++ b/api/src/main/java/com/microsoft/gctoolkit/jvm/Diarizer.java @@ -22,8 +22,6 @@ public interface Diarizer { boolean completed(); - void fillInKnowns(); - boolean diarize(String line); } diff --git a/parser/src/main/java/com/microsoft/gctoolkit/parser/AbstractLogTrace.java b/parser/src/main/java/com/microsoft/gctoolkit/parser/AbstractLogTrace.java index 89f2115c..dc238e74 100644 --- a/parser/src/main/java/com/microsoft/gctoolkit/parser/AbstractLogTrace.java +++ b/parser/src/main/java/com/microsoft/gctoolkit/parser/AbstractLogTrace.java @@ -76,13 +76,28 @@ public String getDateStamp() { } } + /** + * + * @return the date timestamp paring found at the beginning of the GC log line. + */ public DateTimeStamp getDateTimeStamp() { return getDateTimeStamp(1); } - public DateTimeStamp getDateTimeStamp(int index) { + /** + * If a line contains multiple date timestamp group pairing then return the nth pair. + * The following example contains 3 different date timestamps. index of 1 yields 57724.218 + * whereas index 3 yields 2010-04-21T10:45:33.367+0100@57724.319 + * + * 57724.218: [Full GC 57724.218: [CMS2010-04-21T10:45:33.367+0100: 57724.319: [CMS-concurrent-mark: 2.519/2.587 secs] + * + * one time stamp or a date timestamp pairing + * @param nth is date timestamp field pair to be returned + * @return the nth date timestamp pairing + */ + public DateTimeStamp getDateTimeStamp(int nth) { Matcher matcher = DATE_TIME_STAMP_RULE.matcher(trace.group(0)); - for (int i = 0; i < index - 1; i++) + for (int i = 0; i < nth - 1; i++) if (!matcher.find()) break; if (matcher.find()) { diff --git a/parser/src/main/java/com/microsoft/gctoolkit/parser/GenerationalHeapParser.java b/parser/src/main/java/com/microsoft/gctoolkit/parser/GenerationalHeapParser.java index 9caa4daf..9e2610ca 100644 --- a/parser/src/main/java/com/microsoft/gctoolkit/parser/GenerationalHeapParser.java +++ b/parser/src/main/java/com/microsoft/gctoolkit/parser/GenerationalHeapParser.java @@ -488,6 +488,7 @@ private void parNewFLSTime(GCLogTrace trace, String line) { MemoryPoolSummary heap = new MemoryPoolSummary(heapForwardReference.getOccupancyBeforeCollection(), heapForwardReference.getSizeAfterCollection(), heapForwardReference.getOccupancyBeforeCollection(), heapForwardReference.getSizeAfterCollection()); FullGC fullGc = new FullGC(fullGCTimeStamp, gcCauseForwardReference, trace.getDuration()); fullGc.add(heap); + fullGc.add(extractCPUSummary(line)); publish(fullGc); } else LOGGER.warning("Unable to parse -> " + trace); @@ -1173,6 +1174,7 @@ public void fullGCInterruptsConcurrentPhase(GCLogTrace trace, String line) { fullGCTimeStamp = getClock(); garbageCollectionTypeForwardReference = GarbageCollectionTypes.FullGC; gcCauseForwardReference = trace.gcCause(); + endOfConcurrentPhase(trace,trace.getDateTimeStamp(3), 5); } public void fullGCReferenceConcurrentModeFailure(GCLogTrace trace, String line) { @@ -2054,6 +2056,8 @@ private void log(String line) { // if (line.startsWith("}")) return; // if (line.startsWith("Heap")) return; // if (line.startsWith("[Times: user")) return; + if ( line.startsWith("Metaspace used")) return; + if ( line.startsWith("class space used")) return; if (line.startsWith("par new generation total")) return; // if (line.startsWith("concurrent mark-sweep generation total")) return; if (line.startsWith("concurrent-mark-sweep perm gen total")) return; @@ -2068,6 +2072,7 @@ private void log(String line) { // if (line.contains("Large block")) return; // // GCToolKit.LOG_DEBUG_MESSAGE(() -> "GenerationalHeapParser missed: " + line); + if (line.contains("CMSCMS: Large block")) return; LOGGER.log(Level.WARNING, "Missed: {0}", line); } @@ -2119,6 +2124,9 @@ private void endOfConcurrentPhase(GCLogTrace trace, DateTimeStamp timeStamp, int double cpuTime = trace.getDoubleGroup(4 + offset); double wallTime = trace.getDoubleGroup(5 + offset); double duration = timeStamp.toSeconds() - startOfConcurrentPhase.toSeconds(); + // The wallTime measure is a very good estimate of duration. + if ( duration == Double.NaN) + duration = wallTime; if ("mark".equals(phase)) publish(new ConcurrentMark(startOfConcurrentPhase, duration, cpuTime, wallTime)); else if ("preclean".equals(phase)) @@ -2158,12 +2166,12 @@ private void clear() { } public void publish( JVMEvent event, boolean drain, boolean clear) { + publish(event,clear); if (drain) { for( GenerationalGCPauseEvent pauseEvent : queue) publish(pauseEvent, false); queue.clear(); } - publish(event,clear); } public void publish(JVMEvent event, boolean clear) { diff --git a/parser/src/main/java/com/microsoft/gctoolkit/parser/jvm/PreUnifiedDiarizer.java b/parser/src/main/java/com/microsoft/gctoolkit/parser/jvm/PreUnifiedDiarizer.java index b9398aee..d23815de 100644 --- a/parser/src/main/java/com/microsoft/gctoolkit/parser/jvm/PreUnifiedDiarizer.java +++ b/parser/src/main/java/com/microsoft/gctoolkit/parser/jvm/PreUnifiedDiarizer.java @@ -109,6 +109,7 @@ public PreUnifiedDiarizer() {} @Override public Diary getDiary() { + fillInKnowns(); return diary; } @@ -145,56 +146,56 @@ public int getMaxTenuringThreshold() { @Override public boolean hasJVMEvents() { - return getDiary().isApplicationStoppedTime() || - getDiary().isApplicationRunningTime() || - getDiary().isApplicationRunningTime() || - getDiary().isTLABData(); + return diary.isApplicationStoppedTime() || + diary.isApplicationRunningTime() || + diary.isApplicationRunningTime() || + diary.isTLABData(); } private boolean versionIsKnown() { - return (getDiary().isStateKnown(SupportedFlags.JDK80) && getDiary().isStateKnown(SupportedFlags.JDK70)) && getDiary().isStateKnown(SupportedFlags.PRE_JDK70_40); + return (diary.isStateKnown(SupportedFlags.JDK80) && diary.isStateKnown(SupportedFlags.JDK70)) && diary.isStateKnown(SupportedFlags.PRE_JDK70_40); } @Override public boolean completed() { - return getDiary().isComplete() || lineCount < 1 || (simpleCMSCycleDetected && (simpleCMSCycleDetected || simpleFullGCDetected)); + return diary.isComplete() || lineCount < 1 || (simpleCMSCycleDetected && (simpleCMSCycleDetected || simpleFullGCDetected)); } // Things that if we've not seen them, we know that they are false. - public void fillInKnowns() { + private void fillInKnowns() { if (simpleCMSCycleDetected) { - getDiary().setTrue(SupportedFlags.CMS); - getDiary().setFalse(SupportedFlags.SERIAL, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.ICMS, SupportedFlags.G1GC, SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.GC_CAUSE, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.ADAPTIVE_SIZING, SupportedFlags.PRINT_HEAP_AT_GC, SupportedFlags.RSET_STATS, SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40, SupportedFlags.JDK80); + diary.setTrue(SupportedFlags.CMS); + diary.setFalse(SupportedFlags.SERIAL, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.ICMS, SupportedFlags.G1GC, SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.GC_CAUSE, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.ADAPTIVE_SIZING, SupportedFlags.PRINT_HEAP_AT_GC, SupportedFlags.RSET_STATS, SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40, SupportedFlags.JDK80); // if we have age table or if no tenuring distribution, assume default ParNew/CMS - if (youngCollectionCount == 0 || ageTableDetected || !getDiary().isTenuringDistribution()) { - getDiary().setTrue(SupportedFlags.PARNEW); - getDiary().setFalse(SupportedFlags.DEFNEW); + if (youngCollectionCount == 0 || ageTableDetected || !diary.isTenuringDistribution()) { + diary.setTrue(SupportedFlags.PARNEW); + diary.setFalse(SupportedFlags.DEFNEW); } else { //CMS with no age table implies DEFNEW/CMS - getDiary().setTrue(SupportedFlags.DEFNEW); - getDiary().setFalse(SupportedFlags.PARNEW); + diary.setTrue(SupportedFlags.DEFNEW); + diary.setFalse(SupportedFlags.PARNEW); } } else if (simpleFullGCDetected) { if (ageTableDetected) { - getDiary().setTrue(SupportedFlags.PARNEW, SupportedFlags.SERIAL); + diary.setTrue(SupportedFlags.PARNEW, SupportedFlags.SERIAL); } else { //at this point we can't tell if it's serial or parallel so assume defaults - getDiary().setTrue(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); + diary.setTrue(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); } - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.SERIAL, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.G1GC, SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.GC_CAUSE, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.ADAPTIVE_SIZING, SupportedFlags.PRINT_HEAP_AT_GC, SupportedFlags.RSET_STATS, SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40, SupportedFlags.JDK80); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.SERIAL, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.G1GC, SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.GC_CAUSE, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.ADAPTIVE_SIZING, SupportedFlags.PRINT_HEAP_AT_GC, SupportedFlags.RSET_STATS, SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40, SupportedFlags.JDK80); } //Not much information here, assume defaults else if (simpleParallelOrParNewDetected) { if (ageTableDetected) { - getDiary().setTrue(SupportedFlags.PARNEW, SupportedFlags.CMS); - getDiary().setFalse(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); + diary.setTrue(SupportedFlags.PARNEW, SupportedFlags.CMS); + diary.setFalse(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); } else { - getDiary().setTrue(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); - getDiary().setFalse(SupportedFlags.PARNEW, SupportedFlags.CMS); + diary.setTrue(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); + diary.setFalse(SupportedFlags.PARNEW, SupportedFlags.CMS); } - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.SERIAL, SupportedFlags.ICMS, SupportedFlags.G1GC, SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.GC_CAUSE, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.ADAPTIVE_SIZING, SupportedFlags.PRINT_HEAP_AT_GC, SupportedFlags.RSET_STATS, SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40, SupportedFlags.JDK80); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.SERIAL, SupportedFlags.ICMS, SupportedFlags.G1GC, SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.GC_CAUSE, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.ADAPTIVE_SIZING, SupportedFlags.PRINT_HEAP_AT_GC, SupportedFlags.RSET_STATS, SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40, SupportedFlags.JDK80); } - getDiary().setFalse(SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION, SupportedFlags.PRINT_PROMOTION_FAILURE, SupportedFlags.PRINT_FLS_STATISTICS); + diary.setFalse(SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION, SupportedFlags.PRINT_PROMOTION_FAILURE, SupportedFlags.PRINT_FLS_STATISTICS); } /** @@ -222,7 +223,6 @@ public boolean diarize(String line) { version(line); details(line); } - return this.completed(); } @@ -249,23 +249,23 @@ private void timeOfFirstEvent(String line) { private boolean jvmActivityFlag(String line) { - if (getDiary().isStateKnown(SupportedFlags.APPLICATION_STOPPED_TIME, SupportedFlags.APPLICATION_CONCURRENT_TIME, SupportedFlags.TLAB_DATA)) + if (diary.isStateKnown(SupportedFlags.APPLICATION_STOPPED_TIME, SupportedFlags.APPLICATION_CONCURRENT_TIME, SupportedFlags.TLAB_DATA)) return false; if ((JVMPatterns.APPLICATION_STOP_TIME.parse(line) != null) || (JVMPatterns.SIMPLE_APPLICATION_STOP_TIME.parse(line) != null) || JVMPatterns.APPLICATION_STOP_TIME_WITH_STOPPING_TIME.parse(line) != null) { - getDiary().setTrue(SupportedFlags.APPLICATION_STOPPED_TIME); + diary.setTrue(SupportedFlags.APPLICATION_STOPPED_TIME); return true; } else if ((JVMPatterns.APPLICATION_TIME.parse(line) != null) || (JVMPatterns.SIMPLE_APPLICATION_TIME.parse(line) != null)) { - getDiary().setTrue(SupportedFlags.APPLICATION_CONCURRENT_TIME); + diary.setTrue(SupportedFlags.APPLICATION_CONCURRENT_TIME); return true; } else if (JVMPatterns.TLAB_CONT.parse(line) != null) { - getDiary().setTrue(SupportedFlags.TLAB_DATA); + diary.setTrue(SupportedFlags.TLAB_DATA); return true; } //This will be reported along size a collection so if we don't see them by 3nd collection.... // maybe some rubbish lines between collection and log so wait a bit longer than just the reporting of the first collection if (collectionCount > 1) { - getDiary().setFalse(SupportedFlags.APPLICATION_STOPPED_TIME, SupportedFlags.APPLICATION_CONCURRENT_TIME, SupportedFlags.TLAB_DATA); + diary.setFalse(SupportedFlags.APPLICATION_STOPPED_TIME, SupportedFlags.APPLICATION_CONCURRENT_TIME, SupportedFlags.TLAB_DATA); } return false; @@ -280,70 +280,73 @@ private void collector(String line) { GCLogTrace trace; - if ((!getDiary().isStateKnown(SupportedFlags.PARNEW, SupportedFlags.DEFNEW, SupportedFlags.PARALLELGC, SupportedFlags.G1GC)) || - !getDiary().isStateKnown(SupportedFlags.GC_DETAILS) || collectionCount < 3) { + if ((!diary.isStateKnown(SupportedFlags.PARNEW, SupportedFlags.DEFNEW, SupportedFlags.PARALLELGC, SupportedFlags.G1GC)) || + !diary.isStateKnown(SupportedFlags.GC_DETAILS) || collectionCount < 3) { if (line.contains("[PSYoungGen:")) { - getDiary().setTrue(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION, SupportedFlags.RSET_STATS); + diary.setTrue(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION, SupportedFlags.RSET_STATS); collectionCount++; youngCollectionCount++; if ((trace = ParallelPatterns.PSYOUNGGEN.parse(line)) != null) { - getDiary().setTrue(SupportedFlags.GC_DETAILS); - getDiary().setFalse(SupportedFlags.TENURING_DISTRIBUTION); - getDiary().setFalse(SupportedFlags.PRINT_HEAP_AT_GC); + diary.setTrue(SupportedFlags.GC_DETAILS); + diary.setFalse(SupportedFlags.TENURING_DISTRIBUTION); + diary.setFalse(SupportedFlags.PRINT_HEAP_AT_GC); setGCCause(trace.getGroup(3)); } else if (ParallelPatterns.PS_DETAILS_WITH_TENURING.parse(line) != null) { - getDiary().setTrue(SupportedFlags.GC_DETAILS); - getDiary().setFalse(SupportedFlags.PRINT_HEAP_AT_GC); + diary.setTrue(SupportedFlags.GC_DETAILS); + diary.setFalse(SupportedFlags.PRINT_HEAP_AT_GC); } } else if (line.contains("ParNew")) { - getDiary().setTrue(SupportedFlags.PARNEW, SupportedFlags.CMS); - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.RSET_STATS); + diary.setTrue(SupportedFlags.PARNEW, SupportedFlags.CMS); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.RSET_STATS); collectionCount++; youngCollectionCount++; if ((trace = CMSPatterns.PARNEW.parse(line)) != null) { - getDiary().setTrue(SupportedFlags.GC_DETAILS); - getDiary().setFalse(SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); + diary.setTrue(SupportedFlags.GC_DETAILS); + diary.setFalse(SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); setGCCause(trace.getGroup(4)); } else if ((trace = CMSPatterns.PARNEW_TENURING.parse(line)) != null) { - getDiary().setTrue(SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION); - getDiary().setFalse(SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setTrue(SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION); + diary.setFalse(SupportedFlags.CMS_DEBUG_LEVEL_1); setGCCause(trace.getGroup(3)); } else if ((trace = SimplePatterns.PARNEW_NO_DETAILS.parse(line)) != null) { - getDiary().setFalse(SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.PRINT_HEAP_AT_GC, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); + diary.setFalse(SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.PRINT_HEAP_AT_GC, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); setGCCause(trace.getGroup(3)); } else if ((trace = SimplePatterns.PARNEW_START.parse(line)) != null) { - getDiary().setFalse(SupportedFlags.GC_DETAILS, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.ADAPTIVE_SIZING, SupportedFlags.PRINT_HEAP_AT_GC); + diary.setFalse(SupportedFlags.GC_DETAILS, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.ADAPTIVE_SIZING, SupportedFlags.PRINT_HEAP_AT_GC); setGCCause(trace.groupCount() > 2 ? trace.getGroup(3) : null); } else if ((trace = CMSPatterns.PARNEW_REFERENCE_SPLIT.parse(line)) != null) { - getDiary().setTrue(SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.PRINT_REFERENCE_GC); + diary.setTrue(SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.PRINT_REFERENCE_GC); setGCCause(trace.getGroup(3)); } } else if ((trace = SerialPatterns.DEFNEW.parse(line)) != null) { collectionCount++; youngCollectionCount++; - getDiary().setTrue(SupportedFlags.DEFNEW, SupportedFlags.GC_DETAILS); - getDiary().setFalse(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.PARNEW, SupportedFlags.G1GC, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.RSET_STATS, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); + diary.setTrue(SupportedFlags.DEFNEW, SupportedFlags.GC_DETAILS); + diary.setFalse(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.PARNEW, SupportedFlags.G1GC, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.RSET_STATS, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); setGCCause(trace.getGroup(3)); } else if ((trace = SerialPatterns.DEFNEW_TENURING.parse(line)) != null) { collectionCount++; youngCollectionCount++; - getDiary().setTrue(SupportedFlags.DEFNEW, SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION); - getDiary().setFalse(SupportedFlags.PARNEW, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.G1GC, SupportedFlags.RSET_STATS); + diary.setTrue(SupportedFlags.DEFNEW, SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION); + diary.setFalse(SupportedFlags.PARNEW, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.G1GC, SupportedFlags.RSET_STATS); setGCCause(trace.getGroup(3)); } else if (SimplePatterns.PARNEW_NO_DETAILS.parse(line) != null) { collectionCount++; youngCollectionCount++; - getDiary().setTrue(SupportedFlags.PARNEW); - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.G1GC, SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.GC_CAUSE, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.ADAPTIVE_SIZING, SupportedFlags.PRINT_HEAP_AT_GC, SupportedFlags.RSET_STATS, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); + diary.setTrue(SupportedFlags.PARNEW); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.G1GC, SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.GC_CAUSE, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.ADAPTIVE_SIZING, SupportedFlags.PRINT_HEAP_AT_GC, SupportedFlags.RSET_STATS, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); } else if (SimplePatterns.YOUNG_NO_DETAILS.parse(line) != null) { collectionCount++; youngCollectionCount++; simpleParallelOrParNewDetected = true; + diary.setFalse(SupportedFlags.G1GC, SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION, + SupportedFlags.GC_CAUSE, SupportedFlags.JDK80, SupportedFlags.PRINT_HEAP_AT_GC, + SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION, SupportedFlags.ADAPTIVE_SIZING); } else if (SimplePatterns.FULL_NO_GC_DETAILS.parse(line) != null) { collectionCount++; simpleFullGCDetected = true; @@ -352,7 +355,7 @@ private void collector(String line) { collectionCount++; simpleParallelOrParNewDetected = true; youngCollectionCount++; - getDiary().setFalse(SupportedFlags.G1GC, SupportedFlags.RSET_STATS); + diary.setFalse(SupportedFlags.G1GC, SupportedFlags.RSET_STATS); setGCCause(trace.getGroup(3)); } else if (SimplePatterns.CMS_NO_DETAILS.parse(line) != null) { // could be parallel or CMS.. look for Full GC but even that may be a trick @@ -363,61 +366,61 @@ private void collector(String line) { } else if ((trace = G1GCPatterns.G1_YOUNG_SPLIT_START.parse(line)) != null) { collectionCount++; youngCollectionCount++; - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1); - getDiary().setTrue(SupportedFlags.G1GC); - getDiary().setTrue(SupportedFlags.GC_DETAILS); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setTrue(SupportedFlags.G1GC); + diary.setTrue(SupportedFlags.GC_DETAILS); if (trace.gcCause() == GCCause.GCCAUSE_NOT_SET) { - getDiary().setFalse(SupportedFlags.GC_CAUSE); + diary.setFalse(SupportedFlags.GC_CAUSE); } else if (trace.gcCause() == GCCause.METADATA_GENERATION_THRESHOLD) { - getDiary().setTrue(SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); - getDiary().setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); + diary.setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); } else if ((trace.gcCause() == GCCause.G1_EVACUATION_PAUSE) || (trace.gcCause(3, 0) == GCCause.G1_HUMONGOUS_ALLOCATION)) { - getDiary().setTrue(SupportedFlags.GC_CAUSE); - getDiary().setFalse(SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.GC_CAUSE); + diary.setFalse(SupportedFlags.PRE_JDK70_40); } } else if ((trace = G1GCPatterns.G1_DETAILS.parse(line)) != null) { collectionCount++; youngCollectionCount++; - getDiary().setTrue(SupportedFlags.G1GC, SupportedFlags.GC_DETAILS); - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); + diary.setTrue(SupportedFlags.G1GC, SupportedFlags.GC_DETAILS); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); if (trace.gcCause(3, 0) == GCCause.GCCAUSE_NOT_SET) { - getDiary().setFalse(SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); - getDiary().setTrue(SupportedFlags.JDK70); + diary.setFalse(SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); + diary.setTrue(SupportedFlags.JDK70); } else { - getDiary().setFalse(SupportedFlags.GC_CAUSE); - getDiary().setFalse(SupportedFlags.PRE_JDK70_40); + diary.setFalse(SupportedFlags.GC_CAUSE); + diary.setFalse(SupportedFlags.PRE_JDK70_40); } } else if ((trace = G1GCPatterns.YOUNG.parse(line)) != null) { collectionCount++; youngCollectionCount++; - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); - getDiary().setTrue(SupportedFlags.G1GC); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.GC_DETAILS, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); + diary.setTrue(SupportedFlags.G1GC); checkForGCCause(trace); //2014-10-21T11:49:08.954-0500: 12053.551: [GC pause (young)12054.116: [SoftReference, 0 refs, 0.0000070 secs]12054.116: [WeakReference, 234 refs, 0.0000640 secs]12054.116: [FinalReference, 3805 refs, 0.0034010 secs]12054.119: [PhantomReference, 9 refs, 0.0000040 secs]12054.119: [JNI Weak Reference, 0.0001960 secs], 0.58191800 secs] } else if ((trace = G1GCPatterns.G1_DETAILS_REFERENCE_GC.parse(line)) != null) { collectionCount++; youngCollectionCount++; - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); - getDiary().setTrue(SupportedFlags.G1GC, SupportedFlags.GC_DETAILS, SupportedFlags.PRINT_REFERENCE_GC); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); + diary.setTrue(SupportedFlags.G1GC, SupportedFlags.GC_DETAILS, SupportedFlags.PRINT_REFERENCE_GC); if (trace.getGroup(3) != null) - getDiary().setTrue(SupportedFlags.GC_CAUSE); + diary.setTrue(SupportedFlags.GC_CAUSE); else - getDiary().setFalse(SupportedFlags.GC_CAUSE); + diary.setFalse(SupportedFlags.GC_CAUSE); } else if (G1GCPatterns.G1_INITIAL_MARK.parse(line) != null) { collectionCount++; youngCollectionCount++; - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); - getDiary().setTrue(SupportedFlags.G1GC, SupportedFlags.GC_DETAILS, SupportedFlags.GC_CAUSE, SupportedFlags.TENURING_DISTRIBUTION); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); + diary.setTrue(SupportedFlags.G1GC, SupportedFlags.GC_DETAILS, SupportedFlags.GC_CAUSE, SupportedFlags.TENURING_DISTRIBUTION); } } - if (getDiary().isTrue(SupportedFlags.ADAPTIVE_SIZING)) { + if (diary.isTrue(SupportedFlags.ADAPTIVE_SIZING)) { if ((trace = G1GCPatterns.YOUNG_SPLIT_BY_G1ERGONOMICS.parse(line)) != null) { collectionCount++; youngCollectionCount++; - getDiary().setTrue(SupportedFlags.G1GC, SupportedFlags.GC_DETAILS); - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setTrue(SupportedFlags.G1GC, SupportedFlags.GC_DETAILS); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1); checkForGCCause(trace); } } @@ -425,90 +428,90 @@ private void collector(String line) { //This has been verified true as of 1.7.0_51. Check later versions to make sure it hasn't been back ported if (ParallelPatterns.PS_FULL_GC_PERM.parse(line) != null) { collectionCount++; - getDiary().setTrue(SupportedFlags.JDK70); - getDiary().setFalse(SupportedFlags.JDK80); + diary.setTrue(SupportedFlags.JDK70); + diary.setFalse(SupportedFlags.JDK80); if (line.contains(" [PSYoungGen: ")) - getDiary().setTrue(SupportedFlags.PARALLELGC); - getDiary().setTrue(SupportedFlags.PARALLELOLDGC, SupportedFlags.GC_DETAILS); - getDiary().setFalse(SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.SERIAL, SupportedFlags.G1GC); + diary.setTrue(SupportedFlags.PARALLELGC); + diary.setTrue(SupportedFlags.PARALLELOLDGC, SupportedFlags.GC_DETAILS); + diary.setFalse(SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.SERIAL, SupportedFlags.G1GC); - getDiary().setFalse(SupportedFlags.CMS_DEBUG_LEVEL_1); - getDiary().setFalse(SupportedFlags.PRINT_HEAP_AT_GC); + diary.setFalse(SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setFalse(SupportedFlags.PRINT_HEAP_AT_GC); } //This has been verified true as of 1.7.0_51. Check later versions to make sure it hasn't been back ported else if (ParallelPatterns.PS_FULL_GC_META.parse(line) != null) { collectionCount++; - getDiary().setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); - getDiary().setTrue(SupportedFlags.JDK80); + diary.setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.JDK80); if (line.contains(" [PSYoungGen: ")) - getDiary().setTrue(SupportedFlags.PARALLELGC); - getDiary().setTrue(SupportedFlags.PARALLELOLDGC, SupportedFlags.GC_DETAILS); - getDiary().setFalse(SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.SERIAL, SupportedFlags.ICMS, SupportedFlags.G1GC); + diary.setTrue(SupportedFlags.PARALLELGC); + diary.setTrue(SupportedFlags.PARALLELOLDGC, SupportedFlags.GC_DETAILS); + diary.setFalse(SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.SERIAL, SupportedFlags.ICMS, SupportedFlags.G1GC); - getDiary().setFalse(SupportedFlags.CMS_DEBUG_LEVEL_1); - getDiary().setFalse(SupportedFlags.PRINT_HEAP_AT_GC); + diary.setFalse(SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setFalse(SupportedFlags.PRINT_HEAP_AT_GC); } else if (line.contains("CMS-initial-mark")) { collectionCount++; - getDiary().setFalse(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.G1GC); - getDiary().setTrue(SupportedFlags.CMS, SupportedFlags.GC_DETAILS); + diary.setFalse(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.G1GC); + diary.setTrue(SupportedFlags.CMS, SupportedFlags.GC_DETAILS); } //todo: this rule is in the wrong place else if (CMSPatterns.SERIAL_FULL.parse(line) != null) { collectionCount++; - getDiary().setFalse(SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELOLDGC, SupportedFlags.G1GC, SupportedFlags.CMS_DEBUG_LEVEL_1); - getDiary().setTrue(SupportedFlags.SERIAL, SupportedFlags.GC_DETAILS); + diary.setFalse(SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELOLDGC, SupportedFlags.G1GC, SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setTrue(SupportedFlags.SERIAL, SupportedFlags.GC_DETAILS); //todo: private final int SupportedFlags.GC_CAUSE = 12; - getDiary().setFalse(SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setFalse(SupportedFlags.CMS_DEBUG_LEVEL_1); if (line.contains("Metaspace")) { - getDiary().setFalse(SupportedFlags.JDK70); - getDiary().setTrue(SupportedFlags.JDK80, SupportedFlags.GC_CAUSE); + diary.setFalse(SupportedFlags.JDK70); + diary.setTrue(SupportedFlags.JDK80, SupportedFlags.GC_CAUSE); } else if ( line.contains("Perm")) { // todo: maybe look for GC_CAUSE in JDK 7??? - getDiary().setFalse(SupportedFlags.JDK80); + diary.setFalse(SupportedFlags.JDK80); } if (line.contains("Tenured")) { - getDiary().setFalse(SupportedFlags.CMS, SupportedFlags.ICMS); - getDiary().setTrue(SupportedFlags.SERIAL); + diary.setFalse(SupportedFlags.CMS, SupportedFlags.ICMS); + diary.setTrue(SupportedFlags.SERIAL); } else if (line.contains("CMS")) { - getDiary().setFalse(SupportedFlags.SERIAL); - getDiary().setTrue(SupportedFlags.CMS); + diary.setFalse(SupportedFlags.SERIAL); + diary.setTrue(SupportedFlags.CMS); } } else if (CMSPatterns.SERIAL_FULL.parse(line) != null) { collectionCount++; - getDiary().setFalse(SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELOLDGC, SupportedFlags.G1GC, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.JDK70); - getDiary().setTrue(SupportedFlags.SERIAL, SupportedFlags.GC_DETAILS, SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); + diary.setFalse(SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELOLDGC, SupportedFlags.G1GC, SupportedFlags.CMS_DEBUG_LEVEL_1, SupportedFlags.JDK70); + diary.setTrue(SupportedFlags.SERIAL, SupportedFlags.GC_DETAILS, SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); } else if (TENURED_BLOCK.parse(line) != null) { collectionCount++; - getDiary().setFalse(SupportedFlags.CMS); - getDiary().setFalse(SupportedFlags.ICMS); - getDiary().setTrue(SupportedFlags.SERIAL); - getDiary().setFalse(SupportedFlags.G1GC); + diary.setFalse(SupportedFlags.CMS); + diary.setFalse(SupportedFlags.ICMS); + diary.setTrue(SupportedFlags.SERIAL); + diary.setFalse(SupportedFlags.G1GC); } - if (getDiary().isTrue(SupportedFlags.CMS) && !getDiary().isStateKnown(SupportedFlags.ICMS)) { + if (diary.isTrue(SupportedFlags.CMS) && !diary.isStateKnown(SupportedFlags.ICMS)) { if (firstCMSCycle) { if (line.contains("ParNew") || line.contains("DefNew")) youngCountAfterFirstCMSCycle++; if (line.contains("icms_dc")) - getDiary().setTrue(SupportedFlags.ICMS); + diary.setTrue(SupportedFlags.ICMS); else if (youngCountAfterFirstCMSCycle > 1) - getDiary().setFalse(SupportedFlags.ICMS); + diary.setFalse(SupportedFlags.ICMS); } //The first CMS cycle is needed to kick off iCMS if (line.contains("concurrent-reset")) firstCMSCycle = true; - } else if (getDiary().isTrue(SupportedFlags.G1GC)) { + } else if (diary.isTrue(SupportedFlags.G1GC)) { if (G1GCPatterns.G1_MEMORY_SUMMARY.parse(line) != null) { if (line.contains("Metaspace")) { - getDiary().setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); - getDiary().setTrue(SupportedFlags.JDK80); + diary.setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.JDK80); } else { - getDiary().setTrue(SupportedFlags.JDK70); - getDiary().setFalse(SupportedFlags.JDK80); + diary.setTrue(SupportedFlags.JDK70); + diary.setFalse(SupportedFlags.JDK80); } } } @@ -516,10 +519,10 @@ else if (youngCountAfterFirstCMSCycle > 1) private void checkForGCCause(GCLogTrace trace) { if (trace.gcCause(3, 0) == GCCause.METADATA_GENERATION_THRESHOLD) { - getDiary().setTrue(SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); - getDiary().setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); + diary.setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); } else if ((trace.gcCause(3, 0) == GCCause.G1_EVACUATION_PAUSE) || (trace.gcCause(3, 0) == GCCause.G1_HUMONGOUS_ALLOCATION)) { - getDiary().setTrue(SupportedFlags.GC_CAUSE); + diary.setTrue(SupportedFlags.GC_CAUSE); } } @@ -541,59 +544,59 @@ private void version(String line) { String value = trace.getGroup(1).trim(); if ("CMS Perm".equals(value)) { - getDiary().setTrue(SupportedFlags.JDK70); - getDiary().setFalse(SupportedFlags.JDK80); + diary.setTrue(SupportedFlags.JDK70); + diary.setFalse(SupportedFlags.JDK80); } else if ("PS Perm".equals(value)) { - getDiary().setTrue(SupportedFlags.JDK70); - getDiary().setFalse(SupportedFlags.JDK80); + diary.setTrue(SupportedFlags.JDK70); + diary.setFalse(SupportedFlags.JDK80); } else if ("Perm".equals(value)) { - getDiary().setTrue(SupportedFlags.JDK70); - getDiary().setFalse(SupportedFlags.JDK80); + diary.setTrue(SupportedFlags.JDK70); + diary.setFalse(SupportedFlags.JDK80); } else if ("PSPermGen".equals(value)) { - getDiary().setTrue(SupportedFlags.JDK70); - getDiary().setFalse(SupportedFlags.JDK80); + diary.setTrue(SupportedFlags.JDK70); + diary.setFalse(SupportedFlags.JDK80); } else if ("Metaspace".equals(value)) { - getDiary().setTrue(SupportedFlags.JDK80); - getDiary().setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.JDK80); + diary.setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); } } else if (META_SPACE_RECORD.parse(line) != null) { - getDiary().setTrue(SupportedFlags.JDK80); - getDiary().setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.JDK80); + diary.setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); } // maybe we'll get lucky, app server often call System.gc() after startup. if (line.contains("(System)")) { - getDiary().setTrue(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); - getDiary().setFalse(SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); + diary.setTrue(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); + diary.setFalse(SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); } else if (line.contains("(System.gc()")) { - getDiary().setFalse(SupportedFlags.PRE_JDK70_40); - getDiary().setTrue(SupportedFlags.GC_CAUSE); - } else if (getDiary().isGenerationalKnown() && getDiary().isGenerational()) { + diary.setFalse(SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.GC_CAUSE); + } else if (diary.isGenerationalKnown() && diary.isGenerational()) { if ((trace = PREFIX.parse(line)) != null) { - if ((trace.getGroup(3) == null) && getDiary().isTrue(SupportedFlags.GC_DETAILS)) { - getDiary().setTrue(SupportedFlags.JDK70); - getDiary().setFalse(SupportedFlags.JDK80, SupportedFlags.GC_CAUSE); + if ((trace.getGroup(3) == null) && diary.isTrue(SupportedFlags.GC_DETAILS)) { + diary.setTrue(SupportedFlags.JDK70); + diary.setFalse(SupportedFlags.JDK80, SupportedFlags.GC_CAUSE); } else if (trace.gcCause(3, 0) != GCCause.GCCAUSE_NOT_SET) { - getDiary().setTrue(SupportedFlags.GC_CAUSE); - getDiary().setFalse(SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.GC_CAUSE); + diary.setFalse(SupportedFlags.PRE_JDK70_40); } } else if ((trace = FULL_PREFIX.parse(line)) != null) { - if ((trace.getGroup(3) == null) && getDiary().isTrue(SupportedFlags.GC_DETAILS)) { - getDiary().setTrue(SupportedFlags.JDK70); - getDiary().setFalse(SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); + if ((trace.getGroup(3) == null) && diary.isTrue(SupportedFlags.GC_DETAILS)) { + diary.setTrue(SupportedFlags.JDK70); + diary.setFalse(SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); } else if (trace.gcCause(3, 0) != GCCause.GCCAUSE_NOT_SET) { - getDiary().setTrue(SupportedFlags.GC_CAUSE); - getDiary().setFalse(SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.GC_CAUSE); + diary.setFalse(SupportedFlags.PRE_JDK70_40); } } - } else if (getDiary().isG1GCKnown() && getDiary().isG1GC()) { + } else if (diary.isG1GCKnown() && diary.isG1GC()) { if ((trace = G1GC_PREFIX.parse(line)) != null) { - if (getDiary().isTrue(SupportedFlags.GC_DETAILS) && (trace.gcCause() == GCCause.GCCAUSE_NOT_SET)) { - getDiary().setTrue(SupportedFlags.JDK70); - getDiary().setFalse(SupportedFlags.JDK80); + if (diary.isTrue(SupportedFlags.GC_DETAILS) && (trace.gcCause() == GCCause.GCCAUSE_NOT_SET)) { + diary.setTrue(SupportedFlags.JDK70); + diary.setFalse(SupportedFlags.JDK80); } else { //we can't say much else unless we look for 8.0 specific details - getDiary().setFalse(SupportedFlags.PRE_JDK70_40); + diary.setFalse(SupportedFlags.PRE_JDK70_40); } } } @@ -612,73 +615,73 @@ private void details(String line) { if ((trace = PREFIX.parse(line)) != null) { String cause = trace.getGroup(3); if (cause != null) { - getDiary().setTrue(SupportedFlags.GC_CAUSE); + diary.setTrue(SupportedFlags.GC_CAUSE); if ("(System)".equals(cause)) { - getDiary().setFalse(SupportedFlags.JDK80); - getDiary().setTrue(SupportedFlags.JDK70); - getDiary().setTrue(SupportedFlags.PRE_JDK70_40); + diary.setFalse(SupportedFlags.JDK80); + diary.setTrue(SupportedFlags.JDK70); + diary.setTrue(SupportedFlags.PRE_JDK70_40); } else if ("(System.gc())".equals(cause)) { - getDiary().setFalse(SupportedFlags.PRE_JDK70_40); + diary.setFalse(SupportedFlags.PRE_JDK70_40); } else { - getDiary().setFalse(SupportedFlags.PRE_JDK70_40); + diary.setFalse(SupportedFlags.PRE_JDK70_40); } } else { if ((trace = G1GC_PREFIX.parse(line)) != null) { cause = trace.getGroup(3); if (cause == null) - getDiary().setTrue(SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.PRE_JDK70_40); else - getDiary().setFalse(SupportedFlags.PRE_JDK70_40); + diary.setFalse(SupportedFlags.PRE_JDK70_40); } else { - getDiary().setFalse(SupportedFlags.GC_CAUSE); + diary.setFalse(SupportedFlags.GC_CAUSE); } } - getDiary().setFalse(SupportedFlags.GC_CAUSE); + diary.setFalse(SupportedFlags.GC_CAUSE); } else if (line.contains("promotion failure size =")) - getDiary().setTrue(SupportedFlags.PRINT_PROMOTION_FAILURE); + diary.setTrue(SupportedFlags.PRINT_PROMOTION_FAILURE); else if (FLS_HEADER.parse(line) != null) { - getDiary().setTrue(SupportedFlags.PRINT_FLS_STATISTICS); + diary.setTrue(SupportedFlags.PRINT_FLS_STATISTICS); } //old G1 log file // [GC Worker Start (ms): 12053551.6 12053551.6 12053551.6 12053551.6 12053551.7 12053551.7 12053551.7 12053551.7 12053551.7 12053551.7 12053551.7 12053551.7 //new G1 log file // [GC Worker Start (ms): Min: 76.3, Avg: 76.3, Max: 76.4, Diff: 0.1] - if (getDiary().isG1GC()) { + if (diary.isG1GC()) { if (line.startsWith("[GC Worker Start (ms): ")) if (line.startsWith("[GC Worker Start (ms): Min: ")) - getDiary().setFalse(SupportedFlags.PRE_JDK70_40); + diary.setFalse(SupportedFlags.PRE_JDK70_40); else - getDiary().setTrue(SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.PRE_JDK70_40); } else if (line.contains("AdaptiveSizePolicy::")) { - getDiary().setTrue(SupportedFlags.ADAPTIVE_SIZING); + diary.setTrue(SupportedFlags.ADAPTIVE_SIZING); } //if we've seen a collection and Print Reference GC hasn't been set... - if (youngCollectionCount > 1 && !getDiary().isStateKnown(SupportedFlags.PRINT_REFERENCE_GC)) { - getDiary().setFalse(SupportedFlags.PRINT_REFERENCE_GC); + if (youngCollectionCount > 1 && !diary.isStateKnown(SupportedFlags.PRINT_REFERENCE_GC)) { + diary.setFalse(SupportedFlags.PRINT_REFERENCE_GC); } GCLogTrace gcLogTrace; if ((gcLogTrace = MEMORY_SUMMARY_RULE.parse(line)) != null) { if (gcLogTrace.next() != null) - getDiary().setTrue(SupportedFlags.GC_DETAILS); + diary.setTrue(SupportedFlags.GC_DETAILS); } // if we've seen a statement than this is false if (line.startsWith("{Heap before GC invocations=")) - getDiary().setTrue(SupportedFlags.PRINT_HEAP_AT_GC); + diary.setTrue(SupportedFlags.PRINT_HEAP_AT_GC); else if (collectionCount > 1) - getDiary().setFalse(SupportedFlags.PRINT_HEAP_AT_GC); + diary.setFalse(SupportedFlags.PRINT_HEAP_AT_GC); if ((trace = TenuredPatterns.TENURING_SUMMARY.parse(line)) != null) { //we have seen at least one good tenuring summary without an age breakdown if ((tenuringSummary > 0) && (!ageTableDetected)) { - getDiary().setTrue(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setTrue(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.CMS_DEBUG_LEVEL_1); } else - getDiary().setTrue(SupportedFlags.TENURING_DISTRIBUTION); + diary.setTrue(SupportedFlags.TENURING_DISTRIBUTION); // if calculated tenuring threshold == 0 we won't get an age breakdown so delay evaluation if (trace.getIntegerGroup(2) > 0) @@ -687,47 +690,47 @@ else if (collectionCount > 1) //If the MaxTenuringThreshold is set to be greater than 15 then we a configuration bug to report on. if (trace.getIntegerGroup(3) > 15) { maxTenuringThreshold = trace.getIntegerGroup(3); - getDiary().setTrue(SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); + diary.setTrue(SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); } else - getDiary().setFalse(SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); + diary.setFalse(SupportedFlags.MAX_TENURING_THRESHOLD_VIOLATION); } else if (TenuredPatterns.TENURING_AGE_BREAKDOWN.parse(line) != null) { ageTableDetected = true; - getDiary().setFalse(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); - } else if (getDiary().isTenuringDistributionKnown() && collectionCount > 1 && youngCollectionCount > 1) { - getDiary().setFalse(SupportedFlags.TENURING_DISTRIBUTION); + diary.setFalse(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); + } else if (diary.isTenuringDistributionKnown() && collectionCount > 1 && youngCollectionCount > 1) { + diary.setFalse(SupportedFlags.TENURING_DISTRIBUTION); } if (line.contains("G1Ergonomics")) { if (line.contains("CSet Construction") || line.contains("Heap Sizing")) { collectionCount++; - getDiary().setTrue(SupportedFlags.G1GC, SupportedFlags.ADAPTIVE_SIZING); - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setTrue(SupportedFlags.G1GC, SupportedFlags.ADAPTIVE_SIZING); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1); } } if (REFERENCE_PROCESSING_BLOCK.parse(line) != null) - getDiary().setTrue(SupportedFlags.PRINT_REFERENCE_GC); + diary.setTrue(SupportedFlags.PRINT_REFERENCE_GC); if (line.startsWith("Concurrent RS processed")) { collectionCount++; - getDiary().setTrue(SupportedFlags.G1GC, SupportedFlags.RSET_STATS); - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setTrue(SupportedFlags.G1GC, SupportedFlags.RSET_STATS); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1); } else if (line.contains(" (cardTable: ")) { - getDiary().setTrue(SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setTrue(SupportedFlags.CMS_DEBUG_LEVEL_1); } if (collectionCount > 1) { - if (!getDiary().isCMSDebugLevel1Known()) { - getDiary().setFalse(SupportedFlags.CMS_DEBUG_LEVEL_1); + if (!diary.isCMSDebugLevel1Known()) { + diary.setFalse(SupportedFlags.CMS_DEBUG_LEVEL_1); } - if (!getDiary().isAdaptiveSizingKnown()) { - getDiary().setFalse(SupportedFlags.ADAPTIVE_SIZING); + if (!diary.isAdaptiveSizingKnown()) { + diary.setFalse(SupportedFlags.ADAPTIVE_SIZING); } - if (!getDiary().isRSetStatsKnown()) - getDiary().setFalse(SupportedFlags.RSET_STATS); + if (!diary.isRSetStatsKnown()) + diary.setFalse(SupportedFlags.RSET_STATS); } } @@ -766,47 +769,47 @@ private void evaluateCommandLineFlags(String[] commandLineFlags) { if (supportedFlag != null) { switch (supportedFlag) { case PrintGCApplicationStoppedTime: - getDiary().setState(SupportedFlags.APPLICATION_STOPPED_TIME, flagTurnedOn); + diary.setState(SupportedFlags.APPLICATION_STOPPED_TIME, flagTurnedOn); break; case PrintGCApplicationConcurrentTime: - getDiary().setState(SupportedFlags.APPLICATION_CONCURRENT_TIME, flagTurnedOn); + diary.setState(SupportedFlags.APPLICATION_CONCURRENT_TIME, flagTurnedOn); break; case PrintGCTimeStamps: break; case PrintGCDetails: - getDiary().setState(SupportedFlags.GC_DETAILS, flagTurnedOn); - if (flagTurnedOn && (getDiary().isJDK80() || getDiary().isUnifiedLogging())) - getDiary().setTrue(SupportedFlags.GC_CAUSE); + diary.setState(SupportedFlags.GC_DETAILS, flagTurnedOn); + if (flagTurnedOn && (diary.isJDK80() || diary.isUnifiedLogging())) + diary.setTrue(SupportedFlags.GC_CAUSE); break; case PrintGCCause: - getDiary().setState(SupportedFlags.GC_CAUSE, flagTurnedOn); + diary.setState(SupportedFlags.GC_CAUSE, flagTurnedOn); break; case PrintTenuringDistribution: - getDiary().setState(SupportedFlags.TENURING_DISTRIBUTION, flagTurnedOn); + diary.setState(SupportedFlags.TENURING_DISTRIBUTION, flagTurnedOn); break; case PrintAdaptiveSizePolicy: - getDiary().setState(SupportedFlags.ADAPTIVE_SIZING, flagTurnedOn); + diary.setState(SupportedFlags.ADAPTIVE_SIZING, flagTurnedOn); break; case PrintReferenceGC: - getDiary().setState(SupportedFlags.PRINT_REFERENCE_GC, flagTurnedOn); + diary.setState(SupportedFlags.PRINT_REFERENCE_GC, flagTurnedOn); break; case PrintHeapAtGC: - getDiary().setState(SupportedFlags.PRINT_HEAP_AT_GC, flagTurnedOn); + diary.setState(SupportedFlags.PRINT_HEAP_AT_GC, flagTurnedOn); break; case PrintPromotionFailure: - getDiary().setTrue(SupportedFlags.PRINT_PROMOTION_FAILURE); + diary.setTrue(SupportedFlags.PRINT_PROMOTION_FAILURE); case PrintFLSStatistics: - getDiary().setTrue(SupportedFlags.PRINT_FLS_STATISTICS); + diary.setTrue(SupportedFlags.PRINT_FLS_STATISTICS); default: //shouldn't be able to get here.... @@ -852,7 +855,7 @@ private void evaluateCommandLineFlags(String[] commandLineFlags) { } evaluateGCLogFlags(); - getDiary().setFalse(SupportedFlags.APPLICATION_STOPPED_TIME, SupportedFlags.APPLICATION_CONCURRENT_TIME, SupportedFlags.GC_DETAILS, + diary.setFalse(SupportedFlags.APPLICATION_STOPPED_TIME, SupportedFlags.APPLICATION_CONCURRENT_TIME, SupportedFlags.GC_DETAILS, SupportedFlags.GC_CAUSE, SupportedFlags.TENURING_DISTRIBUTION, SupportedFlags.ADAPTIVE_SIZING, SupportedFlags.PRINT_REFERENCE_GC, SupportedFlags.PRINT_HEAP_AT_GC, SupportedFlags.PRINT_PROMOTION_FAILURE, SupportedFlags.PRINT_FLS_STATISTICS); } @@ -885,26 +888,26 @@ private void parseJVMVersion(String versionString) { if (matcher.find()) { switch (matcher.group(2).charAt(0)) { case '7': - getDiary().setTrue(SupportedFlags.JDK70); - getDiary().setFalse(SupportedFlags.JDK80); + diary.setTrue(SupportedFlags.JDK70); + diary.setFalse(SupportedFlags.JDK80); if (matcher.group(3) == null) - getDiary().setTrue(SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.PRE_JDK70_40); try { int minorVersion = Integer.parseInt(matcher.group(3).substring(1)); if (minorVersion < 41) - getDiary().setTrue(SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.PRE_JDK70_40); else - getDiary().setFalse(SupportedFlags.PRE_JDK70_40); + diary.setFalse(SupportedFlags.PRE_JDK70_40); } catch (NumberFormatException nfe) { - getDiary().setTrue(SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.PRE_JDK70_40); } break; case '8': - getDiary().setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); - getDiary().setTrue(SupportedFlags.JDK80, SupportedFlags.GC_CAUSE); // doesn't matter so much but may only be true for later versions of 8 + diary.setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.JDK80, SupportedFlags.GC_CAUSE); // doesn't matter so much but may only be true for later versions of 8 break; case '9': - getDiary().setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40, SupportedFlags.JDK80); + diary.setFalse(SupportedFlags.JDK70, SupportedFlags.PRE_JDK70_40, SupportedFlags.JDK80); break; default: } @@ -962,64 +965,64 @@ private void evaluateGCLogFlags() { case 4354: case 6146: case 16384: - getDiary().setTrue(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.RSET_STATS, SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setTrue(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.RSET_STATS, SupportedFlags.CMS_DEBUG_LEVEL_1); break; case 1024: // parallel/serial case 1026: - getDiary().setTrue(SupportedFlags.PARALLELGC); - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.RSET_STATS, SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setTrue(SupportedFlags.PARALLELGC); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.RSET_STATS, SupportedFlags.CMS_DEBUG_LEVEL_1); break; case 1: // DefNew/Serial - getDiary().setTrue(SupportedFlags.DEFNEW, SupportedFlags.SERIAL); - getDiary().setFalse(SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.G1GC, SupportedFlags.RSET_STATS, SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setTrue(SupportedFlags.DEFNEW, SupportedFlags.SERIAL); + diary.setFalse(SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.G1GC, SupportedFlags.RSET_STATS, SupportedFlags.CMS_DEBUG_LEVEL_1); break; case 8: //ParNew/Serial Deprecated case 4101: - getDiary().setTrue(SupportedFlags.PARNEW, SupportedFlags.SERIAL); - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.G1GC, SupportedFlags.RSET_STATS, SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setTrue(SupportedFlags.PARNEW, SupportedFlags.SERIAL); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.G1GC, SupportedFlags.RSET_STATS, SupportedFlags.CMS_DEBUG_LEVEL_1); break; case 16: //ParNew/CMS case 24: case 272: - getDiary().setTrue(SupportedFlags.PARNEW, SupportedFlags.CMS); - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.RSET_STATS); + diary.setTrue(SupportedFlags.PARNEW, SupportedFlags.CMS); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.RSET_STATS); break; case 2064: //DefNew/CMS Deprecated - getDiary().setTrue(SupportedFlags.DEFNEW, SupportedFlags.CMS); - getDiary().setFalse(SupportedFlags.PARNEW, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.RSET_STATS); + diary.setTrue(SupportedFlags.DEFNEW, SupportedFlags.CMS); + diary.setFalse(SupportedFlags.PARNEW, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.RSET_STATS); break; case 48: //ParNew/iCMS case 56: - getDiary().setTrue(SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS); - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.RSET_STATS); + diary.setTrue(SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.RSET_STATS); break; case 2096: //DefNew/iCMS - getDiary().setTrue(SupportedFlags.DEFNEW, SupportedFlags.CMS, SupportedFlags.ICMS); - getDiary().setFalse(SupportedFlags.PARNEW, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.RSET_STATS); + diary.setTrue(SupportedFlags.DEFNEW, SupportedFlags.CMS, SupportedFlags.ICMS); + diary.setFalse(SupportedFlags.PARNEW, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.G1GC, SupportedFlags.RSET_STATS); break; case 6208: case 64: //G1GC - getDiary().setTrue(SupportedFlags.G1GC); - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setTrue(SupportedFlags.G1GC); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1); break; case 4096: - getDiary().setTrue(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); - getDiary().setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.G1GC, SupportedFlags.RSET_STATS, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setTrue(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC); + diary.setFalse(SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.G1GC, SupportedFlags.RSET_STATS, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1); break; case 4160: - getDiary().setTrue(SupportedFlags.G1GC); - getDiary().setFalse(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1); + diary.setTrue(SupportedFlags.G1GC); + diary.setFalse(SupportedFlags.PARALLELGC, SupportedFlags.PARALLELOLDGC, SupportedFlags.DEFNEW, SupportedFlags.PARNEW, SupportedFlags.CMS, SupportedFlags.ICMS, SupportedFlags.SERIAL, SupportedFlags.CMS_DEBUG_LEVEL_1); break; default: @@ -1028,21 +1031,21 @@ private void evaluateGCLogFlags() { } private void setGCCause(String gcCause) { - if (gcCause == null && getDiary().isPrintGCDetails()) { - getDiary().setFalse(SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); + if (gcCause == null && diary.isPrintGCDetails()) { + diary.setFalse(SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); } else if (gcCause != null) { if (GCCauses.get(gcCause) == GCCause.GCCAUSE_NOT_SET) { - if (getDiary().isPrintGCDetailsKnown() && getDiary().isPrintGCDetails()) { - getDiary().setFalse(SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); - getDiary().setTrue(SupportedFlags.JDK70); + if (diary.isPrintGCDetailsKnown() && diary.isPrintGCDetails()) { + diary.setFalse(SupportedFlags.GC_CAUSE, SupportedFlags.JDK80); + diary.setTrue(SupportedFlags.JDK70); } } else { if (gcCause.contains("System.gc()") || !gcCause.contains("System")) { - getDiary().setTrue(SupportedFlags.GC_CAUSE); - getDiary().setFalse(SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.GC_CAUSE); + diary.setFalse(SupportedFlags.PRE_JDK70_40); } else { - getDiary().setTrue(SupportedFlags.PRE_JDK70_40); - getDiary().setTrue(SupportedFlags.JDK70); + diary.setTrue(SupportedFlags.PRE_JDK70_40); + diary.setTrue(SupportedFlags.JDK70); } } } diff --git a/parser/src/main/java/com/microsoft/gctoolkit/parser/jvm/UnifiedDiarizer.java b/parser/src/main/java/com/microsoft/gctoolkit/parser/jvm/UnifiedDiarizer.java index 1f0c4639..a2dc68a1 100644 --- a/parser/src/main/java/com/microsoft/gctoolkit/parser/jvm/UnifiedDiarizer.java +++ b/parser/src/main/java/com/microsoft/gctoolkit/parser/jvm/UnifiedDiarizer.java @@ -41,9 +41,11 @@ public class UnifiedDiarizer implements Diarizer { public UnifiedDiarizer() {} public Diary getDiary() { + fillInKnowns(); return diary; } + @Override public boolean isUnified() { return true; @@ -62,19 +64,18 @@ public int getMaxTenuringThreshold() { @Override public boolean hasJVMEvents() { - return getDiary().isApplicationStoppedTime() || - getDiary().isApplicationRunningTime() || - getDiary().isTLABData(); + return diary.isApplicationStoppedTime() || + diary.isApplicationRunningTime() || + diary.isTLABData(); } - @Override - public void fillInKnowns() { - getDiary().setFalse(ADAPTIVE_SIZING); + private void fillInKnowns() { + diary.setFalse(ADAPTIVE_SIZING); } @Override public boolean completed() { - return getDiary().isComplete() || lineCount < 1; + return diary.isComplete() || lineCount < 1; } @Override @@ -84,11 +85,11 @@ public boolean diarize(String line) { return false; lineCount--; extractDecorators(line); - if (!getDiary().isCollectorKnown()) + if (!diary.isCollectorKnown()) discoverCollector(line); - if (!getDiary().isDetailsKnown()) + if (!diary.isDetailsKnown()) discoverDetails(line); - if (!getDiary().isJVMEventsKnown()) + if (!diary.isJVMEventsKnown()) discoverJVMEvents(line); if ((CPU_BREAKOUT.parse(line) != null) || line.contains("gc,start")) stopTheWorldEvents++; @@ -109,40 +110,40 @@ private void extractDecorators(String line) { if (decorators.getLogLevel().isPresent()) { UnifiedLoggingLevel logLevel = decorators.getLogLevel().get(); if (decorators.tagsContain("gc,age")) - getDiary().setTrue(TENURING_DISTRIBUTION); + diary.setTrue(TENURING_DISTRIBUTION); else if (decorators.tagsContain("ref") && logLevel.isGreaterThanOrEqualTo(UnifiedLoggingLevel.debug)) - getDiary().setTrue(PRINT_REFERENCE_GC); + diary.setTrue(PRINT_REFERENCE_GC); else if (decorators.tagsContain("gc,phases") && logLevel.isGreaterThanOrEqualTo(UnifiedLoggingLevel.debug)) - getDiary().setTrue(GC_DETAILS); + diary.setTrue(GC_DETAILS); else if ( decorators.tagsContain("gc,ergo")) - getDiary().setTrue(ADAPTIVE_SIZING); + diary.setTrue(ADAPTIVE_SIZING); if (decorators.tagsContain("safepoint")) - getDiary().setTrue(APPLICATION_STOPPED_TIME, APPLICATION_CONCURRENT_TIME); + diary.setTrue(APPLICATION_STOPPED_TIME, APPLICATION_CONCURRENT_TIME); - if (getDiary().isZGC()) { + if (diary.isZGC()) { if (decorators.tagsContain("task")) - getDiary().setTrue(GC_DETAILS); + diary.setTrue(GC_DETAILS); else if (decorators.tagsContain("heap")) - getDiary().setTrue(PRINT_HEAP_AT_GC); + diary.setTrue(PRINT_HEAP_AT_GC); else if (decorators.tagsContain("tlab")) - getDiary().setTrue(TLAB_DATA); + diary.setTrue(TLAB_DATA); else if (decorators.tagsContain("gc,start") && line.contains("Garbage Collection (")) - getDiary().setTrue(GC_CAUSE); + diary.setTrue(GC_CAUSE); else if (decorators.tagsContain("gc,heap")) { if (line.contains("Heap before GC")) - getDiary().setTrue(PRINT_HEAP_AT_GC); - getDiary().setTrue(GC_DETAILS); + diary.setTrue(PRINT_HEAP_AT_GC); + diary.setTrue(GC_DETAILS); } else if (decorators.tagsContain("gc,ref")) - getDiary().setTrue(PRINT_REFERENCE_GC); + diary.setTrue(PRINT_REFERENCE_GC); else if (decorators.tagsContain("gc,heap") && decorators.getLogLevel().get() == UnifiedLoggingLevel.debug) - getDiary().setTrue(PRINT_HEAP_AT_GC); - } else if (getDiary().isShenandoah()) { + diary.setTrue(PRINT_HEAP_AT_GC); + } else if (diary.isShenandoah()) { if (decorators.tagsContain("gc,task") || decorators.tagsContain("gc,start")) - getDiary().setTrue(GC_DETAILS); + diary.setTrue(GC_DETAILS); else if (decorators.tagsContain("gc,ergo")) - getDiary().setTrue(ADAPTIVE_SIZING); + diary.setTrue(ADAPTIVE_SIZING); else if (decorators.tagsContain("gc") && line.contains("Trigger")) - getDiary().setTrue(GC_CAUSE); + diary.setTrue(GC_CAUSE); } } } @@ -170,42 +171,42 @@ private void extractTagsAndLevels(Decorators decorators) { private void discoverCollector(String line) { if ( ZGC_TAG.parse(line) != null || CYCLE_START.parse(line) != null) { - getDiary().setTrue(ZGC); - getDiary().setFalse(DEFNEW, SERIAL, PARALLELGC, PARALLELOLDGC, PARNEW, CMS, ICMS, G1GC, RSET_STATS, SHENANDOAH, CMS_DEBUG_LEVEL_1, PRE_JDK70_40, JDK70, JDK80, TENURING_DISTRIBUTION, MAX_TENURING_THRESHOLD_VIOLATION, TLAB_DATA, PRINT_PROMOTION_FAILURE, PRINT_FLS_STATISTICS); + diary.setTrue(ZGC); + diary.setFalse(DEFNEW, SERIAL, PARALLELGC, PARALLELOLDGC, PARNEW, CMS, ICMS, G1GC, RSET_STATS, SHENANDOAH, CMS_DEBUG_LEVEL_1, PRE_JDK70_40, JDK70, JDK80, TENURING_DISTRIBUTION, MAX_TENURING_THRESHOLD_VIOLATION, TLAB_DATA, PRINT_PROMOTION_FAILURE, PRINT_FLS_STATISTICS); return; } if ( SHENANDOAH_TAG.parse(line) != null) { - getDiary().setTrue(SHENANDOAH); - getDiary().setFalse(DEFNEW, SERIAL, PARALLELGC, PARALLELOLDGC, PARNEW, CMS, ICMS, G1GC, RSET_STATS, ZGC, CMS_DEBUG_LEVEL_1, PRE_JDK70_40, JDK70, JDK80, TENURING_DISTRIBUTION, MAX_TENURING_THRESHOLD_VIOLATION, TLAB_DATA, PRINT_PROMOTION_FAILURE, PRINT_FLS_STATISTICS, PRINT_HEAP_AT_GC); + diary.setTrue(SHENANDOAH); + diary.setFalse(DEFNEW, SERIAL, PARALLELGC, PARALLELOLDGC, PARNEW, CMS, ICMS, G1GC, RSET_STATS, ZGC, CMS_DEBUG_LEVEL_1, PRE_JDK70_40, JDK70, JDK80, TENURING_DISTRIBUTION, MAX_TENURING_THRESHOLD_VIOLATION, TLAB_DATA, PRINT_PROMOTION_FAILURE, PRINT_FLS_STATISTICS, PRINT_HEAP_AT_GC); return; } if (G1_TAG.parse(line) != null || line.contains("G1 Evacuation Pause") || (line.contains("Humongous regions: "))) { - getDiary().setTrue(G1GC); - getDiary().setFalse(DEFNEW, SERIAL, PARALLELGC, PARALLELOLDGC, PARNEW, CMS, ICMS, ZGC, SHENANDOAH, CMS_DEBUG_LEVEL_1, PRE_JDK70_40, JDK70, JDK80, TLAB_DATA, PRINT_PROMOTION_FAILURE, PRINT_FLS_STATISTICS); + diary.setTrue(G1GC); + diary.setFalse(DEFNEW, SERIAL, PARALLELGC, PARALLELOLDGC, PARNEW, CMS, ICMS, ZGC, SHENANDOAH, CMS_DEBUG_LEVEL_1, PRE_JDK70_40, JDK70, JDK80, TLAB_DATA, PRINT_PROMOTION_FAILURE, PRINT_FLS_STATISTICS); return; } if (CMS_TAG.parse(line) != null || PARNEW_TAG.parse(line) != null || line.contains("ParNew")) { - getDiary().setTrue(PARNEW, CMS); - getDiary().setFalse(DEFNEW, SERIAL, PARALLELGC, PARALLELOLDGC, ICMS, CMS_DEBUG_LEVEL_1, G1GC, ZGC, SHENANDOAH, PRE_JDK70_40, JDK70, JDK80, RSET_STATS); + diary.setTrue(PARNEW, CMS); + diary.setFalse(DEFNEW, SERIAL, PARALLELGC, PARALLELOLDGC, ICMS, CMS_DEBUG_LEVEL_1, G1GC, ZGC, SHENANDOAH, PRE_JDK70_40, JDK70, JDK80, RSET_STATS); return; } if (PARALLEL_TAG.parse(line) != null || line.contains("ParOldGen") || line.contains("PSYoungGen")) { - getDiary().setTrue(PARALLELGC, PARALLELOLDGC, GC_CAUSE); - getDiary().setFalse(DEFNEW, SERIAL, PARNEW, CMS, ICMS, CMS_DEBUG_LEVEL_1, G1GC, ZGC, SHENANDOAH, PRE_JDK70_40, JDK70, JDK80, RSET_STATS); + diary.setTrue(PARALLELGC, PARALLELOLDGC, GC_CAUSE); + diary.setFalse(DEFNEW, SERIAL, PARNEW, CMS, ICMS, CMS_DEBUG_LEVEL_1, G1GC, ZGC, SHENANDOAH, PRE_JDK70_40, JDK70, JDK80, RSET_STATS); return; } if (SERIAL_TAG.parse(line) != null || line.contains("DefNew")) { - getDiary().setTrue(DEFNEW, SERIAL, GC_CAUSE); - getDiary().setFalse(PARALLELGC, PARALLELOLDGC, PARNEW, CMS, ICMS, CMS_DEBUG_LEVEL_1, G1GC, ZGC, SHENANDOAH, PRE_JDK70_40, JDK70, JDK80, RSET_STATS); + diary.setTrue(DEFNEW, SERIAL, GC_CAUSE); + diary.setFalse(PARALLELGC, PARALLELOLDGC, PARNEW, CMS, ICMS, CMS_DEBUG_LEVEL_1, G1GC, ZGC, SHENANDOAH, PRE_JDK70_40, JDK70, JDK80, RSET_STATS); return; } } @@ -218,26 +219,26 @@ private void discoverDetails(String line) { //todo: RSET_STATS for G1 not looked for... if (G1_COLLECTION.parse(line) != null) { - getDiary().setTrue(GC_CAUSE); + diary.setTrue(GC_CAUSE); } else if (CYCLE_START.parse(line) != null) { - getDiary().setTrue(GC_CAUSE); + diary.setTrue(GC_CAUSE); } if (stopTheWorldEvents > CYCLES_TO_EXAMINE_BEFORE_GIVING_UP) - getDiary().setFalse(ADAPTIVE_SIZING, GC_CAUSE, TLAB_DATA, PRINT_REFERENCE_GC, PRINT_PROMOTION_FAILURE, PRINT_FLS_STATISTICS, RSET_STATS, PRINT_HEAP_AT_GC); + diary.setFalse(ADAPTIVE_SIZING, GC_CAUSE, TLAB_DATA, PRINT_REFERENCE_GC, PRINT_PROMOTION_FAILURE, PRINT_FLS_STATISTICS, RSET_STATS, PRINT_HEAP_AT_GC); } private void discoverJVMEvents(String line) { if (stopTheWorldEvents > CYCLES_TO_EXAMINE_FOR_SAFEPOINT) { - getDiary().setFalse(APPLICATION_STOPPED_TIME, APPLICATION_CONCURRENT_TIME); + diary.setFalse(APPLICATION_STOPPED_TIME, APPLICATION_CONCURRENT_TIME); } } @Override public DateTimeStamp getTimeOfFirstEvent() { - return getDiary().getTimeOfFirstEvent(); + return diary.getTimeOfFirstEvent(); } } \ No newline at end of file diff --git a/parser/src/test/java/com/microsoft/gctoolkit/parser/GenerationalHeapParserTest.java b/parser/src/test/java/com/microsoft/gctoolkit/parser/GenerationalHeapParserTest.java index 084c090c..7ee2f648 100644 --- a/parser/src/test/java/com/microsoft/gctoolkit/parser/GenerationalHeapParserTest.java +++ b/parser/src/test/java/com/microsoft/gctoolkit/parser/GenerationalHeapParserTest.java @@ -5,24 +5,22 @@ import com.microsoft.gctoolkit.event.generational.AbortablePreClean; import com.microsoft.gctoolkit.event.generational.CMSRemark; import com.microsoft.gctoolkit.event.generational.ConcurrentMark; +import com.microsoft.gctoolkit.event.generational.ConcurrentModeFailure; import com.microsoft.gctoolkit.event.generational.ConcurrentPreClean; import com.microsoft.gctoolkit.event.generational.ConcurrentReset; import com.microsoft.gctoolkit.event.generational.ConcurrentSweep; +import com.microsoft.gctoolkit.event.generational.FullGC; import com.microsoft.gctoolkit.event.generational.InitialMark; +import com.microsoft.gctoolkit.event.generational.ParNew; import com.microsoft.gctoolkit.event.jvm.JVMEvent; import com.microsoft.gctoolkit.jvm.Diarizer; -import com.microsoft.gctoolkit.jvm.Diary; -import com.microsoft.gctoolkit.parser.GCLogParser; -import com.microsoft.gctoolkit.parser.GenerationalHeapParser; import com.microsoft.gctoolkit.parser.jvm.PreUnifiedDiarizer; -import com.microsoft.gctoolkit.parser.ParserTest; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import java.util.List; -import java.util.concurrent.atomic.AtomicBoolean; -import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.junit.jupiter.api.Assertions.fail; +import static org.junit.jupiter.api.Assertions.*; public class GenerationalHeapParserTest extends ParserTest { @@ -31,41 +29,35 @@ public class GenerationalHeapParserTest extends ParserTest { @Test public void canParseLFSFullGC() { - String fragment = "2019-11-14T23:50:29.896+0000: 91334.028: [Full GC (Allocation Failure) Before GC:\n" + - "Statistics for BinaryTreeDictionary:\n" + - "------------------------------------\n" + - "Total Free Space: 1261\n" + - "Max Chunk Size: 1261\n" + - "Number of Blocks: 1\n" + - "Av. Block Size: 1261\n" + - "Tree Height: 1\n" + - "2019-11-14T23:50:29.896+0000: 91334.028: [CMSCMS: Large block 0x00000007bfffd898\n" + - ": 2097142K->2097142K(2097152K), 1.9092744 secs] 4063215K->4063215K(4063232K), [Metaspace: 99441K->99441K(1140736K)]After GC:\n" + - "Statistics for BinaryTreeDictionary:\n" + - "------------------------------------\n" + - "Total Free Space: 1261\n" + - "Max Chunk Size: 1261\n" + - "Number of Blocks: 1\n" + - "Av. Block Size: 1261\n" + - "Tree Height: 1\n" + - ", 1.9094806 secs] [Times: user=1.91 sys=0.00, real=1.91 secs]\n" + - "2019-11-14T23:50:31.806+0000: 91335.938: Total time for which application threads were stopped: 4.0762194 seconds, Stopping threads took: 0.0000522 seconds\n"; - - AtomicBoolean eventCreated = new AtomicBoolean(false); - GenerationalHeapParser parser = new GenerationalHeapParser(); //, event -> { - parser.diary(new Diary()); -// parser. -// Assertions.assertTrue(event instanceof FullGC); -// FullGC fgc = (FullGC) event; -// Assertions.assertEquals(1.9094806d, fgc.getDuration()); -// Assertions.assertEquals(4063232, fgc.getHeap().getSizeAfterCollection()); -// eventCreated.set(true); -// }); -// -// Arrays.stream(fragment.split("\n")).forEach(parser::receive); -// -// Assertions.assertTrue(eventCreated.get()); + String[] lines = {"2019-11-14T23:50:29.896+0000: 91334.028: [Full GC (Allocation Failure) Before GC:", + "Statistics for BinaryTreeDictionary:", + "------------------------------------", + "Total Free Space: 1261", + "Max Chunk Size: 1261", + "Number of Blocks: 1", + "Av. Block Size: 1261", + "Tree Height: 1", + "2019-11-14T23:50:29.896+0000: 91334.028: [CMSCMS: Large block 0x00000007bfffd898", + ": 2097142K->2097142K(2097152K), 1.9092744 secs] 4063215K->4063215K(4063232K), [Metaspace: 99441K->99441K(1140736K)]After GC:", + "Statistics for BinaryTreeDictionary:", + "------------------------------------", + "Total Free Space: 1261", + "Max Chunk Size: 1261", + "Number of Blocks: 1", + "Av. Block Size: 1261", + "Tree Height: 1", + ", 1.9094806 secs] [Times: user=1.91 sys=0.00, real=1.91 secs]" + }; + + List jvmEvents = feedParser(lines); + try { + FullGC fgc = (FullGC) jvmEvents.get(0); + Assertions.assertEquals(1.9094806d, fgc.getDuration()); + Assertions.assertEquals(4063232, fgc.getHeap().getSizeAfterCollection()); + } catch(Throwable t) { + fail(t); + } } @Test @@ -134,6 +126,74 @@ public void testReferenceProcessingInConcurrentCycle() { assertTrue(true); } + @Test + public void testThat2CMFDoNotHappen() { + String[][] lines = new String[][]{ + { + "57721.729: [GC [1 CMS-initial-mark: 763361K(786432K)] 767767K(1022400K), 0.0022735 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]", + "57721.732: [CMS-concurrent-mark-start]", + "57722.918: [GC 57722.918: [ParNew: 209792K->26176K(235968K), 0.0618431 secs] 973153K->802453K(1022400K), 0.0620347 secs] [Times: user=0.38 sys=0.00, real=0.06 secs]", + "57724.218: [Full GC 57724.218: [CMS2010-04-21T10:45:33.367+0100: 57724.319: [CMS-concurrent-mark: 2.519/2.587 secs] [Times: user=12.58 sys=0.09, real=2.59 secs]", + "(concurrent mode failure): 776277K->770654K(786432K), 6.0499857 secs] 1012245K->770654K(1022400K), [CMS Perm : 23211K->23211K(38736K)], 6.0501617 secs] [Times: user=6.09 sys=0.00, real=6.05 secs]" + }, + { + "58272.354: [GC [1 CMS-initial-mark: 786431K(786432K)] 794666K(1022400K), 0.0088514 secs] [Times: user=0.01 sys=0.00, real=0.02 secs]", + "58272.363: [CMS-concurrent-mark-start]", + "58273.778: [Full GC 58273.778: [CMS2010-04-21T10:54:43.688+0100: 58274.663: [CMS-concurrent-mark: 2.299/2.300 secs] [Times: user=8.69 sys=0.11, real=2.30 secs]", + "(concurrent mode failure): 786431K->785452K(786432K), 6.5738696 secs] 1022399K->785452K(1022400K), [CMS Perm : 23211K->23211K(38736K)], 6.5740517 secs] [Times: user=7.44 sys=0.00, real=6.56 secs]" + } + }; + + Class[][] eventTypes = { + {InitialMark.class, ConcurrentMark.class, ParNew.class, ConcurrentModeFailure.class}, + {InitialMark.class, ConcurrentMark.class, ConcurrentModeFailure.class} + }; + + for (int i = 0; i < lines.length; i++) { + List jvmEvents = feedParser(lines[i]); + + for (int j = 0; j < eventTypes[i].length; j++) { + assertEquals(jvmEvents.get(j).getClass(), eventTypes[i][j]); + } + jvmEvents.clear(); + } + } + + @Test + public void basicLogTest() { + String[] lines = { + "9.089: [GC 17024K->1751K(2095040K), 0.0308466 secs", + "21.464: [GC 18775K->3413K(2095040K), 0.0431857 secs", + "29.141: [GC 20437K->2693K(2095040K), 0.0045342 secs", + "33.155: [GC 19717K->3974K(2095040K), 0.0115157 secs", + "36.966: [GC 20998K->5300K(2095040K), 0.0269848 secs", + "40.351: [GC 22324K->4799K(2095040K), 0.0071082 secs", + "43.373: [GC 21823K->5862K(2095040K), 0.0105840 secs", + "46.464: [GC 22886K->6859K(2095040K), 0.0289186 secs", + "49.185: [GC 23883K->8778K(2095040K), 0.0303312 secs", + "51.113: [GC 25802K->8674K(2095040K), 0.0119712 secs", + "54.218: [GC 25698K->9720K(2095040K), 0.0098641 secs", + "57.311: [GC 26744K->11179K(2095040K), 0.0212367 secs", + "60.249: [GC 28203K->11381K(2095040K), 0.0087235 secs", + "62.602: [GC 28405K->12469K(2095040K), 0.0258451 secs", + "65.245: [GC 29493K->13720K(2095040K), 0.0188990 secs", + "67.554: [GC 30744K->15788K(2095040K), 0.0296812 secs", + "69.923: [GC 32812K->16455K(2095040K), 0.0232905 secs", + "72.100: [GC 33479K->17013K(2095040K), 0.0100926 secs", + "74.262: [GC 34037K->18471K(2095040K), 0.0247458 secs", + "76.203: [GC 35495K->20250K(2095040K), 0.0270935 secs", + "78.319: [GC 37274K->21322K(2095040K), 0.0234226 secs", + "80.257: [GC 38346K->21604K(2095040K), 0.0097355 secs", + "82.298: [GC 38628K->22911K(2095040K), 0.0228335 secs", + "84.129: [GC 39935K->23835K(2095040K), 0.0203206 secs" + }; + + List jvmEvents = feedParser(lines); + assertEquals(24, jvmEvents.size()); + assertEquals(9.089,getParser().diary.getTimeOfFirstEvent().toSeconds()); + } + + @Override protected Diarizer diarizer() { return new PreUnifiedDiarizer(); @@ -143,4 +203,5 @@ protected Diarizer diarizer() { protected GCLogParser parser() { return new GenerationalHeapParser(); } + } diff --git a/parser/src/test/java/com/microsoft/gctoolkit/parser/ParserTest.java b/parser/src/test/java/com/microsoft/gctoolkit/parser/ParserTest.java index a4ae4f89..9813e801 100644 --- a/parser/src/test/java/com/microsoft/gctoolkit/parser/ParserTest.java +++ b/parser/src/test/java/com/microsoft/gctoolkit/parser/ParserTest.java @@ -44,6 +44,10 @@ public void setUp() { */ protected abstract GCLogParser parser(); + GCLogParser getParser() { + return this.parser; + } + /** * Parser runs in its own thread so start one for it and then feed it the lines to be parsed * diff --git a/parser/src/test/java/com/microsoft/gctoolkit/parser/UnifiedG1GCParserFragmentTest.java b/parser/src/test/java/com/microsoft/gctoolkit/parser/UnifiedG1GCParserFragmentTest.java new file mode 100644 index 00000000..b63ec483 --- /dev/null +++ b/parser/src/test/java/com/microsoft/gctoolkit/parser/UnifiedG1GCParserFragmentTest.java @@ -0,0 +1,96 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. +package com.microsoft.gctoolkit.parser; + +import com.microsoft.gctoolkit.event.g1gc.G1Young; +import com.microsoft.gctoolkit.event.jvm.JVMEvent; +import com.microsoft.gctoolkit.jvm.Diarizer; +import com.microsoft.gctoolkit.parser.diary.TestLogFile; +import com.microsoft.gctoolkit.parser.jvm.UnifiedDiarizer; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.nio.file.Path; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.fail; + +public class UnifiedG1GCParserFragmentTest extends ParserTest { + + @Override + protected Diarizer diarizer() { + return new UnifiedDiarizer(); + } + + @Override + protected GCLogParser parser() { + return new UnifiedG1GCParser(); + } + + + @Test + public void testNewDecoratorCombination() { + String[] lines = { + "[2023-12-06T07:32:54.113+0000][25ms] Using G1", + "[2023-12-06T07:32:54.117+0000][29ms] Version: 17.0.2+8-86 (release)", + "[2023-12-06T07:32:54.117+0000][29ms] CPUs: 2 total, 2 available", + "[2023-12-06T07:32:54.117+0000][29ms] Memory: 6531M", + "[2023-12-06T07:32:54.117+0000][29ms] Large Page Support: Disabled", + "[2023-12-06T07:32:54.117+0000][29ms] NUMA Support: Disabled", + "[2023-12-06T07:32:54.117+0000][29ms] Compressed Oops: Enabled (32-bit)", + "[2023-12-06T07:32:54.117+0000][29ms] Heap Region Size: 1M", + "[2023-12-06T07:32:54.117+0000][29ms] Heap Min Capacity: 8M", + "[2023-12-06T07:32:54.117+0000][29ms] Heap Initial Capacity: 104M", + "[2023-12-06T07:32:54.117+0000][29ms] Heap Max Capacity: 1634M", + "[2023-12-06T07:32:54.117+0000][29ms] Pre-touch: Disabled", + "[2023-12-06T07:32:54.117+0000][29ms] Parallel Workers: 2", + "[2023-12-06T07:32:54.117+0000][29ms] Concurrent Workers: 1", + "[2023-12-06T07:32:54.117+0000][29ms] Concurrent Refinement Workers: 2", + "[2023-12-06T07:32:54.117+0000][29ms] Periodic GC: Disabled", + "[2023-12-06T07:32:54.117+0000][29ms] CDS archive(s) mapped at: [0x0000000800000000-0x0000000800bdf000-0x0000000800bdf000), size 12447744, SharedBaseAddress: 0x0000000800000000, ArchiveRelocationMode: 0.", + "[2023-12-06T07:32:54.117+0000][29ms] Compressed class space mapped at: 0x0000000800c00000-0x0000000840c00000, reserved size: 1073741824", + "[2023-12-06T07:32:54.117+0000][29ms] Narrow klass base: 0x0000000800000000, Narrow klass shift: 0, Narrow klass range: 0x100000000", + "[2023-12-06T07:32:54.359+0000][270ms] GC(0) Pause Young (Normal) (G1 Evacuation Pause)", + "[2023-12-06T07:32:54.359+0000][270ms] GC(0) Using 2 workers of 2 for evacuation", + "[2023-12-06T07:32:54.368+0000][280ms] GC(0) Pre Evacuate Collection Set: 0.1ms", + "[2023-12-06T07:32:54.368+0000][280ms] GC(0) Merge Heap Roots: 0.0ms", + "[2023-12-06T07:32:54.368+0000][280ms] GC(0) Evacuate Collection Set: 5.2ms:", + "[2023-12-06T07:32:54.368+0000][280ms] GC(0) Post Evacuate Collection Set: 3.9ms", + "[2023-12-06T07:32:54.368+0000][280ms] GC(0) Other: 0.2ms", + "[2023-12-06T07:32:54.368+0000][280ms] GC(0) Eden regions: 6->0(8)", + "[2023-12-06T07:32:54.368+0000][280ms] GC(0) Survivor regions: 0->1(1)", + "[2023-12-06T07:32:54.368+0000][280ms] GC(0) Old regions: 0->0", + "[2023-12-06T07:32:54.368+0000][280ms] GC(0) Archive regions: 2->2", + "[2023-12-06T07:32:54.368+0000][280ms] GC(0) Humongous regions: 3->3", + "[2023-12-06T07:32:54.368+0000][280ms] GC(0) Metaspace: 858K(1024K)->858K(1024K) NonClass: 780K(832K)->780K(832K) Class: 77K(192K)->77K(192K)", + "[2023-12-06T07:32:54.368+0000][280ms] GC(0) Pause Young (Normal) (G1 Evacuation Pause) 9M->4M(106M) 9.598ms", + "[2023-12-06T07:32:54.368+0000][280ms] GC(0) User=0.00s Sys=0.01s Real=0.01s", + "[2023-12-06T07:32:54.696+0000][608ms] GC(1) Pause Young (Normal) (G1 Evacuation Pause)", + "[2023-12-06T07:32:54.696+0000][608ms] GC(1) Using 2 workers of 2 for evacuation", + "[2023-12-06T07:32:54.701+0000][612ms] GC(1) Pre Evacuate Collection Set: 0.1ms", + "[2023-12-06T07:32:54.701+0000][613ms] GC(1) Merge Heap Roots: 0.0ms", + "[2023-12-06T07:32:54.701+0000][613ms] GC(1) Evacuate Collection Set: 4.3ms", + "[2023-12-06T07:32:54.701+0000][613ms] GC(1) Post Evacuate Collection Set: 0.3ms", + "[2023-12-06T07:32:54.701+0000][613ms] GC(1) Other: 0.1ms", + "[2023-12-06T07:32:54.701+0000][613ms] GC(1) Eden regions: 8->0(60)", + "[2023-12-06T07:32:54.701+0000][613ms] GC(1) Survivor regions: 1->2(2)", + "[2023-12-06T07:32:54.701+0000][613ms] GC(1) Old regions: 0->0", + "[2023-12-06T07:32:54.701+0000][613ms] GC(1) Archive regions: 2->2", + "[2023-12-06T07:32:54.701+0000][613ms] GC(1) Humongous regions: 3->3", + "[2023-12-06T07:32:54.701+0000][613ms] GC(1) Metaspace: 3551K(3712K)->3551K(3712K) NonClass: 3113K(3200K)->3113K(3200K) Class: 438K(512K)->438K(512K)", + "[2023-12-06T07:32:54.701+0000][613ms] GC(1) Pause Young (Normal) (G1 Evacuation Pause) 12M->5M(106M) 4.985ms", + "[2023-12-06T07:32:54.701+0000][613ms] GC(1) User=0.00s Sys=0.00s Real=0.00s" + }; + + List jvmEvents = feedParser(lines); + + try { + Assertions.assertEquals(2, jvmEvents.size()); + Assertions.assertEquals(G1Young.class, jvmEvents.get(0).getClass()); + Assertions.assertEquals(G1Young.class, jvmEvents.get(1).getClass()); + } catch(Throwable t) { + fail(t); + } + } +} diff --git a/parser/src/test/java/com/microsoft/gctoolkit/parser/diary/LogDiaryTest.java b/parser/src/test/java/com/microsoft/gctoolkit/parser/diary/LogDiaryTest.java index 11a77ebd..7cf36fb1 100644 --- a/parser/src/test/java/com/microsoft/gctoolkit/parser/diary/LogDiaryTest.java +++ b/parser/src/test/java/com/microsoft/gctoolkit/parser/diary/LogDiaryTest.java @@ -13,6 +13,7 @@ import java.io.File; import java.io.IOException; import java.util.Objects; +import java.util.stream.Stream; import static org.junit.jupiter.api.Assertions.fail; @@ -32,7 +33,6 @@ protected Diarizer getJVMConfiguration(GCLogFile gcLogFile) throws IOException { filter(completed -> completed). findFirst(); - jvmConfiguration.fillInKnowns(); return jvmConfiguration; } diff --git a/parser/src/test/java/com/microsoft/gctoolkit/parser/unittests/CMSParNewParserTest.java b/parser/src/test/java/com/microsoft/gctoolkit/parser/unittests/CMSParNewParserTest.java index 46654b82..8dd2f1bb 100644 --- a/parser/src/test/java/com/microsoft/gctoolkit/parser/unittests/CMSParNewParserTest.java +++ b/parser/src/test/java/com/microsoft/gctoolkit/parser/unittests/CMSParNewParserTest.java @@ -84,8 +84,8 @@ public void testForDetails() { private static final int[][] detailsCounts = { // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 - {0, 0, 3668, 12, 0, 95, 0, 0, 22, 0, 0, 156, 68, 105, 73, 71, 66, 66}, //todo: these numbers don't seem to add up - {0, 0, 2021, 1, 0, 8, 0, 0, 0, 0, 0, 71, 70, 71, 71, 70, 66, 63}, + {0, 0, 3668, 12, 0, 96, 0, 0, 22, 0, 0, 156, 68, 156, 75, 71, 68, 66}, //todo: these numbers don't seem to add up + {0, 0, 2021, 1, 0, 8, 0, 0, 0, 0, 0, 71, 70, 71, 71, 70, 70, 63}, {0, 0, 24981, 0, 0, 0, 0, 0, 0, 0, 2, 334, 333, 0, 0, 0, 0, 0}, {0, 0, 2762, 0, 0, 0, 0, 0, 3, 0, 0, 50, 49, 50, 49, 49, 49, 49}, {0, 0, 713, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1}, @@ -191,12 +191,12 @@ public void testForDetailsTenuring() { // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 { 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, { 0, 0, 14816, 0, 0, 0, 0, 0, 0, 0, 0, 30, 30, 30, 30, 30, 30, 30 }, - { 0, 0, 3370, 4, 0, 5, 0, 0, 0, 0, 3, 16, 12, 16, 16, 13, 11, 11}, + { 0, 0, 3370, 4, 0, 5, 0, 0, 0, 0, 3, 16, 12, 16, 16, 13, 12, 11}, { 0, 0, 35995, 0, 0, 15, 0, 0, 0, 0, 0, 13676, 13673, 13673, 13673, 0, 13672, 13672}, { 0, 0, 30334, 0, 0, 12, 0, 0, 0, 0, 0, 12339, 12336, 12336, 12336, 0, 12336, 12336}, { 0, 0, 34285, 0, 0, 14, 0, 0, 0, 0, 0, 13354, 13350, 13350, 13350, 0, 13349, 13349}, // todo: audit cmf count feels wrong - { 0, 0, 4592, 0, 0, 5, 0, 0, 0, 0, 3, 45, 43, 45, 44, 16, 40, 40}, // todo: audit abortable pre-clean feels wrong - { 0, 0, 47, 1, 0, 22, 14, 0, 18, 0, 2, 208, 172, 202, 197, 169, 172, 172}, // todo: audit expected 202 - 22 = 186 + { 0, 0, 4592, 0, 0, 5, 0, 0, 0, 0, 3, 45, 43, 45, 45, 17, 43, 40}, + { 0, 0, 47, 1, 0, 22, 17, 0, 19, 0, 2, 210, 172, 210, 200, 178, 172, 172}, // todo: audit expected 210 - 22 = 188, not 172 { 0, 0, 3369, 6, 0, 6, 0, 0, 0, 0, 3, 17, 11, 17, 17, 15, 11, 11}, { 0, 0, 5305, 0, 0, 0, 0, 0, 0, 0, 0, 918, 917, 917, 917, 915, 917, 917}, { 0, 0, 146, 0, 0, 0, 0, 0, 0, 0, 0, 1402, 1402, 1402, 1402, 1375, 1402, 1402}, @@ -204,9 +204,9 @@ public void testForDetailsTenuring() { { 0, 0, 46228, 0, 0, 0, 0, 0, 0, 0, 17, 1, 1, 1, 1, 1, 1, 1}, { 0, 0, 47000, 0, 0, 0, 0, 0, 0, 0, 15, 2, 2, 2, 2, 2, 2, 2}, { 0, 0, 48222, 0, 0, 0, 0, 0, 0, 0, 17, 1, 1, 1, 1, 1, 1, 1}, - { 0, 0, 3370, 4, 0, 5, 0, 0, 0, 0, 3, 16, 12, 16, 16, 13, 11, 11}, + { 0, 0, 3370, 4, 0, 5, 0, 0, 0, 0, 3, 16, 12, 16, 16, 13, 12, 11}, { 0, 0, 1333, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1}, - { 0, 0, 508, 0, 0, 0, 1, 0, 0, 0, 1395, 5, 4, 5, 5, 4, 4, 4}, // todo: audit, expected 5 at the end + { 0, 0, 508, 0, 0, 0, 1, 0, 0, 0, 1395, 5, 4, 5, 5, 5, 4, 4}, // todo: audit, expected 5 at the end { 0, 0, 23829, 0, 0, 0, 0, 0, 0, 0, 0, 978, 977, 977, 977, 959, 975, 975} // todo: audit, how were 2 concurrent cycles lost }; @@ -264,7 +264,7 @@ public void testForParNewDetailsTenuringReference80() { private static final int[][] parNewDetailsTenuringReference180Counts = { // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 - {0, 0, 15338, 0, 0, 3, 0, 0, 3, 0, 7, 7, 1, 4, 1, 1, 1, 1} + {0, 0, 15338, 0, 0, 3, 0, 0, 3, 0, 7, 7, 1, 7, 1, 1, 1, 1} }; diff --git a/parser/src/test/java/com/microsoft/gctoolkit/parser/unittests/ICMSParNewParserTest.java b/parser/src/test/java/com/microsoft/gctoolkit/parser/unittests/ICMSParNewParserTest.java index acdc9b89..ad33b936 100644 --- a/parser/src/test/java/com/microsoft/gctoolkit/parser/unittests/ICMSParNewParserTest.java +++ b/parser/src/test/java/com/microsoft/gctoolkit/parser/unittests/ICMSParNewParserTest.java @@ -7,7 +7,6 @@ import java.io.IOException; import java.nio.file.Path; -import java.util.logging.Logger; import static org.junit.jupiter.api.Assertions.fail; @@ -19,8 +18,6 @@ public class ICMSParNewParserTest extends ParserTest { Young, DefNew, ParNew, ParNew (promotion failed), ParNew (concurrent mode failure), concurrent-mode-failure, concurrent mode interrupted, PSYoungGen, Full GC/PSFull, Full GC (concurrent mode failure), System.gc(), Initial-mark, Remark */ - private static final Logger LOGGER = Logger.getLogger(ICMSParNewParserTest.class.getName()); - @Test public void testForSimpleLogs() { int i = 0; @@ -55,12 +52,12 @@ public void testForSimpleLogs() { private static final int[][] detailsCounts = { // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 - { 0, 0, 12359, 41, 0, 41, 0, 0, 0, 0, 0, 179, 166, 178, 169, 166, 149, 138}, + { 0, 0, 12359, 41, 0, 41, 0, 0, 0, 0, 0, 179, 166, 179, 177, 166, 166, 138}, { 0, 0, 2564, 0, 0, 0, 0, 0, 0, 0, 0, 13, 13, 13, 13, 13, 13, 13}, { 0, 0, 2564, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11, 11, 11, 11, 11, 11}, - { 0, 0, 1374, 0, 0, 0, 1, 0, 0, 0, 0, 3, 2, 2, 2, 2, 2, 2}, - { 0, 0, 143543, 75, 0, 306, 0, 0, 7, 0, 1, 10272, 10015, 10128, 10035, 10018, 10014, 9969}, - { 0, 0, 72395, 43, 0, 173, 0, 0, 4, 0, 1, 5137, 4985, 5081, 4994, 4986, 4985, 4966} + { 0, 0, 1374, 0, 0, 0, 1, 0, 0, 0, 0, 3, 2, 3, 2, 2, 2, 2}, + { 0, 0, 143543, 75, 0, 306, 0, 0, 7, 0, 1, 10272, 10015, 10271, 10039, 10018, 10015, 9969}, + { 0, 0, 72395, 43, 0, 173, 0, 0, 4, 0, 1, 5137, 4985, 5136, 4994, 4986, 4985, 4966} }; @@ -99,9 +96,9 @@ public void testForDetailsTenuring() { // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 { 0, 0, 67, 0, 0, 1, 0, 0, 1, 0, 0, 25, 24, 25, 24, 24, 24, 24}, { 0, 0, 6240, 0, 0, 0, 0, 0, 0, 0, 1, 2087, 2087, 2087, 2087, 2087, 2086, 2086}, - { 0, 0, 417811, 83, 0, 84, 0, 0, 76, 0, 0, 7840, 7809, 7824, 7809, 7783, 7756, 7756}, - { 0, 0, 32439, 0, 0, 0, 0, 0, 0, 0, 0, 103, 103, 103, 103, 102, 102, 102}, // todo: audit as 103 expected - { 0, 0, 18507, 0, 0, 0, 1, 0, 0, 0, 0, 6, 5, 5, 5, 5, 5, 5}, + { 0, 0, 417811, 83, 0, 84, 0, 0, 76, 0, 0, 7840, 7809, 7824, 7809, 7783, 7757, 7756}, + { 0, 0, 32439, 0, 0, 0, 0, 0, 0, 0, 0, 103, 103, 103, 103, 102, 102, 102}, + { 0, 0, 18507, 0, 0, 0, 1, 0, 0, 0, 0, 6, 5, 6, 5, 5, 5, 5}, }; diff --git a/parser/src/test/java/com/microsoft/gctoolkit/parser/unittests/ParserTest.java b/parser/src/test/java/com/microsoft/gctoolkit/parser/unittests/ParserTest.java index 43cfb18c..e925e55f 100644 --- a/parser/src/test/java/com/microsoft/gctoolkit/parser/unittests/ParserTest.java +++ b/parser/src/test/java/com/microsoft/gctoolkit/parser/unittests/ParserTest.java @@ -111,8 +111,6 @@ private Diarizer getJVMConfiguration(GCLogFile gcLogFile) { map(jvmConfiguration::diarize). filter(completed -> completed). findFirst(); - - jvmConfiguration.fillInKnowns(); return jvmConfiguration; } catch (IOException e) { fail(e.getMessage());