From 6a5ec0f6071d8a7133c2e007a03d0cc09bc75f6b Mon Sep 17 00:00:00 2001 From: MishaDemianenko Date: Thu, 19 Jan 2017 18:24:34 +0100 Subject: [PATCH] Expand number of exposed counters in page cursor counters. Tests for page cursor reported counters --- .../cursor/DefaultPageCursorTracer.java | 39 ++++-- .../tracing/cursor/PageCursorCounters.java | 15 ++ .../tracing/cursor/PageCursorTracer.java | 18 +++ .../tracing/DefaultPageCursorTracerTest.java | 128 ++++++++++++++++-- .../linear/LinearHistoryPageCursorTracer.java | 18 +++ .../recording/RecordingPageCursorTracer.java | 18 +++ 6 files changed, 218 insertions(+), 18 deletions(-) diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/DefaultPageCursorTracer.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/DefaultPageCursorTracer.java index 575fde47841f7..6aed8f7322f3a 100644 --- a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/DefaultPageCursorTracer.java +++ b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/DefaultPageCursorTracer.java @@ -44,7 +44,7 @@ public class DefaultPageCursorTracer implements PageCursorTracer private long bytesRead = 0L; private long bytesWritten = 0L; private long evictions = 0L; - private long flushes; + private long flushes = 0L; private long cyclePinsStart; private long cycleUnpinsStart; @@ -105,13 +105,6 @@ public static void enablePinUnpinTracing() public void init( PageCacheTracer pageCacheTracer ) { this.pageCacheTracer = pageCacheTracer; - this.cyclePinsStart = pins; - this.cycleUnpinsStart = unpins; - this.cycleFaultsStart = faults; - this.cycleBytesReadStart = bytesRead; - this.cycleBytesWrittenStart = bytesWritten; - this.cycleEvictionsStart = evictions; - this.cycleFlushesStart = flushes; } public void reportEvents() @@ -124,6 +117,18 @@ public void reportEvents() pageCacheTracer.evictions( Math.abs( evictions - cycleEvictionsStart ) ); pageCacheTracer.bytesWritten( Math.abs( bytesWritten - cycleBytesWrittenStart ) ); pageCacheTracer.flushes( Math.abs( flushes - cycleFlushesStart ) ); + rememberReportedValues(); + } + + private void rememberReportedValues() + { + this.cyclePinsStart = pins; + this.cycleUnpinsStart = unpins; + this.cycleFaultsStart = faults; + this.cycleBytesReadStart = bytesRead; + this.cycleBytesWrittenStart = bytesWritten; + this.cycleEvictionsStart = evictions; + this.cycleFlushesStart = flushes; } @Override @@ -150,6 +155,24 @@ public long bytesRead() return bytesRead; } + @Override + public long evictions() + { + return evictions; + } + + @Override + public long bytesWritten() + { + return bytesWritten; + } + + @Override + public long flushes() + { + return flushes; + } + @Override public PinEvent beginPin( boolean writeLock, long filePageId, PageSwapper swapper ) { diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/PageCursorCounters.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/PageCursorCounters.java index a1828bdb72f9f..22e0676a024ed 100644 --- a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/PageCursorCounters.java +++ b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/PageCursorCounters.java @@ -49,4 +49,19 @@ public interface PageCursorCounters */ long bytesRead(); + /** + * @return The number of page evictions observed thus far. + */ + long evictions(); + + /** + * @return The sum total of bytes written through flushes thus far. + */ + long bytesWritten(); + + /** + * @return The number of page flushes observed thus far. + */ + long flushes(); + } diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/PageCursorTracer.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/PageCursorTracer.java index caf17a7a4aedd..351b60e85325e 100644 --- a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/PageCursorTracer.java +++ b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/PageCursorTracer.java @@ -61,6 +61,24 @@ public long bytesRead() return 0; } + @Override + public long evictions() + { + return 0; + } + + @Override + public long bytesWritten() + { + return 0; + } + + @Override + public long flushes() + { + return 0; + } + @Override public PinEvent beginPin( boolean writeLock, long filePageId, PageSwapper swapper ) { diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DefaultPageCursorTracerTest.java b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DefaultPageCursorTracerTest.java index 8905a3ac76e56..131543da76dae 100644 --- a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DefaultPageCursorTracerTest.java +++ b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DefaultPageCursorTracerTest.java @@ -26,32 +26,36 @@ import org.neo4j.io.pagecache.tracing.cursor.DefaultPageCursorTracer; import org.neo4j.io.pagecache.tracing.cursor.PageCursorTracer; +import static org.junit.Assert.assertEquals; + public class DefaultPageCursorTracerTest { -//TODO: private PageSwapper swapper; - private PageCursorTracer tracer; + private PageCursorTracer pageCursorTracer; + private DefaultPageCacheTracer cacheTracer; @Before public void setUp() { - tracer = createTracer(); + cacheTracer = new DefaultPageCacheTracer(); + pageCursorTracer = createTracer(); swapper = new DummyPageSwapper( "filename" ); } @Test - public void mustCountPinsAndUnpins() + public void countPinsAndUnpins() { - PinEvent pinEvent = tracer.beginPin( true, 0, swapper ); + PinEvent pinEvent = pageCursorTracer.beginPin( true, 0, swapper ); pinEvent.done(); - // We don't particularly care whether the counts are incremented on begin or close + assertEquals( 1, pageCursorTracer.pins() ); + assertEquals( 1, pageCursorTracer.unpins() ); } @Test - public void mustCountPageFaults() + public void countPageFaultsAndBytesRead() { - PinEvent pinEvent = tracer.beginPin( true, 0, swapper ); + PinEvent pinEvent = pageCursorTracer.beginPin( true, 0, swapper ); PageFaultEvent pageFaultEvent = pinEvent.beginPageFault(); pageFaultEvent.addBytesRead( 42 ); pageFaultEvent.done(); @@ -60,12 +64,116 @@ public void mustCountPageFaults() pageFaultEvent.done(); pinEvent.done(); + assertEquals( 1, pageCursorTracer.pins() ); + assertEquals( 1, pageCursorTracer.unpins() ); + assertEquals( 2, pageCursorTracer.faults() ); + assertEquals( 84, pageCursorTracer.bytesRead() ); + } + + @Test + public void countPageEvictions() throws Exception + { + PinEvent pinEvent = pageCursorTracer.beginPin( true, 0, swapper ); + PageFaultEvent faultEvent = pinEvent.beginPageFault(); + EvictionEvent evictionEvent = faultEvent.beginEviction(); + evictionEvent.setFilePageId( 0 ); + evictionEvent.setCachePageId( 0 ); + evictionEvent.close(); + faultEvent.done(); + pinEvent.done(); + + assertEquals( 1, pageCursorTracer.pins() ); + assertEquals( 1, pageCursorTracer.unpins() ); + assertEquals( 1, pageCursorTracer.faults() ); + assertEquals( 1, pageCursorTracer.evictions() ); + } + + @Test + public void countFlushesAndBytesWritten() throws Exception + { + PinEvent pinEvent = pageCursorTracer.beginPin( true, 0, swapper ); + { + PageFaultEvent faultEvent = pinEvent.beginPageFault(); + { + EvictionEvent evictionEvent = faultEvent.beginEviction(); + { + FlushEventOpportunity flushEventOpportunity = evictionEvent.flushEventOpportunity(); + { + FlushEvent flushEvent = flushEventOpportunity.beginFlush( 0, 0, swapper ); + flushEvent.addBytesWritten( 27 ); + flushEvent.done(); + FlushEvent flushEvent1 = flushEventOpportunity.beginFlush( 0, 1, swapper ); + flushEvent1.addBytesWritten( 13 ); + flushEvent1.done(); + } + } + evictionEvent.close(); + } + faultEvent.done(); + } + pinEvent.done(); + + assertEquals( 1, pageCursorTracer.pins() ); + assertEquals( 1, pageCursorTracer.unpins() ); + assertEquals( 1, pageCursorTracer.faults() ); + assertEquals( 1, pageCursorTracer.evictions() ); + assertEquals( 2, pageCursorTracer.flushes() ); + assertEquals( 40, pageCursorTracer.bytesWritten() ); + } + + @Test + public void reportCountersToPageCursorTracer() + { + generateEvents(); + pageCursorTracer.reportEvents(); + + assertEquals( 1, cacheTracer.pins() ); + assertEquals( 1, cacheTracer.unpins() ); + assertEquals( 1, cacheTracer.faults() ); + assertEquals( 1, cacheTracer.evictions() ); + assertEquals( 1, cacheTracer.flushes() ); + assertEquals( 10, cacheTracer.bytesWritten() ); + assertEquals( 150, cacheTracer.bytesRead() ); + + generateEvents(); + generateEvents(); + pageCursorTracer.reportEvents(); + + assertEquals( 3, cacheTracer.pins() ); + assertEquals( 3, cacheTracer.unpins() ); + assertEquals( 3, cacheTracer.faults() ); + assertEquals( 3, cacheTracer.evictions() ); + assertEquals( 3, cacheTracer.flushes() ); + assertEquals( 30, cacheTracer.bytesWritten() ); + assertEquals( 450, cacheTracer.bytesRead() ); + } + + private void generateEvents() + { + PinEvent pinEvent = pageCursorTracer.beginPin( false, 0, swapper ); + { + PageFaultEvent pageFaultEvent = pinEvent.beginPageFault(); + pageFaultEvent.addBytesRead( 150 ); + { + EvictionEvent evictionEvent = pageFaultEvent.beginEviction(); + { + FlushEventOpportunity flushEventOpportunity = evictionEvent.flushEventOpportunity(); + FlushEvent flushEvent = flushEventOpportunity.beginFlush( 0, 0, swapper ); + flushEvent.addBytesWritten( 10 ); + flushEvent.done(); + } + evictionEvent.close(); + } + pageFaultEvent.done(); + } + pinEvent.done(); } private PageCursorTracer createTracer() { DefaultPageCursorTracer.enablePinUnpinTracing(); - return new DefaultPageCursorTracer(); + DefaultPageCursorTracer pageCursorTracer = new DefaultPageCursorTracer(); + pageCursorTracer.init( cacheTracer ); + return pageCursorTracer; } - } diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/linear/LinearHistoryPageCursorTracer.java b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/linear/LinearHistoryPageCursorTracer.java index 82c154176d071..3e6ad2303fb78 100644 --- a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/linear/LinearHistoryPageCursorTracer.java +++ b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/linear/LinearHistoryPageCursorTracer.java @@ -65,6 +65,24 @@ public long bytesRead() return 0; } + @Override + public long evictions() + { + return 0; + } + + @Override + public long bytesWritten() + { + return 0; + } + + @Override + public long flushes() + { + return 0; + } + @Override public PinEvent beginPin( boolean writeLock, long filePageId, PageSwapper swapper ) { diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/recording/RecordingPageCursorTracer.java b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/recording/RecordingPageCursorTracer.java index 946eaba5b2287..a3ea2fa856817 100644 --- a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/recording/RecordingPageCursorTracer.java +++ b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/recording/RecordingPageCursorTracer.java @@ -75,6 +75,24 @@ public long bytesRead() return 0; } + @Override + public long evictions() + { + return 0; + } + + @Override + public long bytesWritten() + { + return 0; + } + + @Override + public long flushes() + { + return 0; + } + @Override public PinEvent beginPin( boolean writeLock, final long filePageId, final PageSwapper swapper ) {