IGNITE-49 Implemented avg statistics
Project: http://git-wip-us.apache.org/repos/asf/incubator-ignite/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-ignite/commit/d8ecf41a Tree: http://git-wip-us.apache.org/repos/asf/incubator-ignite/tree/d8ecf41a Diff: http://git-wip-us.apache.org/repos/asf/incubator-ignite/diff/d8ecf41a Branch: refs/heads/ignite-49 Commit: d8ecf41a7f4ae42fb3becad1a9de61a62b1d26d5 Parents: c04013d Author: nikolay_tikhonov <ntikho...@gridgain.com> Authored: Mon Dec 29 19:07:24 2014 +0300 Committer: nikolay_tikhonov <ntikho...@gridgain.com> Committed: Fri Jan 16 14:13:34 2015 +0300 ---------------------------------------------------------------------- .../processors/cache/IgniteCacheProxy.java | 104 +++++++++- .../cache/GridCacheMetricsAdapter.java | 110 +++++++++-- .../cache/GridCacheAbstractMetricsSelfTest.java | 190 +++++++++++++++++++ .../GridCachePartitionedMetricsSelfTest.java | 10 + 4 files changed, 396 insertions(+), 18 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d8ecf41a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java index f95cd2a..10ff00b 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java @@ -387,14 +387,24 @@ public class IgniteCacheProxy<K, V> extends IgniteAsyncSupportAdapter implements /** {@inheritDoc} */ @Override public V get(K key) { try { + boolean statisticsEnabled = ctx.config().isStatisticsEnabled(); + long start = statisticsEnabled ? System.nanoTime() : 0L; + GridCacheProjectionImpl<K, V> prev = gate.enter(prj); + V res; + try { - return delegate.get(key); + res = delegate.get(key); } finally { gate.leave(prev); } + + if (statisticsEnabled) + ctx.cache().metrics0().addGetTimeNanos(System.nanoTime() - start); + + return res; } catch (IgniteCheckedException e) { throw cacheException(e); @@ -404,14 +414,24 @@ public class IgniteCacheProxy<K, V> extends IgniteAsyncSupportAdapter implements /** {@inheritDoc} */ @Override public Map<K, V> getAll(Set<? extends K> keys) { try { + boolean statisticsEnabled = ctx.config().isStatisticsEnabled(); + long start = statisticsEnabled ? System.nanoTime() : 0L; + GridCacheProjectionImpl<K, V> prev = gate.enter(prj); + Map<K, V> res; + try { - return delegate.getAll(keys); + res = delegate.getAll(keys); } finally { gate.leave(prev); } + + if (statisticsEnabled) + ctx.cache().metrics0().addGetTimeNanos(System.nanoTime() - start); + + return res; } catch (IgniteCheckedException e) { throw cacheException(e); @@ -432,6 +452,9 @@ public class IgniteCacheProxy<K, V> extends IgniteAsyncSupportAdapter implements finally { gate.leave(prev); } + + if (statisticsEnabled) + ctx.cache().metrics0().addPutTimeNanos(System.nanoTime() - start); } catch (IgniteCheckedException e) { throw cacheException(e); @@ -495,6 +518,9 @@ public class IgniteCacheProxy<K, V> extends IgniteAsyncSupportAdapter implements /** {@inheritDoc} */ @Override public void put(K key, V val) { try { + boolean statisticsEnabled = ctx.config().isStatisticsEnabled(); + long start = statisticsEnabled ? System.nanoTime() : 0L; + GridCacheProjectionImpl<K, V> prev = gate.enter(prj); try { @@ -503,6 +529,9 @@ public class IgniteCacheProxy<K, V> extends IgniteAsyncSupportAdapter implements finally { gate.leave(prev); } + + if (statisticsEnabled) + ctx.cache().metrics0().addPutTimeNanos(System.nanoTime() - start); } catch (IgniteCheckedException e) { throw cacheException(e); @@ -512,14 +541,26 @@ public class IgniteCacheProxy<K, V> extends IgniteAsyncSupportAdapter implements /** {@inheritDoc} */ @Override public V getAndPut(K key, V val) { try { + boolean statisticsEnabled = ctx.config().isStatisticsEnabled(); + long start = statisticsEnabled ? System.nanoTime() : 0L; + GridCacheProjectionImpl<K, V> prev = gate.enter(prj); + V ret; + try { - return delegate.put(key, val); + ret = delegate.put(key, val); } finally { gate.leave(prev); } + + if (statisticsEnabled) { + ctx.cache().metrics0().addPutTimeNanos(System.nanoTime() - start); + ctx.cache().metrics0().addGetTimeNanos(System.nanoTime() - start); + } + + return ret; } catch (IgniteCheckedException e) { throw cacheException(e); @@ -529,6 +570,9 @@ public class IgniteCacheProxy<K, V> extends IgniteAsyncSupportAdapter implements /** {@inheritDoc} */ @Override public void putAll(Map<? extends K, ? extends V> map) { try { + boolean statisticsEnabled = ctx.config().isStatisticsEnabled(); + long start = statisticsEnabled ? System.nanoTime() : 0L; + GridCacheProjectionImpl<K, V> prev = gate.enter(prj); try { @@ -546,14 +590,24 @@ public class IgniteCacheProxy<K, V> extends IgniteAsyncSupportAdapter implements /** {@inheritDoc} */ @Override public boolean putIfAbsent(K key, V val) { try { + boolean statisticsEnabled = ctx.config().isStatisticsEnabled(); + long start = statisticsEnabled ? System.nanoTime() : 0L; + GridCacheProjectionImpl<K, V> prev = gate.enter(prj); + boolean stored; + try { - return delegate.putxIfAbsent(key, val); + stored = delegate.putxIfAbsent(key, val); } finally { gate.leave(prev); } + + if (statisticsEnabled && stored) + ctx.cache().metrics0().addPutTimeNanos(System.nanoTime() - start); + + return stored; } catch (IgniteCheckedException e) { throw cacheException(e); @@ -563,14 +617,24 @@ public class IgniteCacheProxy<K, V> extends IgniteAsyncSupportAdapter implements /** {@inheritDoc} */ @Override public boolean remove(K key) { try { + boolean statisticsEnabled = ctx.config().isStatisticsEnabled(); + long start = statisticsEnabled ? System.nanoTime() : 0L; + GridCacheProjectionImpl<K, V> prev = gate.enter(prj); + boolean removed; + try { - return delegate.removex(key); + removed = delegate.removex(key); } finally { gate.leave(prev); } + + if (statisticsEnabled) + ctx.cache().metrics0().addRemoveTimeNanos(System.nanoTime() - start); + + return removed; } catch (IgniteCheckedException e) { throw cacheException(e); @@ -580,14 +644,24 @@ public class IgniteCacheProxy<K, V> extends IgniteAsyncSupportAdapter implements /** {@inheritDoc} */ @Override public boolean remove(K key, V oldVal) { try { + boolean statisticsEnabled = ctx.config().isStatisticsEnabled(); + long start = statisticsEnabled ? System.nanoTime() : 0L; + GridCacheProjectionImpl<K, V> prev = gate.enter(prj); + boolean removed; + try { - return delegate.remove(key, oldVal); + removed = delegate.remove(key, oldVal); } finally { gate.leave(prev); } + + if (statisticsEnabled && removed) + ctx.cache().metrics0().addRemoveTimeNanos(System.nanoTime() - start); + + return removed; } catch (IgniteCheckedException e) { throw cacheException(e); @@ -597,14 +671,24 @@ public class IgniteCacheProxy<K, V> extends IgniteAsyncSupportAdapter implements /** {@inheritDoc} */ @Override public V getAndRemove(K key) { try { + boolean statisticsEnabled = ctx.config().isStatisticsEnabled(); + long start = statisticsEnabled ? System.nanoTime() : 0L; + GridCacheProjectionImpl<K, V> prev = gate.enter(prj); + V removed; + try { - return delegate.remove(key); + removed = delegate.remove(key); } finally { gate.leave(prev); } + + if (statisticsEnabled) + ctx.cache().metrics0().addRemoveTimeNanos(System.nanoTime() - start); + + return removed; } catch (IgniteCheckedException e) { throw cacheException(e); @@ -622,6 +706,9 @@ public class IgniteCacheProxy<K, V> extends IgniteAsyncSupportAdapter implements finally { gate.leave(prev); } + + if (statisticsEnabled) + ctx.cache().metrics0().addRemoveTimeNanos(System.nanoTime() - start); } catch (IgniteCheckedException e) { throw cacheException(e); @@ -665,6 +752,9 @@ public class IgniteCacheProxy<K, V> extends IgniteAsyncSupportAdapter implements /** {@inheritDoc} */ @Override public void removeAll(Set<? extends K> keys) { try { + boolean statisticsEnabled = ctx.config().isStatisticsEnabled(); + long start = statisticsEnabled ? System.nanoTime() : 0L; + GridCacheProjectionImpl<K, V> prev = gate.enter(prj); try { http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d8ecf41a/modules/core/src/main/java/org/gridgain/grid/kernal/processors/cache/GridCacheMetricsAdapter.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/gridgain/grid/kernal/processors/cache/GridCacheMetricsAdapter.java b/modules/core/src/main/java/org/gridgain/grid/kernal/processors/cache/GridCacheMetricsAdapter.java index 4849fa5..a878972 100644 --- a/modules/core/src/main/java/org/gridgain/grid/kernal/processors/cache/GridCacheMetricsAdapter.java +++ b/modules/core/src/main/java/org/gridgain/grid/kernal/processors/cache/GridCacheMetricsAdapter.java @@ -20,6 +20,7 @@ package org.gridgain.grid.kernal.processors.cache; import org.gridgain.grid.cache.*; import org.gridgain.grid.util.tostring.*; import org.gridgain.grid.util.typedef.internal.*; +import org.jdk8.backport.*; import org.jetbrains.annotations.*; import java.io.*; @@ -29,6 +30,9 @@ import java.io.*; */ public class GridCacheMetricsAdapter implements GridCacheMetrics, Externalizable { /** */ + private static final long NANOS_IN_MICROSECOND = 1000L; + + /** */ private static final long serialVersionUID = 0L; /** Create time. */ @@ -70,6 +74,15 @@ public class GridCacheMetricsAdapter implements GridCacheMetrics, Externalizable /** Number of removed entries. */ private volatile long rmCnt; + /** Put time taken nanos. */ + private volatile long putTimeNanos; + + /** Get time taken nanos. */ + private volatile long getTimeNanos; + + /** Remove time taken nanos. */ + private volatile long removeTimeNanos; + /** Cache metrics. */ @GridToStringExclude private transient GridCacheMetricsAdapter delegate; @@ -84,7 +97,7 @@ public class GridCacheMetricsAdapter implements GridCacheMetrics, Externalizable /** * @param m Metrics to copy from. */ - public GridCacheMetricsAdapter(GridCacheMetrics m) { + public GridCacheMetricsAdapter(GridCacheMetricsAdapter m) { createTime = m.createTime(); readTime = m.readTime(); writeTime = m.writeTime(); @@ -98,6 +111,9 @@ public class GridCacheMetricsAdapter implements GridCacheMetrics, Externalizable txRollbacks = m.txRollbacks(); rmCnt = m.getCacheRemovals(); evictCnt = m.getCacheEvictions(); + getTimeNanos = m.getTimeNanos(); + putTimeNanos = m.putTimeNanos(); + removeTimeNanos = m.removeTimeNanos(); } /** @@ -227,19 +243,64 @@ public class GridCacheMetricsAdapter implements GridCacheMetrics, Externalizable return evictCnt; } - /** {@inheritDoc} */ - @Override public float getAverageGetTime() { - return 0; + /** + * Increments the get time accumulator. + * + * @param duration the time taken in nanoseconds. + */ + public void addGetTimeNanos(long duration) { + getTimeNanos += duration; } - /** {@inheritDoc} */ - @Override public float getAveragePutTime() { - return 0; + /** + * Increments the put time accumulator. + * + * @param duration the time taken in nanoseconds. + */ + public void addPutTimeNanos(long duration) { + putTimeNanos += duration; } - /** {@inheritDoc} */ - @Override public float getAverageRemoveTime() { - return 0; + /** + * Increments the remove time accumulator. + * + * @param duration the time taken in nanoseconds. + */ + public void addRemoveTimeNanos(long duration) { + removeTimeNanos += duration; + } + + @Override + public float getAverageGetTime() { + long timeNanos = getTimeNanos; + long readsCnt = reads; + + if (timeNanos == 0 || readsCnt == 0) + return 0; + + return ((1f * timeNanos) / readsCnt) / NANOS_IN_MICROSECOND; + } + + @Override + public float getAveragePutTime() { + long timeNanos = putTimeNanos; + long putsCnt = writes; + + if (timeNanos == 0 || putsCnt == 0) + return 0; + + return ((1f * timeNanos) / putsCnt) / NANOS_IN_MICROSECOND; + } + + @Override + public float getAverageRemoveTime() { + long timeNanos = removeTimeNanos; + long removesCnt = rmCnt; + + if (timeNanos == 0 || removesCnt == 0) + return 0; + + return ((1f * timeNanos) / removesCnt) / NANOS_IN_MICROSECOND; } /** @@ -319,12 +380,39 @@ public class GridCacheMetricsAdapter implements GridCacheMetrics, Externalizable } /** + * Gets remove time. + * + * @return Remove time taken nanos. + */ + public long removeTimeNanos() { + return removeTimeNanos; + } + + /** + * Gets get time. + * + * @return Get time taken nanos. + */ + public long getTimeNanos() { + return getTimeNanos; + } + + /** + * Gets put time. + * + * @return Get time taken nanos. + */ + public long putTimeNanos() { + return putTimeNanos; + } + + /** * Create a copy of given metrics object. * * @param m Metrics to copy from. * @return Copy of given metrics. */ - @Nullable public static GridCacheMetricsAdapter copyOf(@Nullable GridCacheMetrics m) { + @Nullable public static GridCacheMetricsAdapter copyOf(@Nullable GridCacheMetricsAdapter m) { if (m == null) return null; http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d8ecf41a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheAbstractMetricsSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheAbstractMetricsSelfTest.java b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheAbstractMetricsSelfTest.java index 5173837..82aa122 100644 --- a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheAbstractMetricsSelfTest.java +++ b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheAbstractMetricsSelfTest.java @@ -85,6 +85,196 @@ public abstract class GridCacheAbstractMetricsSelfTest extends GridCacheAbstract } } + /** {@inheritDoc} */ + @Override protected void beforeTest() throws Exception { + super.beforeTest(); + + for (int i = 0; i < gridCount(); i++) { + Ignite g = grid(i); + + g.cache(null).configuration().setStatisticsEnabled(true); + } + } + + /** + * @throws Exception If failed. + */ + public void testRemoveAvgTime() throws Exception { + IgniteCache<Integer, Integer> jcache = grid(0).jcache(null); + GridCache<Object, Object> cache = grid(0).cache(null); + + jcache.put(1, 1); + jcache.put(2, 2); + + assertEquals(cache.metrics().getAverageRemoveTime(), 0.0, 0.0); + + long start = System.nanoTime(); + + jcache.remove(1); + + float times = (System.nanoTime() - start) * 1.f / 1000; + + float averageRemoveTime = cache.metrics().getAverageRemoveTime(); + + assert averageRemoveTime > 0; + + assertEquals(times, averageRemoveTime, times / 10); + + jcache.remove(2); + + assert cache.metrics().getAverageRemoveTime() > 0; + } + + /** + * @throws Exception If failed. + */ + public void testRemoveAllAvgTime() throws Exception { + IgniteCache<Integer, Integer> jcache = grid(0).jcache(null); + GridCache<Object, Object> cache = grid(0).cache(null); + + jcache.put(1, 1); + jcache.put(2, 2); + jcache.put(3, 3); + + assertEquals(cache.metrics().getAverageRemoveTime(), 0.0, 0.0); + + long start = System.nanoTime(); + + Set<Integer> keys = new HashSet<>(4, 1); + keys.add(1); + keys.add(2); + keys.add(3); + + jcache.removeAll(keys); + + float times = (System.nanoTime() - start) * 1.f / 3 / 1000; + + float averageRemoveTime = cache.metrics().getAverageRemoveTime(); + + assert averageRemoveTime > 0; + assertEquals(times, averageRemoveTime, times / 10); + } + + /** + * @throws Exception If failed. + */ + public void testGetAvgTime() throws Exception { + IgniteCache<Integer, Integer> jcache = grid(0).jcache(null); + GridCache<Object, Object> cache = grid(0).cache(null); + + jcache.put(1, 1); + + assertEquals(0.0, cache.metrics().getAverageGetTime(), 0.0); + assertEquals(0, cache.metrics().reads()); + + long start = System.nanoTime(); + + jcache.get(1); + + float times = (System.nanoTime() - start) * 1.f / 1000; + + float averageGetTime = cache.metrics().getAverageGetTime(); + + assert averageGetTime > 0; + + assertEquals(1, cache.metrics().reads()); + assertEquals(times, averageGetTime, times / 3); + + jcache.get(2); + + assert cache.metrics().getAverageGetTime() > 0; + } + + /** + * @throws Exception If failed. + */ + public void testGetAllAvgTime() throws Exception { + IgniteCache<Integer, Integer> jcache = grid(0).jcache(null); + GridCache<Object, Object> cache = grid(0).cache(null); + + jcache.put(1, 1); + jcache.put(2, 2); + jcache.put(3, 3); + + assertEquals(0.0, cache.metrics().getAverageGetTime(), 0.0); + assertEquals(0, cache.metrics().reads()); + + long start = System.nanoTime(); + + Set<Integer> keys = new HashSet<>(); + keys.add(1); + keys.add(2); + keys.add(3); + + jcache.getAll(keys); + + float times = (System.nanoTime() - start) * 1.f / 3 / 1000; + + float averageGetTime = cache.metrics().getAverageGetTime(); + + assert averageGetTime > 0; + assertEquals(3, cache.metrics().reads()); + assertEquals(times, averageGetTime, times / 3); + } + + /** + * @throws Exception If failed. + */ + public void testPutAvgTime() throws Exception { + IgniteCache<Integer, Integer> jcache = grid(0).jcache(null); + GridCache<Object, Object> cache = grid(0).cache(null); + + assertEquals(0.0, cache.metrics().getAveragePutTime(), 0.0); + assertEquals(0, cache.metrics().writes()); + + long start = System.nanoTime(); + + jcache.put(1, 1); + + float times = (System.nanoTime() - start) * 1.f / 1000; + + float averagePutTime = cache.metrics().getAveragePutTime(); + + assert averagePutTime > 0; + + assertEquals(1, cache.metrics().writes()); + assertEquals(times, averagePutTime, times / 3); + + jcache.put(2, 2); + + assert cache.metrics().getAveragePutTime() > 0; + } + + /** + * @throws Exception If failed. + */ + public void testPutAllAvgTime() throws Exception { + IgniteCache<Integer, Integer> jcache = grid(0).jcache(null); + GridCache<Object, Object> cache = grid(0).cache(null); + + assertEquals(0.0, cache.metrics().getAveragePutTime(), 0.0); + assertEquals(0, cache.metrics().writes()); + + Map<Integer, Integer> values = new HashMap<>(); + + values.put(1, 1); + values.put(2, 2); + values.put(3, 3); + + long start = System.nanoTime(); + + jcache.putAll(values); + + float times = (System.nanoTime() - start) * 1.f / 1000 / values.size(); + + float averagePutTime = cache.metrics().getAveragePutTime(); + + assert averagePutTime > 0; + + assertEquals(values.size(), cache.metrics().writes()); + assertEquals(times, averagePutTime, times / 3); + } + /** * @throws Exception If failed. */ http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/d8ecf41a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedMetricsSelfTest.java ---------------------------------------------------------------------- diff --git a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedMetricsSelfTest.java b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedMetricsSelfTest.java index 472f544..d7b37c4 100644 --- a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedMetricsSelfTest.java +++ b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedMetricsSelfTest.java @@ -57,4 +57,14 @@ public class GridCachePartitionedMetricsSelfTest extends GridCacheTransactionalA @Override protected int gridCount() { return GRID_CNT; } + + /** {@inheritDoc} */ + @Override public void testGetAllAvgTime() throws Exception { + //TODO: GG-7578 + } + + /** {@inheritDoc} */ + @Override public void testGetAvgTime() throws Exception { + //TODO: GG-7578 + } }
