Update initialization of page cursor tracers, reset counters on init

tests for reset and incorrect reported unpin value.

community/io/src/main/java/org/neo4j/io/pagecache/impl/muninn/CursorPool.java

@@ -19,19 +19,23 @@
  */
 package org.neo4j.io.pagecache.impl.muninn;
 
+import org.neo4j.io.pagecache.tracing.PageCacheTracer;
+import org.neo4j.io.pagecache.tracing.cursor.PageCursorTracer;
 import org.neo4j.io.pagecache.tracing.cursor.PageCursorTracerSupplier;
 
 final class CursorPool extends ThreadLocal<CursorPool.CursorSets>
 {
     private final MuninnPagedFile pagedFile;
     private final long victimPage;
     private final PageCursorTracerSupplier cursorTracerSupplier;
+    private PageCacheTracer tracer;
 
-    CursorPool( MuninnPagedFile pagedFile, PageCursorTracerSupplier cursorTracerSupplier )
+    CursorPool( MuninnPagedFile pagedFile, PageCursorTracerSupplier cursorTracerSupplier, PageCacheTracer tracer )
     {
         this.pagedFile = pagedFile;
         this.victimPage = pagedFile.pageCache.victimPage;
         this.cursorTracerSupplier = cursorTracerSupplier;
+        this.tracer = tracer;
     }
 
     @Override
@@ -58,7 +62,7 @@ MuninnReadPageCursor takeReadCursor( long pageId, int pf_flags )
 
     private MuninnReadPageCursor createReadCursor( CursorSets cursorSets )
     {
-        MuninnReadPageCursor cursor = new MuninnReadPageCursor( cursorSets, victimPage, cursorTracerSupplier.get() );
+        MuninnReadPageCursor cursor = new MuninnReadPageCursor( cursorSets, victimPage, getPageCursorTracer() );
         cursor.initialiseFile( pagedFile );
         return cursor;
     }
@@ -81,11 +85,18 @@ MuninnWritePageCursor takeWriteCursor( long pageId, int pf_flags )
 
     private MuninnWritePageCursor createWriteCursor( CursorSets cursorSets )
     {
-        MuninnWritePageCursor cursor = new MuninnWritePageCursor( cursorSets, victimPage, cursorTracerSupplier.get() );
+        MuninnWritePageCursor cursor = new MuninnWritePageCursor( cursorSets, victimPage, getPageCursorTracer() );
         cursor.initialiseFile( pagedFile );
         return cursor;
     }
 
+    private PageCursorTracer getPageCursorTracer()
+    {
+        PageCursorTracer pageCursorTracer = cursorTracerSupplier.get();
+        pageCursorTracer.init( tracer );
+        return pageCursorTracer;
+    }
+
     static class CursorSets
     {
         MuninnReadPageCursor readCursors;

community/io/src/main/java/org/neo4j/io/pagecache/impl/muninn/MuninnPageCursor.java

@@ -83,8 +83,6 @@ abstract class MuninnPageCursor extends PageCursor
     final void initialiseFile( MuninnPagedFile pagedFile )
     {
         this.swapper = pagedFile.swapper;
-        // TODO: can we avoid this binding?
-        this.pageCursorTracer.init( pagedFile.tracer );
     }
 
     final void initialiseFlags( MuninnPagedFile pagedFile, long pageId, int pf_flags )

community/io/src/main/java/org/neo4j/io/pagecache/impl/muninn/MuninnPagedFile.java

@@ -103,7 +103,7 @@ final class MuninnPagedFile implements PagedFile, Flushable
     {
         this.pageCache = pageCache;
         this.filePageSize = filePageSize;
-        this.cursorPool = new CursorPool( this, cursorTracerSupplier );
+        this.cursorPool = new CursorPool( this, cursorTracerSupplier, tracer );
         this.tracer = tracer;
 
         // The translation table is an array of arrays of references to either null, MuninnPage objects, or Latch

community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/DefaultPageCursorTracer.java

@@ -60,23 +60,37 @@ public class DefaultPageCursorTracer implements PageCursorTracer
     public void init( PageCacheTracer pageCacheTracer )
     {
         this.pageCacheTracer = pageCacheTracer;
+        resetCounters();
+    }
+
+    private void resetCounters()
+    {
+        pins = 0L;
+        unpins = 0L;
+        faults = 0L;
+        bytesRead = 0L;
+        bytesWritten = 0L;
+        evictions = 0L;
+        evictionExceptions = 0L;
+        flushes = 0L;
+        rememberCycleStartValues();
     }
 
     public void reportEvents()
     {
         Objects.nonNull( pageCacheTracer );
         pageCacheTracer.pins( Math.abs( pins - cyclePinsStart ) );
-        pageCacheTracer.unpins( Math.abs( pins - cycleUnpinsStart ) );
+        pageCacheTracer.unpins( Math.abs( unpins - cycleUnpinsStart ) );
         pageCacheTracer.faults( Math.abs( faults - cycleFaultsStart ) );
         pageCacheTracer.bytesRead( Math.abs( bytesRead - cycleBytesReadStart ) );
         pageCacheTracer.evictions( Math.abs( evictions - cycleEvictionsStart ) );
         pageCacheTracer.evictionExceptions( Math.abs( evictionExceptions - cycleEvictionExceptionsStart ) );
         pageCacheTracer.bytesWritten( Math.abs( bytesWritten - cycleBytesWrittenStart ) );
         pageCacheTracer.flushes( Math.abs( flushes - cycleFlushesStart ) );
-        rememberReportedValues();
+        rememberCycleStartValues();
     }
 
-    private void rememberReportedValues()
+    private void rememberCycleStartValues()
     {
         this.cyclePinsStart = pins;
         this.cycleUnpinsStart = unpins;

community/io/src/test/java/org/neo4j/io/pagecache/tracing/DefaultPageCursorTracerTest.java

@@ -49,9 +49,57 @@ public void countPinsAndUnpins()
     {
         PinEvent pinEvent = pageCursorTracer.beginPin( true, 0, swapper );
         pinEvent.done();
+        pinEvent = pageCursorTracer.beginPin( true, 0, swapper );
+
+        assertEquals( 2, pageCursorTracer.pins() );
+        assertEquals( 1, pageCursorTracer.unpins() );
+    }
+
+    @Test
+    public void resetCursorTracerOnInit()
+    {
+        pageCursorTracer.init( cacheTracer );
+        generateEventSet();
+        pageCursorTracer.reportEvents();
+
+        assertEquals( 1, cacheTracer.pins() );
+        assertEquals( 1, cacheTracer.unpins() );
+        assertEquals( 1, cacheTracer.faults() );
+        assertEquals( 1, cacheTracer.evictions() );
+        assertEquals( 1, cacheTracer.evictionExceptions() );
+        assertEquals( 1, cacheTracer.flushes() );
+        assertEquals( 10, cacheTracer.bytesWritten() );
+        assertEquals( 150, cacheTracer.bytesRead() );
 
         assertEquals( 1, pageCursorTracer.pins() );
         assertEquals( 1, pageCursorTracer.unpins() );
+        assertEquals( 1, pageCursorTracer.faults() );
+        assertEquals( 1, pageCursorTracer.evictions() );
+        assertEquals( 1, pageCursorTracer.evictionExceptions() );
+        assertEquals( 1, pageCursorTracer.flushes() );
+        assertEquals( 10, pageCursorTracer.bytesWritten() );
+        assertEquals( 150, pageCursorTracer.bytesRead() );
+
+        pageCursorTracer.init( cacheTracer );
+        generateEventSet();
+        pageCursorTracer.reportEvents();
+        assertEquals( 1, pageCursorTracer.pins() );
+        assertEquals( 1, pageCursorTracer.unpins() );
+        assertEquals( 1, pageCursorTracer.faults() );
+        assertEquals( 1, pageCursorTracer.evictions() );
+        assertEquals( 1, pageCursorTracer.evictionExceptions() );
+        assertEquals( 1, pageCursorTracer.flushes() );
+        assertEquals( 10, pageCursorTracer.bytesWritten() );
+        assertEquals( 150, pageCursorTracer.bytesRead() );
+
+        assertEquals( 2, cacheTracer.pins() );
+        assertEquals( 2, cacheTracer.unpins() );
+        assertEquals( 2, cacheTracer.faults() );
+        assertEquals( 2, cacheTracer.evictions() );
+        assertEquals( 2, cacheTracer.evictionExceptions() );
+        assertEquals( 2, cacheTracer.flushes() );
+        assertEquals( 20, cacheTracer.bytesWritten() );
+        assertEquals( 300, cacheTracer.bytesRead() );
     }
 
     @Test