Use LongAdders in DefaultPageCacheTracer to accumulate total counter …

…value,

update way of evaluation current cycle and total counter in page cursor tracer.

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

@@ -21,7 +21,7 @@
 
 import java.io.File;
 import java.io.IOException;
-import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.LongAdder;
 
 import org.neo4j.io.pagecache.PageSwapper;
 
@@ -30,29 +30,29 @@
  */
 public class DefaultPageCacheTracer implements PageCacheTracer
 {
-    protected final AtomicLong faults = new AtomicLong();
-    protected final AtomicLong evictions = new AtomicLong();
-    protected final AtomicLong pins = new AtomicLong();
-    protected final AtomicLong unpins = new AtomicLong();
-    protected final AtomicLong flushes = new AtomicLong();
-    protected final AtomicLong bytesRead = new AtomicLong();
-    protected final AtomicLong bytesWritten = new AtomicLong();
-    protected final AtomicLong filesMapped = new AtomicLong();
-    protected final AtomicLong filesUnmapped = new AtomicLong();
-    protected final AtomicLong evictionExceptions = new AtomicLong();
+    protected final LongAdder faults = new LongAdder();
+    protected final LongAdder evictions = new LongAdder();
+    protected final LongAdder pins = new LongAdder();
+    protected final LongAdder unpins = new LongAdder();
+    protected final LongAdder flushes = new LongAdder();
+    protected final LongAdder bytesRead = new LongAdder();
+    protected final LongAdder bytesWritten = new LongAdder();
+    protected final LongAdder filesMapped = new LongAdder();
+    protected final LongAdder filesUnmapped = new LongAdder();
+    protected final LongAdder evictionExceptions = new LongAdder();
 
     private final FlushEvent flushEvent = new FlushEvent()
     {
         @Override
         public void addBytesWritten( long bytes )
         {
-            bytesWritten.getAndAdd( bytes );
+            bytesWritten.add( bytes );
         }
 
         @Override
         public void done()
         {
-            flushes.getAndIncrement();
+            flushes.increment();
         }
 
         @Override
@@ -90,7 +90,7 @@ public FlushEventOpportunity flushEventOpportunity()
         @Override
         public void threwException( IOException exception )
         {
-            evictionExceptions.getAndIncrement();
+            evictionExceptions.increment();
         }
 
         @Override
@@ -101,7 +101,7 @@ public void setCachePageId( int cachePageId )
         @Override
         public void close()
         {
-            evictions.getAndIncrement();
+            evictions.increment();
         }
     };
 
@@ -136,13 +136,13 @@ public void close()
     @Override
     public void mappedFile( File file )
     {
-        filesMapped.getAndIncrement();
+        filesMapped.increment();
     }
 
     @Override
     public void unmappedFile( File file )
     {
-        filesUnmapped.getAndIncrement();
+        filesUnmapped.increment();
     }
 
     @Override
@@ -166,108 +166,108 @@ public MajorFlushEvent beginCacheFlush()
     @Override
     public long faults()
     {
-        return faults.get();
+        return faults.sum();
     }
 
     @Override
     public long evictions()
     {
-        return evictions.get();
+        return evictions.sum();
     }
 
     @Override
     public long pins()
     {
-        return pins.get();
+        return pins.sum();
     }
 
     @Override
     public long unpins()
     {
-        return unpins.get();
+        return unpins.sum();
     }
 
     @Override
     public long flushes()
     {
-        return flushes.get();
+        return flushes.sum();
     }
 
     @Override
     public long bytesRead()
     {
-        return bytesRead.get();
+        return bytesRead.sum();
     }
 
     @Override
     public long bytesWritten()
     {
-        return bytesWritten.get();
+        return bytesWritten.sum();
     }
 
     @Override
     public long filesMapped()
     {
-        return filesMapped.get();
+        return filesMapped.sum();
     }
 
     @Override
     public long filesUnmapped()
     {
-        return filesUnmapped.get();
+        return filesUnmapped.sum();
     }
 
     @Override
     public long evictionExceptions()
     {
-        return evictionExceptions.get();
+        return evictionExceptions.sum();
     }
 
     @Override
     public void pins( long pins )
     {
-        this.pins.getAndAdd( pins );
+        this.pins.add( pins );
     }
 
     @Override
     public void unpins( long unpins )
     {
-        this.unpins.getAndAdd( unpins );
+        this.unpins.add( unpins );
     }
 
     @Override
     public void faults( long faults )
     {
-        this.faults.getAndAdd( faults );
+        this.faults.add( faults );
     }
 
     @Override
     public void bytesRead( long bytesRead )
     {
-        this.bytesRead.getAndAdd( bytesRead );
+        this.bytesRead.add( bytesRead );
     }
 
     @Override
     public void evictions( long evictions )
     {
-        this.evictions.getAndAdd( evictions );
+        this.evictions.add( evictions );
     }
 
     @Override
     public void evictionExceptions( long evictionExceptions )
     {
-        this.evictionExceptions.getAndAdd( evictionExceptions );
+        this.evictionExceptions.add( evictionExceptions );
     }
 
     @Override
     public void bytesWritten( long bytesWritten )
     {
-        this.bytesWritten.getAndAdd( bytesWritten );
+        this.bytesWritten.add( bytesWritten );
     }
 
     @Override
     public void flushes( long flushes )
     {
-        this.flushes.getAndAdd( flushes );
+        this.flushes.add( flushes );
     }
 }

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

