Merge pull request #8918 from MishaDemianenko/3.2-hit-metric-page-cache

Introduce page cache hit metric
neo4j · Mar 2, 2017 · 937d653 · 937d653
2 parents 0e8ac21 + 94470a9
commit 937d653
Show file tree

Hide file tree

Showing 17 changed files with 263 additions and 44 deletions.
diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/impl/muninn/MuninnPageCursor.java b/community/io/src/main/java/org/neo4j/io/pagecache/impl/muninn/MuninnPageCursor.java
@@ -242,6 +242,7 @@ protected void pin( long filePageId, boolean writeLock ) throws IOException
                 if ( locked & page.isBoundTo( swapper, filePageId ) )
                 {
                     pinCursorToPage( page, filePageId, swapper );
+                    pinEvent.hit();
                     return;
                 }
                 if ( locked )

diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/monitoring/PageCacheCounters.java b/community/io/src/main/java/org/neo4j/io/pagecache/monitoring/PageCacheCounters.java
@@ -45,6 +45,11 @@ public interface PageCacheCounters
      */
      long unpins();
 
+    /**
+     * @return The number of page cache hits so far.
+     */
+    long hits();
+
     /**
      * @return The number of page flushes observed thus far.
      */

diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/DefaultPageCacheTracer.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/DefaultPageCacheTracer.java
@@ -34,6 +34,7 @@ public class DefaultPageCacheTracer implements PageCacheTracer
     protected final LongAdder evictions = new LongAdder();
     protected final LongAdder pins = new LongAdder();
     protected final LongAdder unpins = new LongAdder();
+    protected final LongAdder hits = new LongAdder();
     protected final LongAdder flushes = new LongAdder();
     protected final LongAdder bytesRead = new LongAdder();
     protected final LongAdder bytesWritten = new LongAdder();
@@ -187,6 +188,12 @@ public long unpins()
         return unpins.sum();
     }
 
+    @Override
+    public long hits()
+    {
+        return hits.sum();
+    }
+
     @Override
     public long flushes()
     {
@@ -235,6 +242,12 @@ public void unpins( long unpins )
         this.unpins.add( unpins );
     }
 
+    @Override
+    public void hits( long hits )
+    {
+        this.hits.add( hits );
+    }
+
     @Override
     public void faults( long faults )
     {

diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/PageCacheTracer.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/PageCacheTracer.java
@@ -88,6 +88,12 @@ public long unpins()
             return 0;
         }
 
