Rename PageCacheMonitor to PageCacheCounters

This change will remove confusions since the "PageCacheMonitor" wasn't
really a monitor in the sense of the Monitors framework.

advanced/management/src/main/java/org/neo4j/management/impl/PageCacheBean.java

@@ -22,7 +22,7 @@
 import javax.management.NotCompliantMBeanException;
 
 import org.neo4j.helpers.Service;
-import org.neo4j.io.pagecache.monitoring.PageCacheMonitor;
+import org.neo4j.io.pagecache.monitoring.PageCacheCounters;
 import org.neo4j.jmx.impl.ManagementBeanProvider;
 import org.neo4j.jmx.impl.ManagementData;
 import org.neo4j.jmx.impl.Neo4jMBean;
@@ -44,72 +44,72 @@ protected Neo4jMBean createMBean( ManagementData management ) throws NotComplian
 
     private static class PageCacheImpl extends Neo4jMBean implements PageCache
     {
-        private final PageCacheMonitor pageCacheMonitor;
+        private final PageCacheCounters pageCacheCounters;
 
         PageCacheImpl( ManagementData management ) throws NotCompliantMBeanException
         {
             super( management );
-            this.pageCacheMonitor = management.resolveDependency( PageCacheMonitor.class );
+            this.pageCacheCounters = management.resolveDependency( PageCacheCounters.class );
         }
 
         @Override
         public long getFaults()
         {
-            return pageCacheMonitor.countFaults();
+            return pageCacheCounters.faults();
         }
 
         @Override
         public long getEvictions()
         {
-            return pageCacheMonitor.countEvictions();
+            return pageCacheCounters.evictions();
         }
 
         @Override
         public long getPins()
         {
-            return pageCacheMonitor.countPins();
+            return pageCacheCounters.pins();
         }
 
         @Override
         public long getUnpins()
         {
-            return pageCacheMonitor.countUnpins();
+            return pageCacheCounters.unpins();
         }
 
         @Override
         public long getFlushes()
         {
-            return pageCacheMonitor.countFlushes();
+            return pageCacheCounters.flushes();
         }
 
         @Override
         public long getBytesRead()
         {
-            return pageCacheMonitor.countBytesRead();
+            return pageCacheCounters.bytesRead();
         }
 
         @Override
         public long getBytesWritten()
         {
-            return pageCacheMonitor.countBytesWritten();
+            return pageCacheCounters.bytesWritten();
         }
 
         @Override
         public long getFileMappings()
         {
-            return pageCacheMonitor.countFilesMapped();
+            return pageCacheCounters.filesMapped();
         }
 
         @Override
         public long getFileUnmappings()
         {
-            return pageCacheMonitor.countFilesUnmapped();
+            return pageCacheCounters.filesUnmapped();
         }
 
         @Override
         public long getEvictionExceptions()
         {
-            return pageCacheMonitor.countEvictionExceptions();
+            return pageCacheCounters.evictionExceptions();
         }
     }
 }

community/io/src/main/java/org/neo4j/io/pagecache/monitoring/PageCacheMonitor.java → community/io/src/main/java/org/neo4j/io/pagecache/monitoring/PageCacheCounters.java

@@ -20,58 +20,58 @@
 package org.neo4j.io.pagecache.monitoring;
 
 /**
- * The PageCacheMonitor exposes internal counters from the page cache.
+ * The PageCacheCounters exposes internal counters from the page cache.
  * The data for these counters is sourced through the PageCacheTracer API.
  */
-public interface PageCacheMonitor
+public interface PageCacheCounters
 {
     /**
      * @return The number of page faults observed thus far.
      */
-    public long countFaults();
+    long faults();
 
     /**
      * @return The number of page evictions observed thus far.
      */
-    public long countEvictions();
+    long evictions();
 
     /**
      * @return The number of page pins observed thus far.
      */
-    public long countPins();
+    long pins();
 
     /**
      * @return The number of page unpins observed thus far.
      */
-    public long countUnpins();
+     long unpins();
 
     /**
      * @return The number of page flushes observed thus far.
      */
-    public long countFlushes();
+    long flushes();
 
     /**
      * @return The sum total of bytes read in through page faults thus far.
      */
-    public long countBytesRead();
+    long bytesRead();
 
     /**
      * @return The sum total of bytes written through flushes thus far.
      */
-    public long countBytesWritten();
+    long bytesWritten();
 
     /**
      * @return The number of file mappings observed thus far.
      */
-    public long countFilesMapped();
+    long filesMapped();
 
     /**
      * @return The number of file unmappings observed thus far.
      */
-    public long countFilesUnmapped();
+    long filesUnmapped();
 
     /**
      * @return The number of page evictions that have thrown exceptions thus far.
      */
-    public long countEvictionExceptions();
+    long evictionExceptions();
 }

