Expand number of exposed counters in page cursor counters.

Tests for page cursor reported counters
neo4j · Feb 27, 2017 · 6a5ec0f · 6a5ec0f
1 parent d4b0cbf
commit 6a5ec0f
Show file tree

Hide file tree

Showing 6 changed files with 218 additions and 18 deletions.
diff --git a/...unity/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/DefaultPageCursorTracer.java b/...unity/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
@@ -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
@@ -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
@@ -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/...io/src/test/java/org/neo4j/io/pagecache/tracing/linear/LinearHistoryPageCursorTracer.java b/...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/.../io/src/test/java/org/neo4j/io/pagecache/tracing/recording/RecordingPageCursorTracer.java b/.../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 )
     {