+        @Override
+        public long hits()
+        {
+            return 0;
+        }
+
         @Override
         public long flushes()
         {
@@ -134,6 +140,11 @@ public void unpins( long unpins )
         {
         }
 
+        @Override
+        public void hits( long hits )
+        {
+        }
+
         @Override
         public void faults( long faults )
         {
@@ -212,6 +223,12 @@ public String toString()
      */
     void unpins( long unpins );
 
+    /**
+     * Report number of observer hits
+     * @param hits number of hits
+     */
+    void hits( long hits );
+
     /**
      * Report number of observed faults
      * @param faults number of faults

diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/PinEvent.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/PinEvent.java
@@ -40,6 +40,11 @@ public PageFaultEvent beginPageFault()
             return PageFaultEvent.NULL;
         }
 
+        @Override
+        public void hit()
+        {
+        }
+
         @Override
         public void done()
         {
@@ -56,6 +61,11 @@ public void done()
      */
     PageFaultEvent beginPageFault();
 
+    /**
+     * Page found and bounded.
+     */
+    void hit();
+
     /**
      * The pinning has completed and the page is now unpinned.
      */

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
@@ -33,6 +33,7 @@ public class DefaultPageCursorTracer implements PageCursorTracer
 {
     private long pins;
     private long unpins;
+    private long hits;
     private long faults;
     private long bytesRead;
     private long bytesWritten;
@@ -41,6 +42,7 @@ public class DefaultPageCursorTracer implements PageCursorTracer
     private long flushes;
 
     private PageCacheTracer pageCacheTracer = PageCacheTracer.NULL;
+    private DefaultPinEvent pinTracingEvent = new DefaultPinEvent();
 
     @Override
     public void init( PageCacheTracer pageCacheTracer )
@@ -58,6 +60,10 @@ public void reportEvents()
         {
             pageCacheTracer.unpins( unpins );
         }
+        if (hits > 0)
+        {
+            pageCacheTracer.hits( hits );
+        }
         if ( faults > 0 )
         {
             pageCacheTracer.faults( faults );
@@ -89,6 +95,7 @@ private void reset()
     {
         pins = 0;
         unpins = 0;
+        hits = 0;
         faults = 0;
         bytesRead = 0;
         bytesWritten = 0;
@@ -115,6 +122,12 @@ public long unpins()
         return unpins;
     }
 
+    @Override
+    public long hits()
+    {
+        return hits;
+    }
+
     @Override
     public long bytesRead()
     {
@@ -149,29 +162,10 @@ public long flushes()
     public PinEvent beginPin( boolean writeLock, long filePageId, PageSwapper swapper )
     {
         pins++;
+        pinTracingEvent.eventHits = 1;
         return pinTracingEvent;
     }
 
-    private final PinEvent pinTracingEvent = new PinEvent()
-    {
-        @Override
-        public void setCachePageId( int cachePageId )
-        {
-        }
-
-        @Override
-        public PageFaultEvent beginPageFault()
-        {
-            return pageFaultEvent;
-        }
-
-        @Override
-        public void done()
-        {
-            unpins++;
-        }
-    };
-
     private final EvictionEvent evictionEvent = new EvictionEvent()
     {
         @Override
@@ -274,4 +268,33 @@ public void addPagesFlushed( int pageCount )
         {
         }
     };
+
+    private class DefaultPinEvent implements PinEvent
+    {
+        int eventHits = 1;
+
+        @Override
+        public void setCachePageId( int cachePageId )
+        {
+        }
+
+        @Override
+        public PageFaultEvent beginPageFault()
+        {
+            eventHits = 0;
+            return pageFaultEvent;
+        }
+
+        @Override
+        public void hit()
+        {
+            hits += eventHits;
+        }
+
+        @Override
+        public void done()
+        {
+            unpins++;
+        }
+    }
 }
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
@@ -44,6 +44,11 @@ public interface PageCursorCounters
      */
     long unpins();
 
+    /**
+     * @return The number of page hits observed so far.
+     */
+    long hits();
+
     /**
      * @return The sum total of bytes read in through page faults thus far.
      */

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
@@ -55,6 +55,12 @@ public long unpins()
             return 0;
         }
 
+        @Override
+        public long hits()
+        {
+            return 0;
+        }
+
         @Override
         public long bytesRead()
         {

diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DefaultPageCacheTracerTest.java b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DefaultPageCacheTracerTest.java
@@ -42,21 +42,6 @@ public void setUp()
         swapper = new DummyPageSwapper( "filename" );
     }
 
-    private void assertCounts( long pins, long unpins, long faults, long evictions, long evictionExceptions,
-                               long flushes, long bytesRead, long bytesWritten, long filesMapped, long filesUnmapped )
-    {
-        assertThat( "pins", tracer.pins(), is( pins ) );
-        assertThat( "unpins", tracer.unpins(), is( unpins ) );
-        assertThat( "faults", tracer.faults(), is( faults ) );
-        assertThat( "evictions", tracer.evictions(), is( evictions ) );
-        assertThat( "evictionExceptions", tracer.evictionExceptions(), is( evictionExceptions ) );
-        assertThat( "flushes", tracer.flushes(), is( flushes ) );
-        assertThat( "bytesRead", tracer.bytesRead(), is( bytesRead ) );
-        assertThat( "bytesWritten", tracer.bytesWritten(), is( bytesWritten ) );
-        assertThat( "filesMapped", tracer.filesMapped(), is( filesMapped ) );
-        assertThat( "filesUnmapped", tracer.filesUnmapped(), is( filesUnmapped ) );
-    }
-
     @Test
     public void mustCountEvictions()
     {
@@ -88,19 +73,19 @@ public void mustCountEvictions()
             evictionRunEvent.beginEviction().close();
         }
 
-        assertCounts( 0, 0, 0, 4, 2, 3, 0, 36, 0, 0 );
+        assertCounts( 0, 0, 0, 0, 4, 2, 3, 0, 36, 0, 0 );
     }
 
     @Test
     public void mustCountFileMappingAndUnmapping()
     {
         tracer.mappedFile( new File( "a" ) );
 
-        assertCounts( 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 );
+        assertCounts( 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 );
 
         tracer.unmappedFile( new File( "a" ) );
 
-        assertCounts( 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 );
+        assertCounts( 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 );
     }
 
     @Test
@@ -113,7 +98,7 @@ public void mustCountFlushes()
             cacheFlush.flushEventOpportunity().beginFlush( 0, 0, swapper ).done();
         }
 
-        assertCounts( 0, 0, 0, 0, 0, 3, 0, 0, 0, 0 );
+        assertCounts( 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0 );
 
         try ( MajorFlushEvent fileFlush = tracer.beginFileFlush( swapper ) )
         {
@@ -122,6 +107,22 @@ public void mustCountFlushes()
             fileFlush.flushEventOpportunity().beginFlush( 0, 0, swapper ).done();
         }
 
-        assertCounts( 0, 0, 0, 0, 0, 6, 0, 0, 0, 0 );
+        assertCounts( 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0 );
+    }
+
+    private void assertCounts( long pins, long unpins, long hits, long faults, long evictions, long evictionExceptions,
+            long flushes, long bytesRead, long bytesWritten, long filesMapped, long filesUnmapped )
+    {
+        assertThat( "pins", tracer.pins(), is( pins ) );
+        assertThat( "unpins", tracer.unpins(), is( unpins ) );
+        assertThat( "hits", tracer.hits(), is( hits ) );
+        assertThat( "faults", tracer.faults(), is( faults ) );
+        assertThat( "evictions", tracer.evictions(), is( evictions ) );
+        assertThat( "evictionExceptions", tracer.evictionExceptions(), is( evictionExceptions ) );
+        assertThat( "flushes", tracer.flushes(), is( flushes ) );
+        assertThat( "bytesRead", tracer.bytesRead(), is( bytesRead ) );
+        assertThat( "bytesWritten", tracer.bytesWritten(), is( bytesWritten ) );
+        assertThat( "filesMapped", tracer.filesMapped(), is( filesMapped ) );
+        assertThat( "filesUnmapped", tracer.filesUnmapped(), is( filesUnmapped ) );
     }
 }
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
@@ -55,6 +55,40 @@ public void countPinsAndUnpins()
         assertEquals( 1, pageCursorTracer.unpins() );
     }
 