community/io/src/main/java/org/neo4j/io/pagecache/tracing/DefaultPageCacheTracer.java

@@ -325,61 +325,61 @@ public MajorFlushEvent beginCacheFlush()
     }
 
     @Override
-    public long countFaults()
+    public long faults()
     {
         return faults.get();
     }
 
     @Override
-    public long countEvictions()
+    public long evictions()
     {
         return evictions.get();
     }
 
     @Override
-    public long countPins()
+    public long pins()
     {
         return pins.get();
     }
 
     @Override
-    public long countUnpins()
+    public long unpins()
     {
         return unpins.get();
     }
 
     @Override
-    public long countFlushes()
+    public long flushes()
     {
         return flushes.get();
     }
 
     @Override
-    public long countBytesRead()
+    public long bytesRead()
     {
         return bytesRead.get();
     }
 
     @Override
-    public long countBytesWritten()
+    public long bytesWritten()
     {
         return bytesWritten.get();
     }
 
     @Override
-    public long countFilesMapped()
+    public long filesMapped()
     {
         return filesMapped.get();
     }
 
     @Override
-    public long countFilesUnmapped()
+    public long filesUnmapped()
     {
         return filesUnmapped.get();
     }
 
     @Override
-    public long countEvictionExceptions()
+    public long evictionExceptions()
     {
         return evictionExceptions.get();
     }

community/io/src/main/java/org/neo4j/io/pagecache/tracing/PageCacheTracer.java

@@ -22,14 +22,14 @@
 import java.io.File;
 
 import org.neo4j.io.pagecache.PageSwapper;
-import org.neo4j.io.pagecache.monitoring.PageCacheMonitor;
+import org.neo4j.io.pagecache.monitoring.PageCacheCounters;
 
 /**
  * A PageCacheTracer receives a steady stream of events and data about what
  * the page cache is doing. Implementations of this interface should be as
  * efficient as possible, lest they severely slow down the page cache.
  */
