diff --git a/advanced/management/src/main/java/org/neo4j/management/impl/PageCacheBean.java b/advanced/management/src/main/java/org/neo4j/management/impl/PageCacheBean.java index c82f72d5c5488..16eaa513fa375 100644 --- a/advanced/management/src/main/java/org/neo4j/management/impl/PageCacheBean.java +++ b/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(); } } } diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/monitoring/PageCacheMonitor.java b/community/io/src/main/java/org/neo4j/io/pagecache/monitoring/PageCacheCounters.java similarity index 79% rename from community/io/src/main/java/org/neo4j/io/pagecache/monitoring/PageCacheMonitor.java rename to community/io/src/main/java/org/neo4j/io/pagecache/monitoring/PageCacheCounters.java index dd720ea72f955..d845231f5c554 100644 --- a/community/io/src/main/java/org/neo4j/io/pagecache/monitoring/PageCacheMonitor.java +++ b/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(); } 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 index febff3fa66064..9fc70c511d407 100644 --- 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 @@ -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(); } 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 index ee30c45cfb746..a33c99fa3f068 100644 --- 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 @@ -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. diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/PageCacheTest.java b/community/io/src/test/java/org/neo4j/io/pagecache/PageCacheTest.java index 842e820489474..e7f215106163c 100644 --- a/community/io/src/test/java/org/neo4j/io/pagecache/PageCacheTest.java +++ b/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", diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/RecordingPageCacheTracer.java b/community/io/src/test/java/org/neo4j/io/pagecache/RecordingPageCacheTracer.java index 4e79a36e76d46..5d058da12c1e9 100644 --- a/community/io/src/test/java/org/neo4j/io/pagecache/RecordingPageCacheTracer.java +++ b/community/io/src/test/java/org/neo4j/io/pagecache/RecordingPageCacheTracer.java @@ -149,61 +149,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; } diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/stress/Conditions.java b/community/io/src/test/java/org/neo4j/io/pagecache/stress/Conditions.java index 7f74d731a8d44..69befab6a3413 100644 --- a/community/io/src/test/java/org/neo4j/io/pagecache/stress/Conditions.java +++ b/community/io/src/test/java/org/neo4j/io/pagecache/stress/Conditions.java @@ -21,13 +21,13 @@ import java.util.concurrent.TimeUnit; -import org.neo4j.io.pagecache.monitoring.PageCacheMonitor; +import org.neo4j.io.pagecache.monitoring.PageCacheCounters; import static java.lang.System.currentTimeMillis; public class Conditions { - public static Condition numberOfEvictions( final PageCacheMonitor monitor, + public static Condition numberOfEvictions( final PageCacheCounters monitor, final long desiredNumberOfEvictions ) { return new Condition() @@ -35,7 +35,7 @@ public static Condition numberOfEvictions( final PageCacheMonitor monitor, @Override public boolean fulfilled() { - return monitor.countEvictions() > desiredNumberOfEvictions; + return monitor.evictions() > desiredNumberOfEvictions; } }; } diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DelegatingPageCacheTracer.java b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DelegatingPageCacheTracer.java index c8ae64b2b8afe..e5648c089f9cf 100644 --- a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DelegatingPageCacheTracer.java +++ b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DelegatingPageCacheTracer.java @@ -42,9 +42,9 @@ public void mappedFile( File file ) delegate.mappedFile( file ); } - public long countBytesRead() + public long bytesRead() { - return delegate.countBytesRead(); + return delegate.bytesRead(); } public MajorFlushEvent beginFileFlush( PageSwapper swapper ) @@ -57,9 +57,9 @@ public EvictionRunEvent beginPageEvictions( int pageCountToEvict ) return delegate.beginPageEvictions( pageCountToEvict ); } - public long countUnpins() + public long unpins() { - return delegate.countUnpins(); + return delegate.unpins(); } public MajorFlushEvent beginCacheFlush() @@ -67,19 +67,19 @@ public MajorFlushEvent beginCacheFlush() return delegate.beginCacheFlush(); } - public long countBytesWritten() + public long bytesWritten() { - return delegate.countBytesWritten(); + return delegate.bytesWritten(); } - public long countPins() + public long pins() { - return delegate.countPins(); + return delegate.pins(); } - public long countFilesUnmapped() + public long filesUnmapped() { - return delegate.countFilesUnmapped(); + return delegate.filesUnmapped(); } public PinEvent beginPin( boolean exclusiveLock, long filePageId, PageSwapper swapper ) @@ -92,28 +92,28 @@ public void unmappedFile( File file ) delegate.unmappedFile( file ); } - public long countEvictionExceptions() + public long evictionExceptions() { - return delegate.countEvictionExceptions(); + return delegate.evictionExceptions(); } - public long countFilesMapped() + public long filesMapped() { - return delegate.countFilesMapped(); + return delegate.filesMapped(); } - public long countFlushes() + public long flushes() { - return delegate.countFlushes(); + return delegate.flushes(); } - public long countFaults() + public long faults() { - return delegate.countFaults(); + return delegate.faults(); } - public long countEvictions() + public long evictions() { - return delegate.countEvictions(); + return delegate.evictions(); } } diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/PageCacheTracerTest.java b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/PageCacheTracerTest.java index 45703c5520128..42770591d1af8 100644 --- a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/PageCacheTracerTest.java +++ b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/PageCacheTracerTest.java @@ -58,16 +58,16 @@ public void mustCountPinsAndUnpins() private void assertCounts( long pins, long unpins, long faults, long evictions, long evictionExceptions, long flushes, long bytesRead, long bytesWritten, long filesMapped, long filesUnmapped ) { - assertThat( "countPins", tracer.countPins(), is( pins ) ); - assertThat( "countUnpins", tracer.countUnpins(), is( unpins ) ); - assertThat( "countFaults", tracer.countFaults(), is( faults ) ); - assertThat( "countEvictions", tracer.countEvictions(), is( evictions ) ); - assertThat( "countEvictionExceptions", tracer.countEvictionExceptions(), is( evictionExceptions ) ); - assertThat( "countFlushes", tracer.countFlushes(), is( flushes ) ); - assertThat( "countBytesRead", tracer.countBytesRead(), is( bytesRead ) ); - assertThat( "countBytesWritten", tracer.countBytesWritten(), is( bytesWritten ) ); - assertThat( "countFilesMapped", tracer.countFilesMapped(), is( filesMapped ) ); - assertThat( "countFilesUnmapped", tracer.countFilesUnmapped(), is( 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 diff --git a/community/io/src/test/java/org/neo4j/test/LinearHistoryPageCacheTracer.java b/community/io/src/test/java/org/neo4j/test/LinearHistoryPageCacheTracer.java index 8984870f2fe2e..8601fa2d7a324 100644 --- a/community/io/src/test/java/org/neo4j/test/LinearHistoryPageCacheTracer.java +++ b/community/io/src/test/java/org/neo4j/test/LinearHistoryPageCacheTracer.java @@ -565,61 +565,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; } diff --git a/community/kernel/src/main/java/org/neo4j/unsafe/impl/batchimport/store/BatchingNeoStores.java b/community/kernel/src/main/java/org/neo4j/unsafe/impl/batchimport/store/BatchingNeoStores.java index 12cc8ace20985..2d6516f983a73 100644 --- a/community/kernel/src/main/java/org/neo4j/unsafe/impl/batchimport/store/BatchingNeoStores.java +++ b/community/kernel/src/main/java/org/neo4j/unsafe/impl/batchimport/store/BatchingNeoStores.java @@ -101,7 +101,7 @@ public BatchingNeoStores( FileSystemAbstraction fileSystem, File storeDir, Confi @Override public long countBytesWritten() { - return tracer.countBytesWritten(); + return tracer.bytesWritten(); } }; this.neoStores = newNeoStores( pageCache ); diff --git a/enterprise/metrics/src/main/java/org/neo4j/metrics/source/Neo4jMetricsBuilder.java b/enterprise/metrics/src/main/java/org/neo4j/metrics/source/Neo4jMetricsBuilder.java index ceecc83b43ab3..51a91fb864780 100644 --- a/enterprise/metrics/src/main/java/org/neo4j/metrics/source/Neo4jMetricsBuilder.java +++ b/enterprise/metrics/src/main/java/org/neo4j/metrics/source/Neo4jMetricsBuilder.java @@ -22,7 +22,7 @@ import com.codahale.metrics.MetricRegistry; import org.neo4j.graphdb.DependencyResolver; -import org.neo4j.io.pagecache.monitoring.PageCacheMonitor; +import org.neo4j.io.pagecache.monitoring.PageCacheCounters; import org.neo4j.kernel.configuration.Config; import org.neo4j.kernel.ha.cluster.member.ClusterMembers; import org.neo4j.kernel.impl.api.LogRotationMonitor; @@ -65,7 +65,7 @@ public interface Dependencies TransactionCounters transactionCounters(); - PageCacheMonitor pageCacheCounters(); + PageCacheCounters pageCacheCounters(); CheckPointerMonitor checkPointerMonitor(); diff --git a/enterprise/metrics/src/main/java/org/neo4j/metrics/source/db/PageCacheMetrics.java b/enterprise/metrics/src/main/java/org/neo4j/metrics/source/db/PageCacheMetrics.java index a6ac5843541ee..fd2f2b5c9ff6c 100644 --- a/enterprise/metrics/src/main/java/org/neo4j/metrics/source/db/PageCacheMetrics.java +++ b/enterprise/metrics/src/main/java/org/neo4j/metrics/source/db/PageCacheMetrics.java @@ -22,7 +22,7 @@ import com.codahale.metrics.Gauge; import com.codahale.metrics.MetricRegistry; -import org.neo4j.io.pagecache.monitoring.PageCacheMonitor; +import org.neo4j.io.pagecache.monitoring.PageCacheCounters; import org.neo4j.kernel.impl.annotations.Documented; import org.neo4j.kernel.lifecycle.LifecycleAdapter; @@ -47,9 +47,9 @@ public class PageCacheMetrics extends LifecycleAdapter public static final String PC_PAGE_FAULTS = name( PAGE_CACHE_PREFIX, "page_faults" ); private final MetricRegistry registry; - private final PageCacheMonitor pageCacheCounters; + private final PageCacheCounters pageCacheCounters; - public PageCacheMetrics( MetricRegistry registry, PageCacheMonitor pageCacheCounters ) + public PageCacheMetrics( MetricRegistry registry, PageCacheCounters pageCacheCounters ) { this.registry = registry; this.pageCacheCounters = pageCacheCounters; @@ -58,12 +58,12 @@ public PageCacheMetrics( MetricRegistry registry, PageCacheMonitor pageCacheCoun @Override public void start() { - registry.register( PC_PAGE_FAULTS, (Gauge) pageCacheCounters::countFaults ); - registry.register( PC_EVICTIONS, (Gauge) pageCacheCounters::countEvictions ); - registry.register( PC_PINS, (Gauge) pageCacheCounters::countPins ); - registry.register( PC_UNPINS, (Gauge) pageCacheCounters::countUnpins ); - registry.register( PC_FLUSHES, (Gauge) pageCacheCounters::countFlushes ); - registry.register( PC_EVICTION_EXCEPTIONS, (Gauge) pageCacheCounters::countEvictionExceptions ); + registry.register( PC_PAGE_FAULTS, (Gauge) pageCacheCounters::faults ); + registry.register( PC_EVICTIONS, (Gauge) pageCacheCounters::evictions ); + registry.register( PC_PINS, (Gauge) pageCacheCounters::pins ); + registry.register( PC_UNPINS, (Gauge) pageCacheCounters::unpins ); + registry.register( PC_FLUSHES, (Gauge) pageCacheCounters::flushes ); + registry.register( PC_EVICTION_EXCEPTIONS, (Gauge) pageCacheCounters::evictionExceptions ); } @Override diff --git a/stresstests/src/test/java/org/neo4j/io/pagecache/stresstests/PageCacheStressTesting.java b/stresstests/src/test/java/org/neo4j/io/pagecache/stresstests/PageCacheStressTesting.java index 5214840b77326..baf89fd0995f7 100644 --- a/stresstests/src/test/java/org/neo4j/io/pagecache/stresstests/PageCacheStressTesting.java +++ b/stresstests/src/test/java/org/neo4j/io/pagecache/stresstests/PageCacheStressTesting.java @@ -69,11 +69,11 @@ public void shouldBehaveCorrectlyUnderStress() throws Exception runner.run(); - long faults = monitor.countFaults(); - long evictions = monitor.countEvictions(); - long pins = monitor.countPins(); - long unpins = monitor.countUnpins(); - long flushes = monitor.countFlushes(); + long faults = monitor.faults(); + long evictions = monitor.evictions(); + long pins = monitor.pins(); + long unpins = monitor.unpins(); + long flushes = monitor.flushes(); System.out.printf( " - page faults: %d%n - evictions: %d%n - pins: %d%n - unpins: %d%n - flushes: %d%n", faults, evictions, pins, unpins, flushes ); }