Skip to content

Commit

Permalink
Refactored tests and updated method params
Browse files Browse the repository at this point in the history
  • Loading branch information
@yanqilee
yanqilee committed Jan 23, 2019
1 parent 2576e5d commit 18d4275
Show file tree
Hide file tree
Showing 2 changed files with 117 additions and 62 deletions.
2 changes: 1 addition & 1 deletion src/main/java/com/tagtraum/perf/gcviewer/imp/DataReaderUnifiedJvmLogging.java
View file
Expand Up @@ -465,7 +465,7 @@ private void setMemoryHeapWithPercentage(AbstractGCEvent<?> event, Matcher match
Integer.parseInt(matcher.group(GROUP_HEAP_MEMORY_PERCENTAGE_VALUE)), matcher.group(GROUP_HEAP_MEMORY_PERCENTAGE_UNIT).charAt(0), matcher.group(GROUP_HEAP_MEMORY_PERCENTAGE)));
}

private void setMemoryWithPercentage(AbstractGCEvent event, Matcher matcher) {
private void setMemoryWithPercentage(AbstractGCEvent<?> event, Matcher matcher) {
event.setPreUsed(getDataReaderTools().getMemoryInKiloByte(
Integer.parseInt(matcher.group(GROUP_MEMORY_PERCENTAGE_BEFORE)), matcher.group(GROUP_MEMORY_PERCENTAGE_BEFORE_UNIT).charAt(0), matcher.group(GROUP_MEMORY_PERCENTAGE)));
event.setPostUsed(getDataReaderTools().getMemoryInKiloByte(
Expand Down
177 changes: 116 additions & 61 deletions src/test/java/com/tagtraum/perf/gcviewer/imp/TestDataReaderUJLZGC.java
View file
Expand Up @@ -8,128 +8,154 @@
import com.tagtraum.perf.gcviewer.UnittestHelper;
import com.tagtraum.perf.gcviewer.model.AbstractGCEvent;
import com.tagtraum.perf.gcviewer.model.GCModel;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
* Test unified java logging ZGC algorithm in OpenJDK 11
*/
public class TestDataReaderUJLZGC {
private GCModel gcAllModel;
private GCModel gcDefaultModel;

private GCModel getGCModelFromLogFile(String fileName) throws IOException {
return UnittestHelper.getGCModelFromLogFile(fileName, UnittestHelper.FOLDER.OPENJDK_UJL, DataReaderUnifiedJvmLogging.class);
}

@Test
public void testGcAll() throws Exception {
GCModel model = getGCModelFromLogFile("sample-ujl-zgc-gc-all.txt");
assertThat("size", model.size(), is(11));
assertThat("amount of gc event types", model.getGcEventPauses().size(), is(3));
assertThat("amount of gc events", model.getGCPause().getN(), is(3));
assertThat("amount of full gc event types", model.getFullGcEventPauses().size(), is(0));
assertThat("amount of full gc events", model.getFullGCPause().getN(), is(0));
assertThat("amount of concurrent pause types", model.getConcurrentEventPauses().size(), is(7));

testGcAllPause(model);
@Before
public void setUp() throws Exception {
gcAllModel = getGCModelFromLogFile("sample-ujl-zgc-gc-all.txt");
gcDefaultModel = getGCModelFromLogFile("sample-ujl-zgc-gc-default.txt");
}

testGcAllConcurrent(model);
@After
public void tearDown() {
gcAllModel = null;
gcDefaultModel = null;
}

AbstractGCEvent<?> garbageCollectionEvent = model.get(10);
UnittestHelper.testMemoryPauseEvent(garbageCollectionEvent,
"Garbage Collection",
AbstractGCEvent.Type.UJL_ZGC_GARBAGE_COLLECTION,
0,
1024 * 10620, 1024 * 8800, 1024 * 194560,
AbstractGCEvent.Generation.TENURED,
false);
assertThat("preused heap percentage", garbageCollectionEvent.getPreUsedPercent(), is(5));
assertThat("postused heap percentage", garbageCollectionEvent.getPostUsedPercent(), is(4));
@Test
public void testGcAll() {
assertThat("size", gcAllModel.size(), is(11));
assertThat("amount of gc event types", gcAllModel.getGcEventPauses().size(), is(3));
assertThat("amount of gc events", gcAllModel.getGCPause().getN(), is(3));
assertThat("amount of full gc event types", gcAllModel.getFullGcEventPauses().size(), is(0));
assertThat("amount of full gc events", gcAllModel.getFullGCPause().getN(), is(0));
assertThat("amount of concurrent pause types", gcAllModel.getConcurrentEventPauses().size(), is(7));
}

public void testGcAllPause(GCModel model) {
AbstractGCEvent<?> pauseMarkStartEvent = model.get(0);
@Test
public void testGcAllPauseMarkStart() {
AbstractGCEvent<?> pauseMarkStartEvent = gcAllModel.get(0);
UnittestHelper.testMemoryPauseEvent(pauseMarkStartEvent,
"Pause Mark Start",
AbstractGCEvent.Type.UJL_ZGC_PAUSE_MARK_START,
0.001279,
0, 0, 0,
AbstractGCEvent.Generation.TENURED,
false);

AbstractGCEvent<?> pauseMarkEndEvent = model.get(2);
UnittestHelper.testMemoryPauseEvent(pauseMarkEndEvent,
"Pause Mark End",
AbstractGCEvent.Type.UJL_ZGC_PAUSE_MARK_END,
0.000695,
0, 0, 0,
AbstractGCEvent.Generation.TENURED,
false);

AbstractGCEvent<?> pauseRelocateStartEvent = model.get(8);
UnittestHelper.testMemoryPauseEvent(pauseRelocateStartEvent,
"Pause Relocate Start",
AbstractGCEvent.Type.UJL_ZGC_PAUSE_RELOCATE_START,
0.000679,
0, 0, 0,
AbstractGCEvent.Generation.TENURED,
false);
}

public void testGcAllConcurrent(GCModel model) {
AbstractGCEvent<?> concurrentMarkEvent = model.get(1);
@Test
public void testGcAllConcurrentMark() {
AbstractGCEvent<?> concurrentMarkEvent = gcAllModel.get(1);
UnittestHelper.testMemoryPauseEvent(concurrentMarkEvent,
"Concurrent Mark",
AbstractGCEvent.Type.UJL_ZGC_CONCURRENT_MARK,
0.005216,
0, 0, 0,
AbstractGCEvent.Generation.TENURED,
false);
}

@Test
public void testGcAllPauseMarkEnd() {
AbstractGCEvent<?> pauseMarkEndEvent = gcAllModel.get(2);
UnittestHelper.testMemoryPauseEvent(pauseMarkEndEvent,
"Pause Mark End",
AbstractGCEvent.Type.UJL_ZGC_PAUSE_MARK_END,
0.000695,
0, 0, 0,
AbstractGCEvent.Generation.TENURED,
false);
}

AbstractGCEvent<?> concurrentNonrefEvent = model.get(3);
@Test
public void testGcAllConcurrentNonref() {
AbstractGCEvent<?> concurrentNonrefEvent = gcAllModel.get(3);
UnittestHelper.testMemoryPauseEvent(concurrentNonrefEvent,
"Concurrent Process Non-Strong References",
AbstractGCEvent.Type.UJL_ZGC_CONCURRENT_NONREF,
0.000258,
0, 0, 0,
AbstractGCEvent.Generation.TENURED,
false);
}

AbstractGCEvent<?> concurrentResetRelocSetEvent = model.get(4);
@Test
public void testGcAllConcurrentResetRelocSet() {
AbstractGCEvent<?> concurrentResetRelocSetEvent = gcAllModel.get(4);
UnittestHelper.testMemoryPauseEvent(concurrentResetRelocSetEvent,
"Concurrent Reset Relocation Set",
AbstractGCEvent.Type.UJL_ZGC_CONCURRENT_RESET_RELOC_SET,
0.000001,
0, 0, 0,
AbstractGCEvent.Generation.TENURED,
false);
}

AbstractGCEvent<?> concurrentDetachedPagesEvent = model.get(5);
@Test
public void testGcAllConcurrentDetachedPages() {
AbstractGCEvent<?> concurrentDetachedPagesEvent = gcAllModel.get(5);
UnittestHelper.testMemoryPauseEvent(concurrentDetachedPagesEvent,
"Concurrent Destroy Detached Pages",
AbstractGCEvent.Type.UJL_ZGC_CONCURRENT_DETATCHED_PAGES,
0.000001,
0, 0, 0,
AbstractGCEvent.Generation.TENURED,
false);
}

AbstractGCEvent<?> concurrentSelectRelocSetEvent = model.get(6);
@Test
public void testGcAllConcurrentSelectRelocSet() {
AbstractGCEvent<?> concurrentSelectRelocSetEvent = gcAllModel.get(6);
UnittestHelper.testMemoryPauseEvent(concurrentSelectRelocSetEvent,
"Concurrent Select Relocation Set",
AbstractGCEvent.Type.UJL_ZGC_CONCURRENT_SELECT_RELOC_SET,
0.003822,
0, 0, 0,
AbstractGCEvent.Generation.TENURED,
false);
}

AbstractGCEvent<?> concurrentPrepareRelocSetEvent = model.get(7);
@Test
public void testGcAllConcurrentPrepareRelocSet() {
AbstractGCEvent<?> concurrentPrepareRelocSetEvent = gcAllModel.get(7);
UnittestHelper.testMemoryPauseEvent(concurrentPrepareRelocSetEvent,
"Concurrent Prepare Relocation Set",
AbstractGCEvent.Type.UJL_ZGC_CONCURRENT_PREPARE_RELOC_SET,
0.000865,
0, 0, 0,
AbstractGCEvent.Generation.TENURED,
false);
}

@Test
public void testGcAllPauseRelocateStart() {
AbstractGCEvent<?> pauseRelocateStartEvent = gcAllModel.get(8);
UnittestHelper.testMemoryPauseEvent(pauseRelocateStartEvent,
"Pause Relocate Start",
AbstractGCEvent.Type.UJL_ZGC_PAUSE_RELOCATE_START,
0.000679,
0, 0, 0,
AbstractGCEvent.Generation.TENURED,
false);
}

AbstractGCEvent<?> concurrentRelocateEvent = model.get(9);
@Test
public void testGcAllConcurrentRelocate() {
AbstractGCEvent<?> concurrentRelocateEvent = gcAllModel.get(9);
UnittestHelper.testMemoryPauseEvent(concurrentRelocateEvent,
"Concurrent Relocate",
AbstractGCEvent.Type.UJL_ZGC_CONCURRENT_RELOCATE,
Expand All @@ -140,15 +166,32 @@ public void testGcAllConcurrent(GCModel model) {
}

@Test
public void testGcDefault() throws Exception {
GCModel model = getGCModelFromLogFile("sample-ujl-zgc-gc-default.txt");
assertThat("size", model.size(), is(5));
assertThat("amount of STW GC pause types", model.getGcEventPauses().size(), is(0));
assertThat("amount of STW Full GC pause types", model.getFullGcEventPauses().size(), is(0));
assertThat("amount of concurrent pause types", model.getConcurrentEventPauses().size(), is(0));
public void testGcAllGarbageCollection() {
AbstractGCEvent<?> garbageCollectionEvent = gcAllModel.get(10);
UnittestHelper.testMemoryPauseEvent(garbageCollectionEvent,
"Garbage Collection",
AbstractGCEvent.Type.UJL_ZGC_GARBAGE_COLLECTION,
0,
1024 * 10620, 1024 * 8800, 1024 * 194560,
AbstractGCEvent.Generation.TENURED,
false);
assertThat("preused heap percentage", garbageCollectionEvent.getPreUsedPercent(), is(5));
assertThat("postused heap percentage", garbageCollectionEvent.getPostUsedPercent(), is(4));
}


@Test
public void testGcDefault() {
assertThat("size", gcDefaultModel.size(), is(5));
assertThat("amount of STW GC pause types", gcDefaultModel.getGcEventPauses().size(), is(0));
assertThat("amount of STW Full GC pause types", gcDefaultModel.getFullGcEventPauses().size(), is(0));
assertThat("amount of concurrent pause types", gcDefaultModel.getConcurrentEventPauses().size(), is(0));
}

@Test
public void testGcDefaultMetadataGcThreshold() {
// Default gc log gives no pause time or total heap size
AbstractGCEvent<?> metadataGcThresholdEvent = model.get(0);
AbstractGCEvent<?> metadataGcThresholdEvent = gcDefaultModel.get(0);
UnittestHelper.testMemoryPauseEvent(metadataGcThresholdEvent,
"Metadata GC Threshold heap",
AbstractGCEvent.Type.UJL_ZGC_GARBAGE_COLLECTION,
Expand All @@ -158,8 +201,11 @@ public void testGcDefault() throws Exception {
false);
assertThat("Metadata GC preused heap percentage", metadataGcThresholdEvent.getPreUsedPercent(), is(0));
assertThat("Metadata GC postused heap percentage", metadataGcThresholdEvent.getPostUsedPercent(), is(0));
}

AbstractGCEvent<?> warmupEvent = model.get(1);
@Test
public void testGcDefaultWarmup() {
AbstractGCEvent<?> warmupEvent = gcDefaultModel.get(1);
UnittestHelper.testMemoryPauseEvent(warmupEvent,
"Warmup heap",
AbstractGCEvent.Type.UJL_ZGC_GARBAGE_COLLECTION,
Expand All @@ -169,8 +215,11 @@ public void testGcDefault() throws Exception {
false);
assertThat("Warmup preused heap percentage", warmupEvent.getPreUsedPercent(), is(20));
assertThat("Warmup GC postused heap percentage", warmupEvent.getPostUsedPercent(), is(16));
}

AbstractGCEvent<?> proactiveEvent = model.get(2);
@Test
public void testGcDefaultProactive() {
AbstractGCEvent<?> proactiveEvent = gcDefaultModel.get(2);
UnittestHelper.testMemoryPauseEvent(proactiveEvent,
"Proactive heap",
AbstractGCEvent.Type.UJL_ZGC_GARBAGE_COLLECTION,
Expand All @@ -180,8 +229,11 @@ public void testGcDefault() throws Exception {
false);
assertThat("Proactive preused heap percentage", proactiveEvent.getPreUsedPercent(), is(10));
assertThat("Proactive postused heap percentage", proactiveEvent.getPostUsedPercent(), is(10));
}

AbstractGCEvent<?> allocationRateEvent = model.get(3);
@Test
public void testGcDefaultAllocationRate() {
AbstractGCEvent<?> allocationRateEvent = gcDefaultModel.get(3);
UnittestHelper.testMemoryPauseEvent(allocationRateEvent,
"Allocation Rate heap",
AbstractGCEvent.Type.UJL_ZGC_GARBAGE_COLLECTION,
Expand All @@ -191,8 +243,11 @@ public void testGcDefault() throws Exception {
false);
assertThat("Allocation preused heap percentage", allocationRateEvent.getPreUsedPercent(), is(49));
assertThat("Allocation postused heap percentage", allocationRateEvent.getPostUsedPercent(), is(70));
}

AbstractGCEvent<?> systemGcEvent = model.get(4);
@Test
public void testDefaultGcSystemGc() {
AbstractGCEvent<?> systemGcEvent = gcDefaultModel.get(4);
UnittestHelper.testMemoryPauseEvent(systemGcEvent,
"System.gc() heap",
AbstractGCEvent.Type.UJL_ZGC_GARBAGE_COLLECTION,
Expand Down

0 comments on commit 18d4275

Please sign in to comment.