+    @Test
+    public void noHitForPinEventWithPageFault()
+    {
+        pinFaultAndHit();
+
+        assertEquals( 1, pageCursorTracer.pins() );
+        assertEquals( 1, pageCursorTracer.faults() );
+        assertEquals( 0, pageCursorTracer.hits() );
+    }
+
+    @Test
+    public void hitForPinEventWithoutPageFault()
+    {
+        pinAndHit();
+
+        assertEquals( 1, pageCursorTracer.pins() );
+        assertEquals( 1, pageCursorTracer.hits() );
+    }
+
+    @Test
+    public void countHitsOnlyForPinEventsWithoutPageFaults()
+    {
+        pinAndHit();
+        pinAndHit();
+        pinAndHit();
+        pinFaultAndHit();
+        pinFaultAndHit();
+        pinAndHit();
+        pinAndHit();
+
+        assertEquals( 7, pageCursorTracer.pins() );
+        assertEquals( 5, pageCursorTracer.hits() );
+    }
+
     @Test
     public void countPageFaultsAndBytesRead()
     {
@@ -193,4 +227,20 @@ private PageCursorTracer createTracer()
         pageCursorTracer.init( cacheTracer );
         return pageCursorTracer;
     }
+
+    private void pinAndHit()
+    {
+        PinEvent pinEvent = pageCursorTracer.beginPin( true, 0, swapper );
+        pinEvent.hit();
+        pinEvent.done();
+    }
+
+    private void pinFaultAndHit()
+    {
+        PinEvent pinEvent = pageCursorTracer.beginPin( true, 0, swapper );
+        PageFaultEvent pageFaultEvent = pinEvent.beginPageFault();
+        pinEvent.hit();
+        pageFaultEvent.done();
+        pinEvent.done();
+    }
 }