@@ -32,23 +32,23 @@
 
 public class DefaultPageCursorTracer implements PageCursorTracer
 {
-    private long pins = 0L;
-    private long unpins = 0L;
-    private long faults = 0L;
-    private long bytesRead = 0L;
-    private long bytesWritten = 0L;
-    private long evictions = 0L;
-    private long evictionExceptions = 0L;
-    private long flushes = 0L;
-
-    private long cyclePinsStart;
-    private long cycleUnpinsStart;
-    private long cycleFaultsStart;
-    private long cycleBytesReadStart;
-    private long cycleBytesWrittenStart;
-    private long cycleEvictionsStart;
-    private long cycleEvictionExceptionsStart;
-    private long cycleFlushesStart;
+    private long totalPins = 0L;
+    private long totalUnpins = 0L;
+    private long totalFaults = 0L;
+    private long totalBytesRead = 0L;
+    private long totalBytesWritten = 0L;
+    private long totalEvictions = 0L;
+    private long totalEvictionExceptions = 0L;
+    private long totalFlushes = 0L;
+
+    private long pins;
+    private long unpins;
+    private long faults;
+    private long bytesRead;
+    private long bytesWritten;
+    private long evictions;
+    private long evictionExceptions;
+    private long flushes;
 
     private PageCacheTracer pageCacheTracer;
 
@@ -60,75 +60,107 @@ public void init( PageCacheTracer pageCacheTracer )
     public void reportEvents()
     {
         Objects.nonNull( pageCacheTracer );
-        pageCacheTracer.pins( Math.abs( pins - cyclePinsStart ) );
-        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 ) );
-        rememberCycleStartValues();
+        if (pins > 0)
+        {
+            pageCacheTracer.pins( pins );
+        }
+        if (unpins > 0)
+        {
+            pageCacheTracer.unpins( unpins );
+        }
+        if ( faults > 0 )
+        {
+            pageCacheTracer.faults( faults );
+        }
+        if ( bytesRead > 0 )
+        {
+            pageCacheTracer.bytesRead( bytesRead );
+        }
+        if ( evictions > 0 )
+        {
+            pageCacheTracer.evictions( evictions );
+        }
+        if ( evictionExceptions > 0 )
+        {
+            pageCacheTracer.evictionExceptions( evictionExceptions );
+        }
+        if ( bytesWritten > 0 )
+        {
+            pageCacheTracer.bytesWritten( bytesWritten );
+        }
+        if ( flushes > 0 )
+        {
+            pageCacheTracer.flushes( flushes );
+        }
+        updateTotals();
     }
 
-    private void rememberCycleStartValues()
+    private void updateTotals()
     {
-        this.cyclePinsStart = pins;
-        this.cycleUnpinsStart = unpins;
-        this.cycleFaultsStart = faults;
-        this.cycleBytesReadStart = bytesRead;
-        this.cycleBytesWrittenStart = bytesWritten;
-        this.cycleEvictionsStart = evictions;
-        this.cycleEvictionExceptionsStart = evictionExceptions;
-        this.cycleFlushesStart = flushes;
+        this.totalPins += pins;
+        this.totalUnpins += unpins;
+        this.totalFaults += faults;
+        this.totalBytesRead += bytesRead;
+        this.totalBytesWritten += bytesWritten;
+        this.totalEvictions += evictions;
+        this.totalEvictionExceptions += evictionExceptions;
+        this.totalFlushes += flushes;
+        pins = 0;
+        unpins = 0;
+        faults = 0;
+        bytesRead = 0;
+        bytesWritten = 0;
+        evictions = 0;
+        evictionExceptions = 0;
+        flushes = 0;
     }
 
     @Override
     public long faults()
     {
-        return faults;
+        return totalFaults + faults;
     }
 
     @Override
     public long pins()
     {
-        return pins;
+        return totalPins + pins;
     }
 
     @Override
     public long unpins()
     {
-        return unpins;
+        return totalUnpins + unpins;
     }
 
     @Override
     public long bytesRead()
     {
-        return bytesRead;
+        return totalBytesRead + bytesRead;
     }
 
     @Override
     public long evictions()
     {
-        return evictions;
+        return totalEvictions + evictions;
     }
 
     @Override
     public long evictionExceptions()
     {
-        return evictionExceptions;
+        return totalEvictionExceptions + evictionExceptions;
     }
 
     @Override
     public long bytesWritten()
     {
-        return bytesWritten;
+        return totalBytesWritten + bytesWritten;
     }
 
     @Override
     public long flushes()
     {
-        return flushes;
+        return totalFlushes + flushes;
     }
 
     @Override
@@ -260,5 +292,4 @@ public void addPagesFlushed( int pageCount )
         {
         }
     };
-
 }