-public interface PageCacheTracer extends PageCacheMonitor
+public interface PageCacheTracer extends PageCacheCounters
 {
     /**
      * A PageCacheTracer that does nothing other than return the NULL variants of the companion interfaces.
@@ -71,61 +71,61 @@ public MajorFlushEvent beginCacheFlush()
         }
 
         @Override
-        public long countFaults()
+        public long faults()
         {
             return 0;
         }
 
         @Override
-        public long countEvictions()
+        public long evictions()
         {
             return 0;
         }
 
         @Override
-        public long countPins()
+        public long pins()
         {
             return 0;
         }
 
         @Override
-        public long countUnpins()
+        public long unpins()
         {
             return 0;
         }
 
         @Override
-        public long countFlushes()
+        public long flushes()
         {
             return 0;
         }
 
         @Override
-        public long countBytesRead()
+        public long bytesRead()
         {
             return 0;
         }
 
         @Override
-        public long countBytesWritten()
+        public long bytesWritten()
         {
             return 0;
         }
 
         @Override
-        public long countFilesMapped()
+        public long filesMapped()
         {
             return 0;
         }
 
         @Override
-        public long countFilesUnmapped()
+        public long filesUnmapped()
         {
             return 0;
         }
 
         @Override
-        public long countEvictionExceptions()
+        public long evictionExceptions()
         {
             return 0;
         }
@@ -149,7 +149,7 @@ public String toString()
 
     /**
      * A background eviction has begun. Called from the background eviction thread.
-     * 
+     *
      * This call will be paired with a following PageCacheTracer#endPageEviction call.
      *
      * The method returns an EvictionRunEvent to represent the event of this eviction run.

community/io/src/test/java/org/neo4j/io/pagecache/PageCacheTest.java

@@ -1929,14 +1929,14 @@ public void tracerMustBeNotifiedAboutPinUnpinFaultAndEvictEventsWhenReading() th
             }
         }
 
-        assertThat( "wrong count of pins", tracer.countPins(), is( countedPages * 2 ) );
-        assertThat( "wrong count of unpins", tracer.countUnpins(), is( countedPages * 2 ) );
+        assertThat( "wrong count of pins", tracer.pins(), is( countedPages * 2 ) );
+        assertThat( "wrong count of unpins", tracer.unpins(), is( countedPages * 2 ) );
 
         // We might be unlucky and fault in the second next call, on the page
         // we brought up in the first next call. That's why we assert that we
         // have observed *at least* the countedPages number of faults.
-        long faults = tracer.countFaults();
-        long bytesRead = tracer.countBytesRead();
+        long faults = tracer.faults();
+        long bytesRead = tracer.bytesRead();
         assertThat( "wrong count of faults", faults, greaterThanOrEqualTo( countedPages ) );
         assertThat( "wrong number of bytes read",
                 bytesRead, greaterThanOrEqualTo( countedPages * filePageSize ) );
@@ -1945,7 +1945,7 @@ public void tracerMustBeNotifiedAboutPinUnpinFaultAndEvictEventsWhenReading() th
         // block and get a page directly transferred to it, and these kinds of
         // evictions can count in addition to the evictions we do when the
         // cache is behind on keeping the freelist full.
-        assertThat( "wrong count of evictions", tracer.countEvictions(),
+        assertThat( "wrong count of evictions", tracer.evictions(),
                 both( greaterThanOrEqualTo( countedPages - maxPages ) )
                         .and( lessThanOrEqualTo( countedPages + faults ) ) );
     }
@@ -1972,20 +1972,20 @@ public void tracerMustBeNotifiedAboutPinUnpinFaultFlushAndEvictionEventsWhenWrit
             }
         }
 
-        assertThat( "wrong count of pins", tracer.countPins(), is( pagesToGenerate * 2 ) );
-        assertThat( "wrong count of unpins", tracer.countUnpins(), is( pagesToGenerate * 2 ) );
+        assertThat( "wrong count of pins", tracer.pins(), is( pagesToGenerate * 2 ) );
+        assertThat( "wrong count of unpins", tracer.unpins(), is( pagesToGenerate * 2 ) );
 
         // We might be unlucky and fault in the second next call, on the page
         // we brought up in the first next call. That's why we assert that we
         // have observed *at least* the countedPages number of faults.
-        long faults = tracer.countFaults();
+        long faults = tracer.faults();
         assertThat( "wrong count of faults", faults, greaterThanOrEqualTo( pagesToGenerate ) );
         // Every page we move forward can put the freelist behind so the cache
         // wants to evict more pages. Plus, every page fault we do could also
         // block and get a page directly transferred to it, and these kinds of
         // evictions can count in addition to the evictions we do when the
         // cache is behind on keeping the freelist full.
-        assertThat( "wrong count of evictions", tracer.countEvictions(),
+        assertThat( "wrong count of evictions", tracer.evictions(),
                 both( greaterThanOrEqualTo( pagesToGenerate - maxPages ) )
                         .and( lessThanOrEqualTo( pagesToGenerate + faults ) ) );
 
@@ -1996,8 +1996,8 @@ public void tracerMustBeNotifiedAboutPinUnpinFaultFlushAndEvictionEventsWhenWrit
         // We also subtract 'maxPages' from the expected flush count, because
         // vectored IO may coalesce all the flushes we do as part of unmapping
         // the file, into a single flush.
-        long flushes = tracer.countFlushes();
-        long bytesWritten = tracer.countBytesWritten();
+        long flushes = tracer.flushes();
+        long bytesWritten = tracer.bytesWritten();
         assertThat( "wrong count of flushes",
                 flushes, greaterThanOrEqualTo( pagesToGenerate - maxPages ) );
         assertThat( "wrong count of bytes written",