From f17b2ae0ea150a2803584f80276ada527db54b5a Mon Sep 17 00:00:00 2001 From: Anton Vinogradov Date: Mon, 28 Mar 2016 19:19:26 +0300 Subject: [PATCH] IGNITE-1071 IgniteCache.metrics() method returns local metrics --- .../rest/RestBinaryProtocolSelfTest.java | 4 +- .../rest/RestMemcacheProtocolSelfTest.java | 4 +- .../java/org/apache/ignite/IgniteCache.java | 20 +- .../discovery/GridDiscoveryManager.java | 2 +- .../cache/CacheClusterMetricsMXBeanImpl.java | 410 ++++++++++++++++++ ....java => CacheLocalMetricsMXBeanImpl.java} | 4 +- .../processors/cache/GridCacheAdapter.java | 43 +- .../processors/cache/GridCacheProcessor.java | 12 +- .../processors/cache/GridCacheProxyImpl.java | 45 +- .../processors/cache/IgniteCacheProxy.java | 39 +- .../processors/cache/IgniteInternalCache.java | 31 +- .../platform/cache/PlatformCache.java | 2 +- .../cache/GridCacheCommandHandler.java | 2 +- .../visor/cache/VisorCacheMetrics.java | 2 +- .../cache/VisorCacheResetMetricsTask.java | 2 +- .../CacheMetricsForClusterGroupSelfTest.java | 2 +- .../cache/CacheSwapUnswapGetTest.java | 4 +- .../GridCacheAbstractMetricsSelfTest.java | 124 +++--- ...ridCacheOffHeapValuesEvictionSelfTest.java | 18 +- ...eTransactionalAbstractMetricsSelfTest.java | 4 +- .../dht/GridCacheColocatedDebugTest.java | 2 +- ...artitionedNearDisabledMetricsSelfTest.java | 2 +- ...omicPartitionedTckMetricsSelfTestImpl.java | 92 ++-- .../near/GridCacheNearMetricsSelfTest.java | 152 +++---- ...CachePartitionedHitsAndMissesSelfTest.java | 2 +- ...cheLocalOffHeapAndSwapMetricsSelfTest.java | 380 ++++++++-------- ...acheAtomicLocalTckMetricsSelfTestImpl.java | 92 ++-- .../multijvm/IgniteCacheProcessProxy.java | 8 + 28 files changed, 1023 insertions(+), 481 deletions(-) create mode 100644 modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheClusterMetricsMXBeanImpl.java rename modules/core/src/main/java/org/apache/ignite/internal/processors/cache/{CacheMetricsMXBeanImpl.java => CacheLocalMetricsMXBeanImpl.java} (98%) diff --git a/modules/clients/src/test/java/org/apache/ignite/internal/processors/rest/RestBinaryProtocolSelfTest.java b/modules/clients/src/test/java/org/apache/ignite/internal/processors/rest/RestBinaryProtocolSelfTest.java index 7629afb94011d..251e184266b40 100644 --- a/modules/clients/src/test/java/org/apache/ignite/internal/processors/rest/RestBinaryProtocolSelfTest.java +++ b/modules/clients/src/test/java/org/apache/ignite/internal/processors/rest/RestBinaryProtocolSelfTest.java @@ -412,9 +412,9 @@ public void testMetrics() throws Exception { IgniteCache jcacheDft = grid().cache(null); IgniteCache jcacheName = grid().cache(CACHE_NAME); - jcacheDft.mxBean().clear(); + jcacheDft.localMxBean().clear(); - jcacheName.mxBean().clear(); + jcacheName.localMxBean().clear(); jcacheDft.put("key1", "val"); jcacheDft.put("key2", "val"); diff --git a/modules/clients/src/test/java/org/apache/ignite/internal/processors/rest/RestMemcacheProtocolSelfTest.java b/modules/clients/src/test/java/org/apache/ignite/internal/processors/rest/RestMemcacheProtocolSelfTest.java index fbaee9eb786e2..27973871c5e65 100644 --- a/modules/clients/src/test/java/org/apache/ignite/internal/processors/rest/RestMemcacheProtocolSelfTest.java +++ b/modules/clients/src/test/java/org/apache/ignite/internal/processors/rest/RestMemcacheProtocolSelfTest.java @@ -205,8 +205,8 @@ public void testReplace() throws Exception { * @throws Exception If failed. */ public void testMetrics() throws Exception { - grid().cache(null).mxBean().clear(); - grid().cache(CACHE_NAME).mxBean().clear(); + grid().cache(null).localMxBean().clear(); + grid().cache(CACHE_NAME).localMxBean().clear(); grid().cache(null).put("key1", "val"); grid().cache(null).put("key2", "val"); diff --git a/modules/core/src/main/java/org/apache/ignite/IgniteCache.java b/modules/core/src/main/java/org/apache/ignite/IgniteCache.java index a791e38e5551a..581f091d45f0a 100644 --- a/modules/core/src/main/java/org/apache/ignite/IgniteCache.java +++ b/modules/core/src/main/java/org/apache/ignite/IgniteCache.java @@ -715,14 +715,14 @@ public Map> invokeAll(Set keys, public IgniteFuture rebalance(); /** - * Gets snapshot metrics (statistics) for this cache. + * Gets whole cluster snapshot metrics (statistics) for this cache. * * @return Cache metrics. */ public CacheMetrics metrics(); /** - * Gets snapshot metrics for caches in cluster group. + * Gets cluster group snapshot metrics for caches in cluster group. * * @param grp Cluster group. * @return Cache metrics. @@ -730,9 +730,23 @@ public Map> invokeAll(Set keys, public CacheMetrics metrics(ClusterGroup grp); /** - * Gets MxBean for this cache. + * Gets local snapshot metrics (statistics) for this cache. + * + * @return Cache metrics. + */ + public CacheMetrics localMetrics(); + + /** + * Gets whole cluster MxBean for this cache. * * @return MxBean. */ public CacheMetricsMXBean mxBean(); + + /** + * Gets local MxBean for this cache. + * + * @return MxBean. + */ + public CacheMetricsMXBean localMxBean(); } diff --git a/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java b/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java index 7b795d5c2f4ab..a254b738a2469 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java @@ -908,7 +908,7 @@ private DiscoveryMetricsProvider createMetricsProvider() { if (metrics == null) metrics = U.newHashMap(caches.size()); - metrics.put(cache.context().cacheId(), cache.metrics()); + metrics.put(cache.context().cacheId(), cache.localMetrics()); } } diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheClusterMetricsMXBeanImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheClusterMetricsMXBeanImpl.java new file mode 100644 index 0000000000000..519d07b105db4 --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheClusterMetricsMXBeanImpl.java @@ -0,0 +1,410 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.processors.cache; + +import org.apache.ignite.IgniteCache; +import org.apache.ignite.mxbean.CacheMetricsMXBean; + +/** + * Management bean that provides access to {@link IgniteCache IgniteCache}. + */ +class CacheClusterMetricsMXBeanImpl implements CacheMetricsMXBean { + /** Cache. */ + private GridCacheAdapter cache; + + /** + * Creates MBean; + * + * @param cache Cache. + */ + CacheClusterMetricsMXBeanImpl(GridCacheAdapter cache) { + assert cache != null; + + this.cache = cache; + } + + /** {@inheritDoc} */ + @Override public String name() { + return cache.clusterMetrics().name(); + } + + /** {@inheritDoc} */ + @Override public long getOverflowSize() { + return cache.clusterMetrics().getOverflowSize(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapGets() { + return cache.clusterMetrics().getOffHeapGets(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapPuts() { + return cache.clusterMetrics().getOffHeapPuts(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapRemovals() { + return cache.clusterMetrics().getOffHeapRemovals(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapEvictions() { + return cache.clusterMetrics().getOffHeapEvictions(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapHits() { + return cache.clusterMetrics().getOffHeapHits(); + } + + /** {@inheritDoc} */ + @Override public float getOffHeapHitPercentage() { + return cache.clusterMetrics().getOffHeapHitPercentage(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapMisses() { + return cache.clusterMetrics().getOffHeapMisses(); + } + + /** {@inheritDoc} */ + @Override public float getOffHeapMissPercentage() { + return cache.clusterMetrics().getOffHeapMissPercentage(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapEntriesCount() { + return cache.clusterMetrics().getOffHeapEntriesCount(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapPrimaryEntriesCount() { + return cache.clusterMetrics().getOffHeapPrimaryEntriesCount(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapBackupEntriesCount() { + return cache.clusterMetrics().getOffHeapBackupEntriesCount(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapAllocatedSize() { + return cache.clusterMetrics().getOffHeapAllocatedSize(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapMaxSize() { + return cache.clusterMetrics().getOffHeapMaxSize(); + } + + /** {@inheritDoc} */ + @Override public long getSwapGets() { + return cache.clusterMetrics().getSwapGets(); + } + + /** {@inheritDoc} */ + @Override public long getSwapPuts() { + return cache.clusterMetrics().getSwapPuts(); + } + + /** {@inheritDoc} */ + @Override public long getSwapRemovals() { + return cache.clusterMetrics().getSwapRemovals(); + } + + /** {@inheritDoc} */ + @Override public long getSwapHits() { + return cache.clusterMetrics().getSwapHits(); + } + + /** {@inheritDoc} */ + @Override public long getSwapMisses() { + return cache.clusterMetrics().getSwapMisses(); + } + + /** {@inheritDoc} */ + @Override public float getSwapHitPercentage() { + return cache.clusterMetrics().getSwapHitPercentage(); + } + + /** {@inheritDoc} */ + @Override public float getSwapMissPercentage() { + return cache.clusterMetrics().getSwapMissPercentage(); + } + + /** {@inheritDoc} */ + @Override public long getSwapEntriesCount() { + return cache.clusterMetrics().getSwapEntriesCount(); + } + + /** {@inheritDoc} */ + @Override public long getSwapSize() { + return cache.clusterMetrics().getSwapSize(); + } + + /** {@inheritDoc} */ + @Override public int getSize() { + return cache.clusterMetrics().getSize(); + } + + /** {@inheritDoc} */ + @Override public int getKeySize() { + return cache.clusterMetrics().getKeySize(); + } + + /** {@inheritDoc} */ + @Override public boolean isEmpty() { + return cache.clusterMetrics().isEmpty(); + } + + /** {@inheritDoc} */ + @Override public int getDhtEvictQueueCurrentSize() { + return cache.clusterMetrics().getDhtEvictQueueCurrentSize(); + } + + /** {@inheritDoc} */ + @Override public int getTxCommitQueueSize() { + return cache.clusterMetrics().getTxCommitQueueSize(); + } + + /** {@inheritDoc} */ + @Override public int getTxThreadMapSize() { + return cache.clusterMetrics().getTxThreadMapSize(); + } + + /** {@inheritDoc} */ + @Override public int getTxXidMapSize() { + return cache.clusterMetrics().getTxXidMapSize(); + } + + /** {@inheritDoc} */ + @Override public int getTxPrepareQueueSize() { + return cache.clusterMetrics().getTxPrepareQueueSize(); + } + + /** {@inheritDoc} */ + @Override public int getTxStartVersionCountsSize() { + return cache.clusterMetrics().getTxStartVersionCountsSize(); + } + + /** {@inheritDoc} */ + @Override public int getTxCommittedVersionsSize() { + return cache.clusterMetrics().getTxCommittedVersionsSize(); + } + + /** {@inheritDoc} */ + @Override public int getTxRolledbackVersionsSize() { + return cache.clusterMetrics().getTxRolledbackVersionsSize(); + } + + /** {@inheritDoc} */ + @Override public int getTxDhtThreadMapSize() { + return cache.clusterMetrics().getTxDhtThreadMapSize(); + } + + /** {@inheritDoc} */ + @Override public int getTxDhtXidMapSize() { + return cache.clusterMetrics().getTxDhtXidMapSize(); + } + + /** {@inheritDoc} */ + @Override public int getTxDhtCommitQueueSize() { + return cache.clusterMetrics().getTxDhtCommitQueueSize(); + } + + /** {@inheritDoc} */ + @Override public int getTxDhtPrepareQueueSize() { + return cache.clusterMetrics().getTxDhtPrepareQueueSize(); + } + + /** {@inheritDoc} */ + @Override public int getTxDhtStartVersionCountsSize() { + return cache.clusterMetrics().getTxDhtStartVersionCountsSize(); + } + + /** {@inheritDoc} */ + @Override public int getTxDhtCommittedVersionsSize() { + return cache.clusterMetrics().getTxDhtCommittedVersionsSize(); + } + + /** {@inheritDoc} */ + @Override public int getTxDhtRolledbackVersionsSize() { + return cache.clusterMetrics().getTxDhtRolledbackVersionsSize(); + } + + /** {@inheritDoc} */ + @Override public boolean isWriteBehindEnabled() { + return cache.clusterMetrics().isWriteBehindEnabled(); + } + + /** {@inheritDoc} */ + @Override public int getWriteBehindFlushSize() { + return cache.clusterMetrics().getWriteBehindFlushSize(); + } + + /** {@inheritDoc} */ + @Override public int getWriteBehindFlushThreadCount() { + return cache.clusterMetrics().getWriteBehindFlushThreadCount(); + } + + /** {@inheritDoc} */ + @Override public long getWriteBehindFlushFrequency() { + return cache.clusterMetrics().getWriteBehindFlushFrequency(); + } + + /** {@inheritDoc} */ + @Override public int getWriteBehindStoreBatchSize() { + return cache.clusterMetrics().getWriteBehindStoreBatchSize(); + } + + /** {@inheritDoc} */ + @Override public int getWriteBehindTotalCriticalOverflowCount() { + return cache.clusterMetrics().getWriteBehindTotalCriticalOverflowCount(); + } + + /** {@inheritDoc} */ + @Override public int getWriteBehindCriticalOverflowCount() { + return cache.clusterMetrics().getWriteBehindCriticalOverflowCount(); + } + + /** {@inheritDoc} */ + @Override public int getWriteBehindErrorRetryCount() { + return cache.clusterMetrics().getWriteBehindErrorRetryCount(); + } + + /** {@inheritDoc} */ + @Override public int getWriteBehindBufferSize() { + return cache.clusterMetrics().getWriteBehindBufferSize(); + } + + /** {@inheritDoc} */ + @Override public void clear() { + throw new UnsupportedOperationException("Cluster metrics can't be cleared. Use local metrics clear instead."); + } + + /** {@inheritDoc} */ + @Override public long getCacheHits() { + return cache.clusterMetrics().getCacheHits(); + } + + /** {@inheritDoc} */ + @Override public float getCacheHitPercentage() { + return cache.clusterMetrics().getCacheHitPercentage(); + } + + /** {@inheritDoc} */ + @Override public long getCacheMisses() { + return cache.clusterMetrics().getCacheMisses(); + } + + /** {@inheritDoc} */ + @Override public float getCacheMissPercentage() { + return cache.clusterMetrics().getCacheMissPercentage(); + } + + /** {@inheritDoc} */ + @Override public long getCacheGets() { + return cache.clusterMetrics().getCacheGets(); + } + + /** {@inheritDoc} */ + @Override public long getCachePuts() { + return cache.clusterMetrics().getCachePuts(); + } + + /** {@inheritDoc} */ + @Override public long getCacheRemovals() { + return cache.clusterMetrics().getCacheRemovals(); + } + + /** {@inheritDoc} */ + @Override public long getCacheEvictions() { + return cache.clusterMetrics().getCacheEvictions(); + } + + /** {@inheritDoc} */ + @Override public float getAverageGetTime() { + return cache.clusterMetrics().getAverageGetTime(); + } + + /** {@inheritDoc} */ + @Override public float getAveragePutTime() { + return cache.clusterMetrics().getAveragePutTime(); + } + + /** {@inheritDoc} */ + @Override public float getAverageRemoveTime() { + return cache.clusterMetrics().getAverageRemoveTime(); + } + + /** {@inheritDoc} */ + @Override public float getAverageTxCommitTime() { + return cache.clusterMetrics().getAverageTxCommitTime(); + } + + /** {@inheritDoc} */ + @Override public float getAverageTxRollbackTime() { + return cache.clusterMetrics().getAverageTxRollbackTime(); + } + + /** {@inheritDoc} */ + @Override public long getCacheTxCommits() { + return cache.clusterMetrics().getCacheTxCommits(); + } + + /** {@inheritDoc} */ + @Override public long getCacheTxRollbacks() { + return cache.clusterMetrics().getCacheTxRollbacks(); + } + + /** {@inheritDoc} */ + @Override public String getKeyType() { + return cache.clusterMetrics().getKeyType(); + } + + /** {@inheritDoc} */ + @Override public String getValueType() { + return cache.clusterMetrics().getValueType(); + } + + /** {@inheritDoc} */ + @Override public boolean isStoreByValue() { + return cache.clusterMetrics().isStoreByValue(); + } + + /** {@inheritDoc} */ + @Override public boolean isStatisticsEnabled() { + return cache.clusterMetrics().isStatisticsEnabled(); + } + + /** {@inheritDoc} */ + @Override public boolean isManagementEnabled() { + return cache.clusterMetrics().isManagementEnabled(); + } + + /** {@inheritDoc} */ + @Override public boolean isReadThrough() { + return cache.clusterMetrics().isReadThrough(); + } + + /** {@inheritDoc} */ + @Override public boolean isWriteThrough() { + return cache.clusterMetrics().isWriteThrough(); + } +} \ No newline at end of file diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsMXBeanImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheLocalMetricsMXBeanImpl.java similarity index 98% rename from modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsMXBeanImpl.java rename to modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheLocalMetricsMXBeanImpl.java index 822240e6b3309..5284ca0d1e515 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsMXBeanImpl.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheLocalMetricsMXBeanImpl.java @@ -23,7 +23,7 @@ /** * Management bean that provides access to {@link IgniteCache IgniteCache}. */ -class CacheMetricsMXBeanImpl implements CacheMetricsMXBean { +class CacheLocalMetricsMXBeanImpl implements CacheMetricsMXBean { /** Cache. */ private GridCacheAdapter cache; @@ -32,7 +32,7 @@ class CacheMetricsMXBeanImpl implements CacheMetricsMXBean { * * @param cache Cache. */ - CacheMetricsMXBeanImpl(GridCacheAdapter cache) { + CacheLocalMetricsMXBeanImpl(GridCacheAdapter cache) { assert cache != null; this.cache = cache; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java index a1f0f2828791e..44c8b570a3e22 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java @@ -137,6 +137,7 @@ import org.apache.ignite.plugin.security.SecurityPermission; import org.apache.ignite.resources.IgniteInstanceResource; import org.apache.ignite.resources.JobContextResource; +import org.apache.ignite.spi.discovery.tcp.internal.TcpDiscoveryNode; import org.apache.ignite.transactions.Transaction; import org.apache.ignite.transactions.TransactionConcurrency; import org.apache.ignite.transactions.TransactionIsolation; @@ -253,8 +254,11 @@ public abstract class GridCacheAdapter implements IgniteInternalCache ctx, GridCacheConcurrent metrics = new CacheMetricsImpl(ctx); - mxBean = new CacheMetricsMXBeanImpl(this); + localMxBean = new CacheLocalMetricsMXBeanImpl(this); + clusterMxBean = new CacheClusterMetricsMXBeanImpl(this); FileSystemConfiguration[] igfsCfgs = gridCfg.getFileSystemConfiguration(); @@ -3294,13 +3299,41 @@ public IgniteInternalFuture localRemoveAll(final CacheEntryPredicate filter) } /** {@inheritDoc} */ - @Override public CacheMetrics metrics() { + @Override public CacheMetrics clusterMetrics() { + return clusterMetrics(ctx.grid().cluster().forCacheNodes(ctx.name())); + } + + /** {@inheritDoc} */ + @Override public CacheMetrics clusterMetrics(ClusterGroup grp) { + List metrics = new ArrayList<>(grp.nodes().size()); + + for (ClusterNode node : grp.nodes()) { + Map nodeCacheMetrics = ((TcpDiscoveryNode)node).cacheMetrics(); + + if (nodeCacheMetrics != null) { + CacheMetrics e = nodeCacheMetrics.get(context().cacheId()); + + if (e != null) + metrics.add(e); + } + } + + return new CacheMetricsSnapshot(ctx.cache().localMetrics(), metrics); + } + + /** {@inheritDoc} */ + @Override public CacheMetrics localMetrics() { return new CacheMetricsSnapshot(metrics); } /** {@inheritDoc} */ - @Override public CacheMetricsMXBean mxBean() { - return mxBean; + @Override public CacheMetricsMXBean localMxBean() { + return localMxBean; + } + + /** {@inheritDoc} */ + @Override public CacheMetricsMXBean clusterMxBean() { + return clusterMxBean; } /** diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProcessor.java index f5ebc0d7dff2d..67d6a6c97977f 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProcessor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProcessor.java @@ -549,8 +549,10 @@ private void cleanup(GridCacheContext cctx) { cleanup(cfg, cfg.getAffinityMapper(), false); cleanup(cfg, cctx.store().configuredStore(), false); - if (!CU.isUtilityCache(cfg.getName()) && !CU.isSystemCache(cfg.getName())) - unregisterMbean(cctx.cache().mxBean(), cfg.getName(), false); + if (!CU.isUtilityCache(cfg.getName()) && !CU.isSystemCache(cfg.getName())) { + unregisterMbean(cctx.cache().localMxBean(), cfg.getName(), false); + unregisterMbean(cctx.cache().clusterMxBean(), cfg.getName(), false); + } NearCacheConfiguration nearCfg = cfg.getNearConfiguration(); @@ -1488,8 +1490,10 @@ private GridCacheContext createCache(CacheConfiguration cfg, cacheCtx.cache(dht); } - if (!CU.isUtilityCache(cache.name()) && !CU.isSystemCache(cache.name())) - registerMbean(cache.mxBean(), cache.name(), false); + if (!CU.isUtilityCache(cache.name()) && !CU.isSystemCache(cache.name())) { + registerMbean(cache.localMxBean(), cache.name(), false); + registerMbean(cache.clusterMxBean(), cache.name(), false); + } return ret; } diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProxyImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProxyImpl.java index 9b4aff3af9dd7..cbe16c60de468 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProxyImpl.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProxyImpl.java @@ -35,6 +35,7 @@ import org.apache.ignite.cache.CacheMetrics; import org.apache.ignite.cache.CachePeekMode; import org.apache.ignite.cache.affinity.Affinity; +import org.apache.ignite.cluster.ClusterGroup; import org.apache.ignite.configuration.CacheConfiguration; import org.apache.ignite.internal.IgniteInternalFuture; import org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion; @@ -142,17 +143,53 @@ public IgniteInternalCache delegate() { return aff; } + /** {@inheritDoc} */ + @Override public CacheMetrics clusterMetrics() { + CacheOperationContext prev = gate.enter(opCtx); + + try { + return delegate.clusterMetrics(); + } + finally { + gate.leave(prev); + } + } + + /** {@inheritDoc} */ + @Override public CacheMetrics clusterMetrics(ClusterGroup grp) { + CacheOperationContext prev = gate.enter(opCtx); + + try { + return delegate.clusterMetrics(grp); + } + finally { + gate.leave(prev); + } + } + /** {@inheritDoc} */ @Override public CacheConfiguration configuration() { return delegate.configuration(); } /** {@inheritDoc} */ - @Override public CacheMetrics metrics() { + @Override public CacheMetrics localMetrics() { + CacheOperationContext prev = gate.enter(opCtx); + + try { + return delegate.localMetrics(); + } + finally { + gate.leave(prev); + } + } + + /** {@inheritDoc} */ + @Override public CacheMetricsMXBean clusterMxBean() { CacheOperationContext prev = gate.enter(opCtx); try { - return delegate.metrics(); + return delegate.clusterMxBean(); } finally { gate.leave(prev); @@ -160,11 +197,11 @@ public IgniteInternalCache delegate() { } /** {@inheritDoc} */ - @Override public CacheMetricsMXBean mxBean() { + @Override public CacheMetricsMXBean localMxBean() { CacheOperationContext prev = gate.enter(opCtx); try { - return delegate.mxBean(); + return delegate.localMxBean(); } finally { gate.leave(prev); 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 6e8bcbf8a5981..5b78271df1ba4 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 @@ -222,7 +222,7 @@ public GridCacheGateway gate() { CacheOperationContext prev = onEnter(gate, opCtx); try { - return ctx.cache().metrics(); + return ctx.cache().clusterMetrics(); } finally { onLeave(gate, prev); @@ -236,20 +236,20 @@ public GridCacheGateway gate() { CacheOperationContext prev = onEnter(gate, opCtx); try { - List metrics = new ArrayList<>(grp.nodes().size()); - - for (ClusterNode node : grp.nodes()) { - Map nodeCacheMetrics = ((TcpDiscoveryNode)node).cacheMetrics(); + return ctx.cache().clusterMetrics(grp); + } + finally { + onLeave(gate, prev); + } + } - if (nodeCacheMetrics != null) { - CacheMetrics e = nodeCacheMetrics.get(context().cacheId()); + @Override public CacheMetrics localMetrics() { + GridCacheGateway gate = this.gate; - if (e != null) - metrics.add(e); - } - } + CacheOperationContext prev = onEnter(gate, opCtx); - return new CacheMetricsSnapshot(ctx.cache().metrics(), metrics); + try { + return ctx.cache().localMetrics(); } finally { onLeave(gate, prev); @@ -263,7 +263,20 @@ public GridCacheGateway gate() { CacheOperationContext prev = onEnter(gate, opCtx); try { - return ctx.cache().mxBean(); + return ctx.cache().clusterMxBean(); + } + finally { + onLeave(gate, prev); + } + } + + @Override public CacheMetricsMXBean localMxBean() { + GridCacheGateway gate = this.gate; + + CacheOperationContext prev = onEnter(gate, opCtx); + + try { + return ctx.cache().localMxBean(); } finally { onLeave(gate, prev); diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteInternalCache.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteInternalCache.java index 68d0f065f139d..d2e010169207c 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteInternalCache.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteInternalCache.java @@ -38,6 +38,7 @@ import org.apache.ignite.cache.affinity.Affinity; import org.apache.ignite.cache.affinity.AffinityKeyMapped; import org.apache.ignite.cache.store.CacheStore; +import org.apache.ignite.cluster.ClusterGroup; import org.apache.ignite.configuration.CacheConfiguration; import org.apache.ignite.configuration.IgniteConfiguration; import org.apache.ignite.internal.IgniteInternalFuture; @@ -1543,18 +1544,40 @@ public boolean lock(K key, long timeout) public Affinity affinity(); /** - * Gets metrics (statistics) for this cache. + * Gets whole cluster metrics (statistics) for this cache. * * @return Cache metrics. */ - public CacheMetrics metrics(); + public CacheMetrics clusterMetrics(); /** - * Gets metrics (statistics) for this cache. + * Gets cluster group metrics (statistics) for this cache. * + * @param grp Cluster group. * @return Cache metrics. */ - public CacheMetricsMXBean mxBean(); + public CacheMetrics clusterMetrics(ClusterGroup grp); + + /** + * Gets local metrics (statistics) for this cache. + * + * @return Cache metrics. + */ + public CacheMetrics localMetrics(); + + /** + * Gets whole cluster metrics (statistics) for this cache. + * + * @return Cache metrics. + */ + public CacheMetricsMXBean clusterMxBean(); + + /** + * Gets local metrics (statistics) for this cache. + * + * @return Cache metrics. + */ + public CacheMetricsMXBean localMxBean(); /** * Gets size (in bytes) of all entries swapped to disk. diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/cache/PlatformCache.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/cache/PlatformCache.java index 35ccd197be5b2..75683a8d0c31f 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/cache/PlatformCache.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/platform/cache/PlatformCache.java @@ -482,7 +482,7 @@ private void loadCache0(BinaryRawReaderEx reader, boolean loc) { break; case OP_METRICS: - CacheMetrics metrics = cache.metrics(); + CacheMetrics metrics = cache.localMetrics(); writer.writeLong(metrics.getCacheGets()); writer.writeLong(metrics.getCachePuts()); diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java index a89913f95ecf1..85611dee96d22 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/handlers/cache/GridCacheCommandHandler.java @@ -1486,7 +1486,7 @@ private static class MetricsCommand extends CacheCommand { /** {@inheritDoc} */ @Override public IgniteInternalFuture applyx(IgniteInternalCache c, GridKernalContext ctx) { - CacheMetrics metrics = c.cache().metrics(); + CacheMetrics metrics = c.cache().localMetrics(); assert metrics != null; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorCacheMetrics.java b/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorCacheMetrics.java index 1a8881336a2c7..0a77dc4090272 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorCacheMetrics.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorCacheMetrics.java @@ -179,7 +179,7 @@ public VisorCacheMetrics from(IgniteEx ignite, String cacheName) { mode = cacheProcessor.cacheMode(cacheName); sys = cacheProcessor.systemCache(cacheName); - CacheMetrics m = c.metrics(); + CacheMetrics m = c.localMetrics(); size = m.getSize(); keySize = m.getKeySize(); diff --git a/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorCacheResetMetricsTask.java b/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorCacheResetMetricsTask.java index 9ff4dae64312a..ccec241722fcc 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorCacheResetMetricsTask.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/visor/cache/VisorCacheResetMetricsTask.java @@ -56,7 +56,7 @@ private VisorCacheResetMetricsJob(String arg, boolean debug) { IgniteInternalCache cache = ignite.cachex(cacheName); if (cache != null) - cache.mxBean().clear(); + cache.localMxBean().clear(); return null; } diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheMetricsForClusterGroupSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheMetricsForClusterGroupSelfTest.java index c0075ad167dab..9c24febd97a6c 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheMetricsForClusterGroupSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheMetricsForClusterGroupSelfTest.java @@ -213,7 +213,7 @@ private void assertMetrics(IgniteCache cache) { CacheMetrics metrics = cache.metrics(grid(i).cluster().forCacheNodes(cache.getName())); for (int j = 0; j < GRID_CNT; j++) - ms[j] = grid(j).cache(cache.getName()).metrics(); + ms[j] = grid(j).cache(cache.getName()).localMetrics(); // Static metrics for (int j = 0; j < GRID_CNT; j++) diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheSwapUnswapGetTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheSwapUnswapGetTest.java index 214beb674c14c..7fe1f34dca419 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheSwapUnswapGetTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheSwapUnswapGetTest.java @@ -264,7 +264,7 @@ private void swapUnswap(CacheAtomicityMode atomicityMode, CacheMemoryMode memMod ", offheap=" + cache.localSize(CachePeekMode.OFFHEAP) + ", swap=" + cache.localSize(CachePeekMode.SWAP) + ", total=" + cache.localSize() + - ", offheapMem=" + cache.metrics().getOffHeapAllocatedSize() + ']'); + ", offheapMem=" + cache.localMetrics().getOffHeapAllocatedSize() + ']'); } done.set(true); @@ -282,7 +282,7 @@ private void swapUnswap(CacheAtomicityMode atomicityMode, CacheMemoryMode memMod int offheapSize = cache.localSize(CachePeekMode.OFFHEAP); int swapSize = cache.localSize(CachePeekMode.SWAP); int total = cache.localSize(); - long offheapMem = cache.metrics().getOffHeapAllocatedSize(); + long offheapMem = cache.localMetrics().getOffHeapAllocatedSize(); log.info("Cache size [heap=" + onheapSize + ", offheap=" + offheapSize + diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractMetricsSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractMetricsSelfTest.java index 4c04df01719e4..13bd081c3bfff 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractMetricsSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractMetricsSelfTest.java @@ -97,7 +97,7 @@ protected int expectedMissesPerPut(boolean isPrimary) { for (int i = 0; i < gridCount(); i++) { Ignite g = grid(i); - g.cache(null).mxBean().clear(); + g.cache(null).localMxBean().clear(); g.transactions().resetMetrics(); } @@ -141,7 +141,7 @@ public void testGetMetricsDisable() throws Exception { // Assert that statistics is clear. for (int i = 0; i < gridCount(); i++) { - CacheMetrics m = grid(i).cache(null).metrics(); + CacheMetrics m = grid(i).cache(null).localMetrics(); assertEquals(m.getCacheGets(), 0); assertEquals(m.getCachePuts(), 0); @@ -162,7 +162,7 @@ public void testGetMetricsDisable() throws Exception { public void testGetMetricsSnapshot() throws Exception { IgniteCache cache = grid(0).cache(null); - assertNotSame("Method metrics() should return snapshot.", cache.metrics(), cache.metrics()); + assertNotSame("Method metrics() should return snapshot.", cache.localMetrics(), cache.localMetrics()); } /** @@ -176,7 +176,7 @@ public void testGetAndRemoveAsyncAvgTime() throws Exception { for (int i = 0; i < KEY_CNT; i++) cache.put(i, i); - assertEquals(cache.metrics().getAverageRemoveTime(), 0.0, 0.0); + assertEquals(cache.localMetrics().getAverageRemoveTime(), 0.0, 0.0); for (int i = 0; i < KEY_CNT; i++) { cacheAsync.getAndRemove(i); @@ -186,7 +186,7 @@ public void testGetAndRemoveAsyncAvgTime() throws Exception { fut.get(); } - assert cache.metrics().getAverageRemoveTime() > 0; + assert cache.localMetrics().getAverageRemoveTime() > 0; } /** @@ -206,7 +206,7 @@ public void testRemoveAsyncValAvgTime() throws Exception { } } - assertEquals(cache.metrics().getAverageRemoveTime(), 0.0, 0.0); + assertEquals(cache.localMetrics().getAverageRemoveTime(), 0.0, 0.0); cache.put(key, key); @@ -216,7 +216,7 @@ public void testRemoveAsyncValAvgTime() throws Exception { assertTrue(fut.get()); - assert cache.metrics().getAverageRemoveTime() >= 0; + assert cache.localMetrics().getAverageRemoveTime() >= 0; } /** @@ -228,12 +228,12 @@ public void testRemoveAvgTime() throws Exception { for (int i = 0; i < KEY_CNT; i++) cache.put(i, i); - assertEquals(cache.metrics().getAverageRemoveTime(), 0.0, 0.0); + assertEquals(cache.localMetrics().getAverageRemoveTime(), 0.0, 0.0); for (int i = 0; i < KEY_CNT; i++) cache.remove(i); - assert cache.metrics().getAverageRemoveTime() > 0; + assert cache.localMetrics().getAverageRemoveTime() > 0; } /** @@ -246,7 +246,7 @@ public void testRemoveAllAvgTime() throws Exception { cache.put(2, 2); cache.put(3, 3); - assertEquals(cache.metrics().getAverageRemoveTime(), 0.0, 0.0); + assertEquals(cache.localMetrics().getAverageRemoveTime(), 0.0, 0.0); Set keys = new HashSet<>(4, 1); keys.add(1); @@ -255,7 +255,7 @@ public void testRemoveAllAvgTime() throws Exception { cache.removeAll(keys); - float averageRemoveTime = cache.metrics().getAverageRemoveTime(); + float averageRemoveTime = cache.localMetrics().getAverageRemoveTime(); assert averageRemoveTime >= 0; } @@ -280,7 +280,7 @@ public void testRemoveAllAsyncAvgTime() throws Exception { } } - assertEquals(cache.metrics().getAverageRemoveTime(), 0.0, 0.0); + assertEquals(cache.localMetrics().getAverageRemoveTime(), 0.0, 0.0); cacheAsync.removeAll(keys); @@ -288,7 +288,7 @@ public void testRemoveAllAsyncAvgTime() throws Exception { fut.get(); - assert cache.metrics().getAverageRemoveTime() >= 0; + assert cache.localMetrics().getAverageRemoveTime() >= 0; } @@ -300,17 +300,17 @@ public void testGetAvgTime() throws Exception { cache.put(1, 1); - assertEquals(0.0, cache.metrics().getAverageGetTime(), 0.0); + assertEquals(0.0, cache.localMetrics().getAverageGetTime(), 0.0); cache.get(1); - float averageGetTime = cache.metrics().getAverageGetTime(); + float averageGetTime = cache.localMetrics().getAverageGetTime(); assert averageGetTime > 0; cache.get(2); - assert cache.metrics().getAverageGetTime() > 0; + assert cache.localMetrics().getAverageGetTime() > 0; } /** @@ -319,13 +319,13 @@ public void testGetAvgTime() throws Exception { public void testGetAllAvgTime() throws Exception { IgniteCache cache = grid(0).cache(null); - assertEquals(0.0, cache.metrics().getAverageGetTime(), 0.0); + assertEquals(0.0, cache.localMetrics().getAverageGetTime(), 0.0); cache.put(1, 1); cache.put(2, 2); cache.put(3, 3); - assertEquals(0.0, cache.metrics().getAverageGetTime(), 0.0); + assertEquals(0.0, cache.localMetrics().getAverageGetTime(), 0.0); Set keys = new TreeSet<>(); keys.add(1); @@ -334,7 +334,7 @@ public void testGetAllAvgTime() throws Exception { cache.getAll(keys); - assert cache.metrics().getAverageGetTime() > 0; + assert cache.localMetrics().getAverageGetTime() > 0; } /** @@ -344,13 +344,13 @@ public void testGetAllAsyncAvgTime() throws Exception { IgniteCache cache = grid(0).cache(null); IgniteCache cacheAsync = cache.withAsync(); - assertEquals(0.0, cache.metrics().getAverageGetTime(), 0.0); + assertEquals(0.0, cache.localMetrics().getAverageGetTime(), 0.0); cache.put(1, 1); cache.put(2, 2); cache.put(3, 3); - assertEquals(0.0, cache.metrics().getAverageGetTime(), 0.0); + assertEquals(0.0, cache.localMetrics().getAverageGetTime(), 0.0); Set keys = new TreeSet<>(); keys.add(1); @@ -365,24 +365,24 @@ public void testGetAllAsyncAvgTime() throws Exception { TimeUnit.MILLISECONDS.sleep(100L); - assert cache.metrics().getAverageGetTime() > 0; + assert cache.localMetrics().getAverageGetTime() > 0; } /** * @throws Exception If failed. */ public void testPutAvgTime() throws Exception { - IgniteCache cache = grid(0).cache(null); + final IgniteCache cache = grid(0).cache(null); - assertEquals(0.0, cache.metrics().getAveragePutTime(), 0.0); - assertEquals(0, cache.metrics().getCachePuts()); + assertEquals(0.0, cache.localMetrics().getAveragePutTime(), 0.0); + assertEquals(0, cache.localMetrics().getCachePuts()); for (int i = 0; i < KEY_CNT; i++) cache.put(i, i); - assert cache.metrics().getAveragePutTime() > 0; + assert cache.localMetrics().getAveragePutTime() > 0; - assertEquals(KEY_CNT, cache.metrics().getCachePuts()); + assertEquals(KEY_CNT, cache.localMetrics().getCachePuts()); } /** @@ -392,8 +392,8 @@ public void testPutAsyncAvgTime() throws Exception { IgniteCache cache = grid(0).cache(null); IgniteCache cacheAsync = cache.withAsync(); - assertEquals(0.0, cache.metrics().getAveragePutTime(), 0.0); - assertEquals(0, cache.metrics().getCachePuts()); + assertEquals(0.0, cache.localMetrics().getAveragePutTime(), 0.0); + assertEquals(0, cache.localMetrics().getCachePuts()); cacheAsync.put(1, 1); @@ -401,7 +401,7 @@ public void testPutAsyncAvgTime() throws Exception { TimeUnit.MILLISECONDS.sleep(100L); - assert cache.metrics().getAveragePutTime() > 0; + assert cache.localMetrics().getAveragePutTime() > 0; } /** @@ -421,8 +421,8 @@ public void testGetAndPutAsyncAvgTime() throws Exception { } } - assertEquals(0.0, cache.metrics().getAveragePutTime(), 0.0); - assertEquals(0.0, cache.metrics().getAverageGetTime(), 0.0); + assertEquals(0.0, cache.localMetrics().getAveragePutTime(), 0.0); + assertEquals(0.0, cache.localMetrics().getAverageGetTime(), 0.0); cacheAsync.getAndPut(key, key); @@ -432,8 +432,8 @@ public void testGetAndPutAsyncAvgTime() throws Exception { TimeUnit.MILLISECONDS.sleep(100L); - assert cache.metrics().getAveragePutTime() > 0; - assert cache.metrics().getAverageGetTime() > 0; + assert cache.localMetrics().getAveragePutTime() > 0; + assert cache.localMetrics().getAverageGetTime() > 0; } /** @@ -453,7 +453,7 @@ public void testPutIfAbsentAsyncAvgTime() throws Exception { } } - assertEquals(0.0f, cache.metrics().getAveragePutTime()); + assertEquals(0.0f, cache.localMetrics().getAveragePutTime()); cacheAsync.putIfAbsent(key, key); @@ -463,7 +463,7 @@ public void testPutIfAbsentAsyncAvgTime() throws Exception { TimeUnit.MILLISECONDS.sleep(100L); - assert cache.metrics().getAveragePutTime() > 0; + assert cache.localMetrics().getAveragePutTime() > 0; } /** @@ -483,7 +483,7 @@ public void testGetAndPutIfAbsentAsyncAvgTime() throws Exception { } } - assertEquals(0.0f, cache.metrics().getAveragePutTime()); + assertEquals(0.0f, cache.localMetrics().getAveragePutTime()); cacheAsync.getAndPutIfAbsent(key, key); @@ -493,7 +493,7 @@ public void testGetAndPutIfAbsentAsyncAvgTime() throws Exception { TimeUnit.MILLISECONDS.sleep(100L); - assert cache.metrics().getAveragePutTime() > 0; + assert cache.localMetrics().getAveragePutTime() > 0; } /** @@ -502,8 +502,8 @@ public void testGetAndPutIfAbsentAsyncAvgTime() throws Exception { public void testPutAllAvgTime() throws Exception { IgniteCache cache = grid(0).cache(null); - assertEquals(0.0, cache.metrics().getAveragePutTime(), 0.0); - assertEquals(0, cache.metrics().getCachePuts()); + assertEquals(0.0, cache.localMetrics().getAveragePutTime(), 0.0); + assertEquals(0, cache.localMetrics().getCachePuts()); Map values = new HashMap<>(); @@ -513,10 +513,10 @@ public void testPutAllAvgTime() throws Exception { cache.putAll(values); - float averagePutTime = cache.metrics().getAveragePutTime(); + float averagePutTime = cache.localMetrics().getAveragePutTime(); assert averagePutTime >= 0; - assertEquals(values.size(), cache.metrics().getCachePuts()); + assertEquals(values.size(), cache.localMetrics().getCachePuts()); } /** @@ -539,12 +539,12 @@ public void testPutsReads() throws Exception { expReads += expectedReadsPerPut(isPrimary); expMisses += expectedMissesPerPut(isPrimary); - info("Puts: " + cache0.metrics().getCachePuts()); + info("Puts: " + cache0.localMetrics().getCachePuts()); for (int j = 0; j < gridCount(); j++) { IgniteCache cache = grid(j).cache(null); - int cacheWrites = (int)cache.metrics().getCachePuts(); + int cacheWrites = (int)cache.localMetrics().getCachePuts(); assertEquals("Wrong cache metrics [i=" + i + ", grid=" + j + ']', i + 1, cacheWrites); } @@ -561,7 +561,7 @@ public void testPutsReads() throws Exception { int misses = 0; for (int i = 0; i < gridCount(); i++) { - CacheMetrics m = grid(i).cache(null).metrics(); + CacheMetrics m = grid(i).cache(null).localMetrics(); puts += m.getCachePuts(); reads += m.getCacheGets(); @@ -583,18 +583,18 @@ public void testPutsReads() throws Exception { public void testMissHitPercentage() throws Exception { IgniteCache cache0 = grid(0).cache(null); - int keyCnt = keyCount(); + final int keyCnt = keyCount(); // Put and get a few keys. for (int i = 0; i < keyCnt; i++) { cache0.getAndPut(i, i); // +1 read - info("Puts: " + cache0.metrics().getCachePuts()); + info("Puts: " + cache0.localMetrics().getCachePuts()); for (int j = 0; j < gridCount(); j++) { IgniteCache cache = grid(j).cache(null); - long cacheWrites = cache.metrics().getCachePuts(); + long cacheWrites = cache.localMetrics().getCachePuts(); assertEquals("Wrong cache metrics [i=" + i + ", grid=" + j + ']', i + 1, cacheWrites); } @@ -604,7 +604,7 @@ public void testMissHitPercentage() throws Exception { // Check metrics for the whole cache. for (int i = 0; i < gridCount(); i++) { - CacheMetrics m = grid(i).cache(null).metrics(); + CacheMetrics m = grid(i).cache(null).localMetrics(); assertEquals(m.getCacheHits() * 100f / m.getCacheGets(), m.getCacheHitPercentage(), 0.1f); assertEquals(m.getCacheMisses() * 100f / m.getCacheGets(), m.getCacheMissPercentage(), 0.1f); @@ -639,7 +639,7 @@ public void testMisses() throws Exception { long misses = 0; for (int i = 0; i < gridCount(); i++) { - CacheMetrics m = grid(i).cache(null).metrics(); + CacheMetrics m = grid(i).cache(null).localMetrics(); puts += m.getCachePuts(); reads += m.getCacheGets(); @@ -659,8 +659,8 @@ public void testMisses() throws Exception { public void testMissesOnEmptyCache() throws Exception { IgniteCache cache = grid(0).cache(null); - assertEquals("Expected 0 read", 0, cache.metrics().getCacheGets()); - assertEquals("Expected 0 miss", 0, cache.metrics().getCacheMisses()); + assertEquals("Expected 0 read", 0, cache.localMetrics().getCacheGets()); + assertEquals("Expected 0 miss", 0, cache.localMetrics().getCacheMisses()); Integer key = null; @@ -676,19 +676,19 @@ public void testMissesOnEmptyCache() throws Exception { cache.get(key); - assertEquals("Expected 1 read", 1, cache.metrics().getCacheGets()); - assertEquals("Expected 1 miss", 1, cache.metrics().getCacheMisses()); + assertEquals("Expected 1 read", 1, cache.localMetrics().getCacheGets()); + assertEquals("Expected 1 miss", 1, cache.localMetrics().getCacheMisses()); cache.getAndPut(key, key); // +1 read, +1 miss. - assertEquals("Expected 2 reads", 2, cache.metrics().getCacheGets()); + assertEquals("Expected 2 reads", 2, cache.localMetrics().getCacheGets()); cache.get(key); - assertEquals("Expected 1 write", 1, cache.metrics().getCachePuts()); - assertEquals("Expected 3 reads", 3, cache.metrics().getCacheGets()); - assertEquals("Expected 2 misses", 2, cache.metrics().getCacheMisses()); - assertEquals("Expected 1 hit", 1, cache.metrics().getCacheHits()); + assertEquals("Expected 1 write", 1, cache.localMetrics().getCachePuts()); + assertEquals("Expected 3 reads", 3, cache.localMetrics().getCacheGets()); + assertEquals("Expected 2 misses", 2, cache.localMetrics().getCacheMisses()); + assertEquals("Expected 1 hit", 1, cache.localMetrics().getCacheHits()); } /** @@ -702,7 +702,7 @@ public void testRemoves() throws Exception { // +1 remove cache.remove(1); - assertEquals(1L, cache.metrics().getCacheRemovals()); + assertEquals(1L, cache.localMetrics().getCacheRemovals()); } /** @@ -718,8 +718,8 @@ public void testManualEvictions() throws Exception { cache.localEvict(Collections.singleton(1)); - assertEquals(0L, cache.metrics().getCacheRemovals()); - assertEquals(1L, cache.metrics().getCacheEvictions()); + assertEquals(0L, cache.localMetrics().getCacheRemovals()); + assertEquals(1L, cache.localMetrics().getCacheEvictions()); } /** diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheOffHeapValuesEvictionSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheOffHeapValuesEvictionSelfTest.java index a3cc7851595b9..108ee90a2c7f2 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheOffHeapValuesEvictionSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheOffHeapValuesEvictionSelfTest.java @@ -103,9 +103,9 @@ public void testPutValuesOffHeap() throws Exception { assertTrue(MAX_VALS_AMOUNT - 5 <= cache.size(CachePeekMode.ONHEAP)); assertEquals(cache.size(CachePeekMode.ALL) - cache.size(CachePeekMode.ONHEAP), cache.size(CachePeekMode.SWAP)); - assertTrue((MAX_VALS_AMOUNT + 5) * VAL_SIZE > cache.metrics().getOffHeapAllocatedSize()); - assertTrue((MAX_VALS_AMOUNT - 5) * VAL_SIZE < cache.metrics().getOffHeapAllocatedSize()); - assertTrue(cache.metrics().getOffHeapAllocatedSize() >= cache.size(CachePeekMode.ONHEAP) * VAL_SIZE); + assertTrue((MAX_VALS_AMOUNT + 5) * VAL_SIZE > cache.localMetrics().getOffHeapAllocatedSize()); + assertTrue((MAX_VALS_AMOUNT - 5) * VAL_SIZE < cache.localMetrics().getOffHeapAllocatedSize()); + assertTrue(cache.localMetrics().getOffHeapAllocatedSize() >= cache.size(CachePeekMode.ONHEAP) * VAL_SIZE); } /** @@ -143,9 +143,9 @@ public void testPutOnHeapWithOffHeap() throws Exception { assertEquals(cache.size(CachePeekMode.ALL) - cache.size(CachePeekMode.ONHEAP) - cache.size(CachePeekMode.OFFHEAP), cache.size(CachePeekMode.SWAP)); - assertTrue((MAX_VALS_AMOUNT + 5) * VAL_SIZE > cache.metrics().getOffHeapAllocatedSize()); - assertTrue((MAX_VALS_AMOUNT - 5) * VAL_SIZE < cache.metrics().getOffHeapAllocatedSize()); - assertTrue(cache.metrics().getOffHeapAllocatedSize() >= cache.size(CachePeekMode.OFFHEAP) * VAL_SIZE); + assertTrue((MAX_VALS_AMOUNT + 5) * VAL_SIZE > cache.localMetrics().getOffHeapAllocatedSize()); + assertTrue((MAX_VALS_AMOUNT - 5) * VAL_SIZE < cache.localMetrics().getOffHeapAllocatedSize()); + assertTrue(cache.localMetrics().getOffHeapAllocatedSize() >= cache.size(CachePeekMode.OFFHEAP) * VAL_SIZE); } /** @@ -181,9 +181,9 @@ public void testOnHeapWithOffHeapSwap() throws Exception{ assertTrue(MAX_VALS_AMOUNT >= cache.size(CachePeekMode.OFFHEAP)); assertTrue(MAX_VALS_AMOUNT - 5 <= cache.size(CachePeekMode.OFFHEAP)); - assertTrue((MAX_VALS_AMOUNT + 5) * VAL_SIZE > cache.metrics().getOffHeapAllocatedSize()); - assertTrue((MAX_VALS_AMOUNT - 5) * VAL_SIZE < cache.metrics().getOffHeapAllocatedSize()); - assertTrue(cache.metrics().getOffHeapAllocatedSize() >= cache.size(CachePeekMode.OFFHEAP) * VAL_SIZE); + assertTrue((MAX_VALS_AMOUNT + 5) * VAL_SIZE > cache.localMetrics().getOffHeapAllocatedSize()); + assertTrue((MAX_VALS_AMOUNT - 5) * VAL_SIZE < cache.localMetrics().getOffHeapAllocatedSize()); + assertTrue(cache.localMetrics().getOffHeapAllocatedSize() >= cache.size(CachePeekMode.OFFHEAP) * VAL_SIZE); } /** Fill cache with values. */ diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheTransactionalAbstractMetricsSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheTransactionalAbstractMetricsSelfTest.java index 4bd4c59bea696..b2273645627ba 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheTransactionalAbstractMetricsSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheTransactionalAbstractMetricsSelfTest.java @@ -231,7 +231,7 @@ private void testCommits(TransactionConcurrency concurrency, TransactionIsolatio for (int i = 0; i < gridCount(); i++) { TransactionMetrics metrics = grid(i).transactions().metrics(); - CacheMetrics cacheMetrics = grid(i).cache(null).metrics(); + CacheMetrics cacheMetrics = grid(i).cache(null).localMetrics(); if (i == 0) { assertEquals(TX_CNT, metrics.txCommits()); @@ -276,7 +276,7 @@ private void testRollbacks(TransactionConcurrency concurrency, TransactionIsolat for (int i = 0; i < gridCount(); i++) { TransactionMetrics metrics = grid(i).transactions().metrics(); - CacheMetrics cacheMetrics = grid(i).cache(null).metrics(); + CacheMetrics cacheMetrics = grid(i).cache(null).localMetrics(); assertEquals(0, metrics.txCommits()); assertEquals(0, cacheMetrics.getCacheTxCommits()); diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCacheColocatedDebugTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCacheColocatedDebugTest.java index 463c2c0862cd6..aa7f6fade5f90 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCacheColocatedDebugTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCacheColocatedDebugTest.java @@ -476,7 +476,7 @@ private void checkSinglePut(boolean explicitTx, TransactionConcurrency concurren if (tx != null) tx.commit(); - System.out.println(cache.metrics()); + System.out.println(cache.localMetrics()); assertEquals("Hello", cache.get(1)); assertEquals("World", cache.get(2)); diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCachePartitionedNearDisabledMetricsSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCachePartitionedNearDisabledMetricsSelfTest.java index 3ace98d14847b..16aa72d422ff2 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCachePartitionedNearDisabledMetricsSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridCachePartitionedNearDisabledMetricsSelfTest.java @@ -107,7 +107,7 @@ public void testGettingRemovedKey() throws Exception { long misses = 0; for (int i = 0; i < gridCount(); i++) { - CacheMetrics m = grid(i).cache(null).metrics(); + CacheMetrics m = grid(i).cache(null).localMetrics(); removes += m.getCacheRemovals(); reads += m.getCacheGets(); diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheAtomicPartitionedTckMetricsSelfTestImpl.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheAtomicPartitionedTckMetricsSelfTestImpl.java index d94fe68e6f457..9e4be22d0a540 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheAtomicPartitionedTckMetricsSelfTestImpl.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheAtomicPartitionedTckMetricsSelfTestImpl.java @@ -50,19 +50,19 @@ public void testEntryProcessorRemove() throws Exception { } }); - assertEquals(1L, cache.metrics().getCachePuts()); + assertEquals(1L, cache.localMetrics().getCachePuts()); assertEquals(20, result); - assertEquals(1L, cache.metrics().getCacheHits()); - assertEquals(100.0f, cache.metrics().getCacheHitPercentage()); - assertEquals(0L, cache.metrics().getCacheMisses()); - assertEquals(0f, cache.metrics().getCacheMissPercentage()); - assertEquals(1L, cache.metrics().getCachePuts()); - assertEquals(1L, cache.metrics().getCacheRemovals()); - assertEquals(0L, cache.metrics().getCacheEvictions()); - assert cache.metrics().getAveragePutTime() >= 0; - assert cache.metrics().getAverageGetTime() >= 0; - assert cache.metrics().getAverageRemoveTime() >= 0; + assertEquals(1L, cache.localMetrics().getCacheHits()); + assertEquals(100.0f, cache.localMetrics().getCacheHitPercentage()); + assertEquals(0L, cache.localMetrics().getCacheMisses()); + assertEquals(0f, cache.localMetrics().getCacheMissPercentage()); + assertEquals(1L, cache.localMetrics().getCachePuts()); + assertEquals(1L, cache.localMetrics().getCacheRemovals()); + assertEquals(0L, cache.localMetrics().getCacheEvictions()); + assert cache.localMetrics().getAveragePutTime() >= 0; + assert cache.localMetrics().getAverageGetTime() >= 0; + assert cache.localMetrics().getAverageRemoveTime() >= 0; } /** @@ -73,36 +73,36 @@ public void testCacheStatistics() throws Exception { cache.put(1, 10); - assertEquals(0, cache.metrics().getCacheRemovals()); - assertEquals(1, cache.metrics().getCachePuts()); + assertEquals(0, cache.localMetrics().getCacheRemovals()); + assertEquals(1, cache.localMetrics().getCachePuts()); cache.remove(1); - assertEquals(0, cache.metrics().getCacheHits()); - assertEquals(1, cache.metrics().getCacheRemovals()); - assertEquals(1, cache.metrics().getCachePuts()); + assertEquals(0, cache.localMetrics().getCacheHits()); + assertEquals(1, cache.localMetrics().getCacheRemovals()); + assertEquals(1, cache.localMetrics().getCachePuts()); cache.remove(1); - assertEquals(0, cache.metrics().getCacheHits()); - assertEquals(0, cache.metrics().getCacheMisses()); - assertEquals(1, cache.metrics().getCacheRemovals()); - assertEquals(1, cache.metrics().getCachePuts()); + assertEquals(0, cache.localMetrics().getCacheHits()); + assertEquals(0, cache.localMetrics().getCacheMisses()); + assertEquals(1, cache.localMetrics().getCacheRemovals()); + assertEquals(1, cache.localMetrics().getCachePuts()); cache.put(1, 10); assertTrue(cache.remove(1, 10)); - assertEquals(1, cache.metrics().getCacheHits()); - assertEquals(0, cache.metrics().getCacheMisses()); - assertEquals(2, cache.metrics().getCacheRemovals()); - assertEquals(2, cache.metrics().getCachePuts()); + assertEquals(1, cache.localMetrics().getCacheHits()); + assertEquals(0, cache.localMetrics().getCacheMisses()); + assertEquals(2, cache.localMetrics().getCacheRemovals()); + assertEquals(2, cache.localMetrics().getCachePuts()); assertFalse(cache.remove(1, 10)); - assertEquals(1, cache.metrics().getCacheHits()); - assertEquals(1, cache.metrics().getCacheMisses()); - assertEquals(2, cache.metrics().getCacheRemovals()); - assertEquals(2, cache.metrics().getCachePuts()); + assertEquals(1, cache.localMetrics().getCacheHits()); + assertEquals(1, cache.localMetrics().getCacheMisses()); + assertEquals(2, cache.localMetrics().getCacheRemovals()); + assertEquals(2, cache.localMetrics().getCachePuts()); } /** @@ -120,18 +120,18 @@ public void testConditionReplace() throws Exception { ++missCount; assertFalse(result); - assertEquals(missCount, cache.metrics().getCacheMisses()); - assertEquals(hitCount, cache.metrics().getCacheHits()); - assertEquals(putCount, cache.metrics().getCachePuts()); + assertEquals(missCount, cache.localMetrics().getCacheMisses()); + assertEquals(hitCount, cache.localMetrics().getCacheHits()); + assertEquals(putCount, cache.localMetrics().getCachePuts()); assertNull(cache.localPeek(1)); cache.put(1, 10); ++putCount; - assertEquals(missCount, cache.metrics().getCacheMisses()); - assertEquals(hitCount, cache.metrics().getCacheHits()); - assertEquals(putCount, cache.metrics().getCachePuts()); + assertEquals(missCount, cache.localMetrics().getCacheMisses()); + assertEquals(hitCount, cache.localMetrics().getCacheHits()); + assertEquals(putCount, cache.localMetrics().getCachePuts()); assertNotNull(cache.localPeek(1)); @@ -141,18 +141,18 @@ public void testConditionReplace() throws Exception { ++hitCount; ++putCount; - assertEquals(missCount, cache.metrics().getCacheMisses()); - assertEquals(hitCount, cache.metrics().getCacheHits()); - assertEquals(putCount, cache.metrics().getCachePuts()); + assertEquals(missCount, cache.localMetrics().getCacheMisses()); + assertEquals(hitCount, cache.localMetrics().getCacheHits()); + assertEquals(putCount, cache.localMetrics().getCachePuts()); result = cache.replace(1, 40, 50); assertFalse(result); ++hitCount; - assertEquals(hitCount, cache.metrics().getCacheHits()); - assertEquals(putCount, cache.metrics().getCachePuts()); - assertEquals(missCount, cache.metrics().getCacheMisses()); + assertEquals(hitCount, cache.localMetrics().getCacheHits()); + assertEquals(putCount, cache.localMetrics().getCachePuts()); + assertEquals(missCount, cache.localMetrics().getCacheMisses()); } /** @@ -170,17 +170,17 @@ public void testPutIfAbsent() throws Exception { ++putCount; assertTrue(result); - assertEquals(missCount, cache.metrics().getCacheMisses()); - assertEquals(hitCount, cache.metrics().getCacheHits()); - assertEquals(putCount, cache.metrics().getCachePuts()); + assertEquals(missCount, cache.localMetrics().getCacheMisses()); + assertEquals(hitCount, cache.localMetrics().getCacheHits()); + assertEquals(putCount, cache.localMetrics().getCachePuts()); result = cache.putIfAbsent(1, 1); cache.containsKey(123); assertFalse(result); - assertEquals(hitCount, cache.metrics().getCacheHits()); - assertEquals(putCount, cache.metrics().getCachePuts()); - assertEquals(missCount, cache.metrics().getCacheMisses()); + assertEquals(hitCount, cache.localMetrics().getCacheHits()); + assertEquals(putCount, cache.localMetrics().getCachePuts()); + assertEquals(missCount, cache.localMetrics().getCacheMisses()); } } \ No newline at end of file diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearMetricsSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearMetricsSelfTest.java index 01ed1574b01e8..09ff519a67976 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearMetricsSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCacheNearMetricsSelfTest.java @@ -72,7 +72,7 @@ protected int keyCount() { assert g.cache(null).localSize() == 0; - g.cache(null).mxBean().clear(); + g.cache(null).localMxBean().clear(); } } @@ -116,8 +116,8 @@ public void testPrimaryPut() throws Exception { key = i; - info("Puts: " + cache0.metrics().getCachePuts()); - info("Reads: " + cache0.metrics().getCacheGets()); + info("Puts: " + cache0.localMetrics().getCachePuts()); + info("Reads: " + cache0.localMetrics().getCacheGets()); info("Affinity nodes: " + U.nodes2names(affinity(cache0).mapKeyToPrimaryAndBackups(i))); break; @@ -131,23 +131,23 @@ public void testPrimaryPut() throws Exception { IgniteCache jcache = g.cache(null); - info("Puts: " + jcache.metrics().getCachePuts()); - info("Reads: " + jcache.metrics().getCacheGets()); + info("Puts: " + jcache.localMetrics().getCachePuts()); + info("Reads: " + jcache.localMetrics().getCacheGets()); if (affinity(jcache).isPrimaryOrBackup(g.cluster().localNode(), key)) - assertEquals(1, jcache.metrics().getCachePuts()); + assertEquals(1, jcache.localMetrics().getCachePuts()); else - assertEquals(0, jcache.metrics().getCachePuts()); + assertEquals(0, jcache.localMetrics().getCachePuts()); if (affinity(jcache).isPrimary(g.cluster().localNode(), key)) { - assertEquals(2, jcache.metrics().getCacheGets()); - assertEquals(1, jcache.metrics().getCacheHits()); - assertEquals(1, jcache.metrics().getCacheMisses()); + assertEquals(2, jcache.localMetrics().getCacheGets()); + assertEquals(1, jcache.localMetrics().getCacheHits()); + assertEquals(1, jcache.localMetrics().getCacheMisses()); } else { - assertEquals(0, jcache.metrics().getCacheGets()); - assertEquals(0, jcache.metrics().getCacheHits()); - assertEquals(0, jcache.metrics().getCacheMisses()); + assertEquals(0, jcache.localMetrics().getCacheGets()); + assertEquals(0, jcache.localMetrics().getCacheHits()); + assertEquals(0, jcache.localMetrics().getCacheMisses()); } } } @@ -171,8 +171,8 @@ public void testBackupPut() throws Exception { key = i; - info("Puts: " + cache0.metrics().getCachePuts()); - info("Reads: " + cache0.metrics().getCacheGets()); + info("Puts: " + cache0.localMetrics().getCachePuts()); + info("Reads: " + cache0.localMetrics().getCacheGets()); info("Affinity nodes: " + U.nodes2names(affinity(cache0).mapKeyToPrimaryAndBackups(i))); break; @@ -184,24 +184,24 @@ public void testBackupPut() throws Exception { IgniteCache jcache = g.cache(null); if (affinity(jcache).isPrimaryOrBackup(g.cluster().localNode(), key)) - assertEquals(1, jcache.metrics().getCachePuts()); + assertEquals(1, jcache.localMetrics().getCachePuts()); else - assertEquals(0, jcache.metrics().getCachePuts()); + assertEquals(0, jcache.localMetrics().getCachePuts()); if (affinity(jcache).isPrimary(g.cluster().localNode(), key)) { - assertEquals(1, jcache.metrics().getCacheGets()); - assertEquals(0, jcache.metrics().getCacheHits()); - assertEquals(1, jcache.metrics().getCacheMisses()); + assertEquals(1, jcache.localMetrics().getCacheGets()); + assertEquals(0, jcache.localMetrics().getCacheHits()); + assertEquals(1, jcache.localMetrics().getCacheMisses()); } else if (affinity(jcache).isBackup(g.cluster().localNode(), key)){ - assertEquals(1, jcache.metrics().getCacheGets()); - assertEquals(1, jcache.metrics().getCacheHits()); - assertEquals(0, jcache.metrics().getCacheMisses()); + assertEquals(1, jcache.localMetrics().getCacheGets()); + assertEquals(1, jcache.localMetrics().getCacheHits()); + assertEquals(0, jcache.localMetrics().getCacheMisses()); } else { - assertEquals(0, jcache.metrics().getCacheGets()); - assertEquals(0, jcache.metrics().getCacheHits()); - assertEquals(0, jcache.metrics().getCacheMisses()); + assertEquals(0, jcache.localMetrics().getCacheGets()); + assertEquals(0, jcache.localMetrics().getCacheHits()); + assertEquals(0, jcache.localMetrics().getCacheMisses()); } } } @@ -225,8 +225,8 @@ public void testNearPut() throws Exception { key = i; - info("Writes: " + cache0.metrics().getCachePuts()); - info("Reads: " + cache0.metrics().getCacheGets()); + info("Writes: " + cache0.localMetrics().getCachePuts()); + info("Reads: " + cache0.localMetrics().getCacheGets()); info("Affinity nodes: " + U.nodes2names(affinity(cache0).mapKeyToPrimaryAndBackups(i))); break; @@ -238,22 +238,22 @@ public void testNearPut() throws Exception { IgniteCache jcache = g.cache(null); - assertEquals(1, jcache.metrics().getCachePuts()); + assertEquals(1, jcache.localMetrics().getCachePuts()); if (affinity(jcache).isPrimary(g.cluster().localNode(), key)) { - assertEquals(1, jcache.metrics().getCacheGets()); - assertEquals(0, jcache.metrics().getCacheHits()); - assertEquals(1, jcache.metrics().getCacheMisses()); + assertEquals(1, jcache.localMetrics().getCacheGets()); + assertEquals(0, jcache.localMetrics().getCacheHits()); + assertEquals(1, jcache.localMetrics().getCacheMisses()); } else if (affinity(jcache).isBackup(g.cluster().localNode(), key)){ - assertEquals(0, jcache.metrics().getCacheGets()); - assertEquals(0, jcache.metrics().getCacheHits()); - assertEquals(0, jcache.metrics().getCacheMisses()); + assertEquals(0, jcache.localMetrics().getCacheGets()); + assertEquals(0, jcache.localMetrics().getCacheHits()); + assertEquals(0, jcache.localMetrics().getCacheMisses()); } else { - assertEquals(1, jcache.metrics().getCacheGets()); - assertEquals(1, jcache.metrics().getCacheHits()); - assertEquals(0, jcache.metrics().getCacheMisses()); + assertEquals(1, jcache.localMetrics().getCacheGets()); + assertEquals(1, jcache.localMetrics().getCacheHits()); + assertEquals(0, jcache.localMetrics().getCacheMisses()); } } } @@ -275,14 +275,14 @@ public void testPrimaryRead() throws Exception { key = i; - info("Writes: " + cache0.metrics().getCachePuts()); - info("Reads: " + cache0.metrics().getCacheGets()); + info("Writes: " + cache0.localMetrics().getCachePuts()); + info("Reads: " + cache0.localMetrics().getCacheGets()); info("Affinity nodes: " + U.nodes2names(affinity(cache0).mapKeyToPrimaryAndBackups(i))); cache0.get(i); // +1 read. - info("Writes: " + cache0.metrics().getCachePuts()); - info("Reads: " + cache0.metrics().getCacheGets()); + info("Writes: " + cache0.localMetrics().getCachePuts()); + info("Reads: " + cache0.localMetrics().getCacheGets()); info("Affinity nodes: " + U.nodes2names(affinity(cache0).mapKeyToPrimaryAndBackups(i))); break; @@ -296,20 +296,20 @@ public void testPrimaryRead() throws Exception { IgniteCache jcache = g.cache(null); - info("Writes: " + jcache.metrics().getCachePuts()); - info("Reads: " + jcache.metrics().getCacheGets()); + info("Writes: " + jcache.localMetrics().getCachePuts()); + info("Reads: " + jcache.localMetrics().getCacheGets()); - assertEquals(0, jcache.metrics().getCachePuts()); + assertEquals(0, jcache.localMetrics().getCachePuts()); if (affinity(jcache).isPrimary(g.cluster().localNode(), key)) { - assertEquals(2, jcache.metrics().getCacheGets()); - assertEquals(0, jcache.metrics().getCacheHits()); - assertEquals(2, jcache.metrics().getCacheMisses()); + assertEquals(2, jcache.localMetrics().getCacheGets()); + assertEquals(0, jcache.localMetrics().getCacheHits()); + assertEquals(2, jcache.localMetrics().getCacheMisses()); } else { - assertEquals(0, jcache.metrics().getCacheGets()); - assertEquals(0, jcache.metrics().getCacheHits()); - assertEquals(0, jcache.metrics().getCacheMisses()); + assertEquals(0, jcache.localMetrics().getCacheGets()); + assertEquals(0, jcache.localMetrics().getCacheHits()); + assertEquals(0, jcache.localMetrics().getCacheMisses()); } } } @@ -331,14 +331,14 @@ public void testBackupRead() throws Exception { key = i; - info("Writes: " + cache0.metrics().getCachePuts()); - info("Reads: " + cache0.metrics().getCacheGets()); + info("Writes: " + cache0.localMetrics().getCachePuts()); + info("Reads: " + cache0.localMetrics().getCacheGets()); info("Affinity nodes: " + U.nodes2names(affinity(cache0).mapKeyToPrimaryAndBackups(i))); cache0.get(i); // +1 read. - info("Writes: " + cache0.metrics().getCachePuts()); - info("Reads: " + cache0.metrics().getCacheGets()); + info("Writes: " + cache0.localMetrics().getCachePuts()); + info("Reads: " + cache0.localMetrics().getCacheGets()); info("Affinity nodes: " + U.nodes2names(affinity(cache0).mapKeyToPrimaryAndBackups(i))); break; @@ -350,17 +350,17 @@ public void testBackupRead() throws Exception { IgniteCache jcache = g.cache(null); - assertEquals(0, jcache.metrics().getCachePuts()); + assertEquals(0, jcache.localMetrics().getCachePuts()); if (affinity(jcache).isPrimaryOrBackup(g.cluster().localNode(), key)) { - assertEquals(2, jcache.metrics().getCacheGets()); - assertEquals(0, jcache.metrics().getCacheHits()); - assertEquals(2, jcache.metrics().getCacheMisses()); + assertEquals(2, jcache.localMetrics().getCacheGets()); + assertEquals(0, jcache.localMetrics().getCacheHits()); + assertEquals(2, jcache.localMetrics().getCacheMisses()); } else { - assertEquals(0, jcache.metrics().getCacheGets()); - assertEquals(0, jcache.metrics().getCacheHits()); - assertEquals(0, jcache.metrics().getCacheMisses()); + assertEquals(0, jcache.localMetrics().getCacheGets()); + assertEquals(0, jcache.localMetrics().getCacheHits()); + assertEquals(0, jcache.localMetrics().getCacheMisses()); } } } @@ -383,10 +383,10 @@ public void testNearRead() throws Exception { key = i; - info("Writes: " + cache0.metrics().getCachePuts()); - info("Reads: " + cache0.metrics().getCacheGets()); - info("Hits: " + cache0.metrics().getCacheHits()); - info("Misses: " + cache0.metrics().getCacheMisses()); + info("Writes: " + cache0.localMetrics().getCachePuts()); + info("Reads: " + cache0.localMetrics().getCacheGets()); + info("Hits: " + cache0.localMetrics().getCacheHits()); + info("Misses: " + cache0.localMetrics().getCacheMisses()); info("Affinity nodes: " + U.nodes2names(affinity(cache0).mapKeyToPrimaryAndBackups(i))); break; @@ -398,22 +398,22 @@ public void testNearRead() throws Exception { IgniteCache jcache = g.cache(null); - assertEquals(0, jcache.metrics().getCachePuts()); + assertEquals(0, jcache.localMetrics().getCachePuts()); if (affinity(jcache).isPrimary(g.cluster().localNode(), key)) { - assertEquals(2, jcache.metrics().getCacheGets()); - assertEquals(0, jcache.metrics().getCacheHits()); - assertEquals(2, jcache.metrics().getCacheMisses()); + assertEquals(2, jcache.localMetrics().getCacheGets()); + assertEquals(0, jcache.localMetrics().getCacheHits()); + assertEquals(2, jcache.localMetrics().getCacheMisses()); } else if (affinity(jcache).isBackup(g.cluster().localNode(), key)){ - assertEquals(0, jcache.metrics().getCacheGets()); - assertEquals(0, jcache.metrics().getCacheHits()); - assertEquals(0, jcache.metrics().getCacheMisses()); + assertEquals(0, jcache.localMetrics().getCacheGets()); + assertEquals(0, jcache.localMetrics().getCacheHits()); + assertEquals(0, jcache.localMetrics().getCacheMisses()); } else { - assertEquals(2, jcache.metrics().getCacheGets()); - assertEquals(0, jcache.metrics().getCacheHits()); - assertEquals(2, jcache.metrics().getCacheMisses()); + assertEquals(2, jcache.localMetrics().getCacheGets()); + assertEquals(0, jcache.localMetrics().getCacheHits()); + assertEquals(2, jcache.localMetrics().getCacheMisses()); } } } diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCachePartitionedHitsAndMissesSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCachePartitionedHitsAndMissesSelfTest.java index 02eb9d882641e..16faa458b1cd0 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCachePartitionedHitsAndMissesSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/near/GridCachePartitionedHitsAndMissesSelfTest.java @@ -114,7 +114,7 @@ public void testHitsAndMisses() throws Exception { long misses = 0; for (int i = 0; i < GRID_CNT; i++) { - CacheMetrics m = grid(i).cache(null).metrics(); + CacheMetrics m = grid(i).cache(null).localMetrics(); hits += m.getCacheHits(); misses += m.getCacheMisses(); diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/local/CacheLocalOffHeapAndSwapMetricsSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/local/CacheLocalOffHeapAndSwapMetricsSelfTest.java index b638236089f89..15ac96eebe74e 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/local/CacheLocalOffHeapAndSwapMetricsSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/local/CacheLocalOffHeapAndSwapMetricsSelfTest.java @@ -113,74 +113,74 @@ public void testOffHeapMetrics() throws Exception { printStat(); - assertEquals(cache.metrics().getCacheEvictions(), cache.metrics().getOffHeapPuts()); - assertEquals(KEYS_CNT, cache.metrics().getOffHeapGets()); - assertEquals(0, cache.metrics().getOffHeapHits()); - assertEquals(0f, cache.metrics().getOffHeapHitPercentage()); - assertEquals(KEYS_CNT, cache.metrics().getOffHeapMisses()); - assertEquals(100f, cache.metrics().getOffHeapMissPercentage()); - assertEquals(0, cache.metrics().getOffHeapRemovals()); - - assertEquals(0, cache.metrics().getOffHeapEvictions()); - assertEquals(cache.metrics().getCacheEvictions(), cache.metrics().getOffHeapEntriesCount()); - assertEquals(cache.metrics().getCacheEvictions(), cache.metrics().getOffHeapPrimaryEntriesCount()); - assertEquals(0, cache.metrics().getOffHeapBackupEntriesCount()); + assertEquals(cache.localMetrics().getCacheEvictions(), cache.localMetrics().getOffHeapPuts()); + assertEquals(KEYS_CNT, cache.localMetrics().getOffHeapGets()); + assertEquals(0, cache.localMetrics().getOffHeapHits()); + assertEquals(0f, cache.localMetrics().getOffHeapHitPercentage()); + assertEquals(KEYS_CNT, cache.localMetrics().getOffHeapMisses()); + assertEquals(100f, cache.localMetrics().getOffHeapMissPercentage()); + assertEquals(0, cache.localMetrics().getOffHeapRemovals()); + + assertEquals(0, cache.localMetrics().getOffHeapEvictions()); + assertEquals(cache.localMetrics().getCacheEvictions(), cache.localMetrics().getOffHeapEntriesCount()); + assertEquals(cache.localMetrics().getCacheEvictions(), cache.localMetrics().getOffHeapPrimaryEntriesCount()); + assertEquals(0, cache.localMetrics().getOffHeapBackupEntriesCount()); for (int i = 0; i < KEYS_CNT; i++) cache.get(i); printStat(); - assertEquals(cache.metrics().getCacheEvictions(), cache.metrics().getOffHeapPuts()); - assertEquals(KEYS_CNT * 2, cache.metrics().getOffHeapGets()); - assertEquals(KEYS_CNT, cache.metrics().getOffHeapHits()); - assertEquals(100 * KEYS_CNT / (KEYS_CNT * 2.0), cache.metrics().getOffHeapHitPercentage(), 0.1); - assertEquals(KEYS_CNT, cache.metrics().getOffHeapMisses()); - assertEquals(100 * KEYS_CNT / (KEYS_CNT * 2.0), cache.metrics().getOffHeapMissPercentage(), 0.1); - assertEquals(KEYS_CNT, cache.metrics().getOffHeapRemovals()); + assertEquals(cache.localMetrics().getCacheEvictions(), cache.localMetrics().getOffHeapPuts()); + assertEquals(KEYS_CNT * 2, cache.localMetrics().getOffHeapGets()); + assertEquals(KEYS_CNT, cache.localMetrics().getOffHeapHits()); + assertEquals(100 * KEYS_CNT / (KEYS_CNT * 2.0), cache.localMetrics().getOffHeapHitPercentage(), 0.1); + assertEquals(KEYS_CNT, cache.localMetrics().getOffHeapMisses()); + assertEquals(100 * KEYS_CNT / (KEYS_CNT * 2.0), cache.localMetrics().getOffHeapMissPercentage(), 0.1); + assertEquals(KEYS_CNT, cache.localMetrics().getOffHeapRemovals()); - assertEquals(0, cache.metrics().getOffHeapEvictions()); - assertEquals(KEYS_CNT - MAX_SIZE, cache.metrics().getOffHeapEntriesCount()); - assertEquals(KEYS_CNT - MAX_SIZE, cache.metrics().getOffHeapPrimaryEntriesCount()); - assertEquals(0, cache.metrics().getOffHeapBackupEntriesCount()); + assertEquals(0, cache.localMetrics().getOffHeapEvictions()); + assertEquals(KEYS_CNT - MAX_SIZE, cache.localMetrics().getOffHeapEntriesCount()); + assertEquals(KEYS_CNT - MAX_SIZE, cache.localMetrics().getOffHeapPrimaryEntriesCount()); + assertEquals(0, cache.localMetrics().getOffHeapBackupEntriesCount()); for (int i = KEYS_CNT; i < KEYS_CNT * 2; i++) cache.get(i); printStat(); - assertEquals(cache.metrics().getCacheEvictions(), cache.metrics().getOffHeapPuts()); - assertEquals(KEYS_CNT * 3, cache.metrics().getOffHeapGets()); - assertEquals(KEYS_CNT, cache.metrics().getOffHeapHits()); - assertEquals(100 / 3.0, cache.metrics().getOffHeapHitPercentage(), 0.1); - assertEquals(KEYS_CNT * 2, cache.metrics().getOffHeapMisses()); - assertEquals(100 - (100 / 3.0), cache.metrics().getOffHeapMissPercentage(), 0.1); - assertEquals(KEYS_CNT, cache.metrics().getOffHeapRemovals()); + assertEquals(cache.localMetrics().getCacheEvictions(), cache.localMetrics().getOffHeapPuts()); + assertEquals(KEYS_CNT * 3, cache.localMetrics().getOffHeapGets()); + assertEquals(KEYS_CNT, cache.localMetrics().getOffHeapHits()); + assertEquals(100 / 3.0, cache.localMetrics().getOffHeapHitPercentage(), 0.1); + assertEquals(KEYS_CNT * 2, cache.localMetrics().getOffHeapMisses()); + assertEquals(100 - (100 / 3.0), cache.localMetrics().getOffHeapMissPercentage(), 0.1); + assertEquals(KEYS_CNT, cache.localMetrics().getOffHeapRemovals()); - assertEquals(0, cache.metrics().getOffHeapEvictions()); - assertEquals(KEYS_CNT - MAX_SIZE, cache.metrics().getOffHeapEntriesCount()); - assertEquals(KEYS_CNT - MAX_SIZE, cache.metrics().getOffHeapPrimaryEntriesCount()); - assertEquals(0, cache.metrics().getOffHeapBackupEntriesCount()); + assertEquals(0, cache.localMetrics().getOffHeapEvictions()); + assertEquals(KEYS_CNT - MAX_SIZE, cache.localMetrics().getOffHeapEntriesCount()); + assertEquals(KEYS_CNT - MAX_SIZE, cache.localMetrics().getOffHeapPrimaryEntriesCount()); + assertEquals(0, cache.localMetrics().getOffHeapBackupEntriesCount()); for (int i = 0; i < KEYS_CNT; i++) cache.remove(i); printStat(); - assertEquals(cache.metrics().getCacheEvictions(), cache.metrics().getOffHeapPuts()); - assertEquals(KEYS_CNT * 4 - MAX_SIZE, cache.metrics().getOffHeapGets()); - assertEquals(KEYS_CNT * 2 - MAX_SIZE, cache.metrics().getOffHeapHits()); + assertEquals(cache.localMetrics().getCacheEvictions(), cache.localMetrics().getOffHeapPuts()); + assertEquals(KEYS_CNT * 4 - MAX_SIZE, cache.localMetrics().getOffHeapGets()); + assertEquals(KEYS_CNT * 2 - MAX_SIZE, cache.localMetrics().getOffHeapHits()); assertEquals(100 * (KEYS_CNT * 2.0 - MAX_SIZE) / (KEYS_CNT * 4.0 - MAX_SIZE), - cache.metrics().getOffHeapHitPercentage(), 0.1); - assertEquals(KEYS_CNT * 2, cache.metrics().getOffHeapMisses()); + cache.localMetrics().getOffHeapHitPercentage(), 0.1); + assertEquals(KEYS_CNT * 2, cache.localMetrics().getOffHeapMisses()); assertEquals(100 * KEYS_CNT * 2.0 / (KEYS_CNT * 4.0 - MAX_SIZE), - cache.metrics().getOffHeapMissPercentage(), 0.1); - assertEquals(KEYS_CNT * 2 - MAX_SIZE, cache.metrics().getOffHeapRemovals()); + cache.localMetrics().getOffHeapMissPercentage(), 0.1); + assertEquals(KEYS_CNT * 2 - MAX_SIZE, cache.localMetrics().getOffHeapRemovals()); - assertEquals(0, cache.metrics().getOffHeapEvictions()); - assertEquals(0, cache.metrics().getOffHeapEntriesCount()); - assertEquals(0, cache.metrics().getOffHeapPrimaryEntriesCount()); - assertEquals(0, cache.metrics().getOffHeapBackupEntriesCount()); + assertEquals(0, cache.localMetrics().getOffHeapEvictions()); + assertEquals(0, cache.localMetrics().getOffHeapEntriesCount()); + assertEquals(0, cache.localMetrics().getOffHeapPrimaryEntriesCount()); + assertEquals(0, cache.localMetrics().getOffHeapBackupEntriesCount()); } /** @@ -194,62 +194,62 @@ public void testSwapMetrics() throws Exception { printStat(); - assertEquals(cache.metrics().getCacheEvictions(), cache.metrics().getSwapPuts()); - assertEquals(KEYS_CNT, cache.metrics().getSwapGets()); - assertEquals(0, cache.metrics().getSwapHits()); - assertEquals(0f, cache.metrics().getSwapHitPercentage()); - assertEquals(KEYS_CNT, cache.metrics().getSwapMisses()); - assertEquals(100f, cache.metrics().getSwapMissPercentage()); - assertEquals(0, cache.metrics().getSwapRemovals()); + assertEquals(cache.localMetrics().getCacheEvictions(), cache.localMetrics().getSwapPuts()); + assertEquals(KEYS_CNT, cache.localMetrics().getSwapGets()); + assertEquals(0, cache.localMetrics().getSwapHits()); + assertEquals(0f, cache.localMetrics().getSwapHitPercentage()); + assertEquals(KEYS_CNT, cache.localMetrics().getSwapMisses()); + assertEquals(100f, cache.localMetrics().getSwapMissPercentage()); + assertEquals(0, cache.localMetrics().getSwapRemovals()); - assertEquals(cache.metrics().getCacheEvictions(), cache.metrics().getSwapEntriesCount()); + assertEquals(cache.localMetrics().getCacheEvictions(), cache.localMetrics().getSwapEntriesCount()); for (int i = 0; i < KEYS_CNT; i++) cache.get(i); printStat(); - assertEquals(cache.metrics().getCacheEvictions(), cache.metrics().getSwapPuts()); - assertEquals(KEYS_CNT * 2, cache.metrics().getSwapGets()); - assertEquals(KEYS_CNT, cache.metrics().getSwapHits()); - assertEquals(100 * KEYS_CNT / (KEYS_CNT * 2.0), cache.metrics().getSwapHitPercentage(), 0.1); - assertEquals(KEYS_CNT, cache.metrics().getSwapMisses()); - assertEquals(100 * KEYS_CNT / (KEYS_CNT * 2.0), cache.metrics().getSwapMissPercentage(), 0.1); - assertEquals(KEYS_CNT, cache.metrics().getSwapRemovals()); + assertEquals(cache.localMetrics().getCacheEvictions(), cache.localMetrics().getSwapPuts()); + assertEquals(KEYS_CNT * 2, cache.localMetrics().getSwapGets()); + assertEquals(KEYS_CNT, cache.localMetrics().getSwapHits()); + assertEquals(100 * KEYS_CNT / (KEYS_CNT * 2.0), cache.localMetrics().getSwapHitPercentage(), 0.1); + assertEquals(KEYS_CNT, cache.localMetrics().getSwapMisses()); + assertEquals(100 * KEYS_CNT / (KEYS_CNT * 2.0), cache.localMetrics().getSwapMissPercentage(), 0.1); + assertEquals(KEYS_CNT, cache.localMetrics().getSwapRemovals()); - assertEquals(KEYS_CNT - MAX_SIZE, cache.metrics().getSwapEntriesCount()); + assertEquals(KEYS_CNT - MAX_SIZE, cache.localMetrics().getSwapEntriesCount()); for (int i = KEYS_CNT; i < KEYS_CNT * 2; i++) cache.get(i); printStat(); - assertEquals(cache.metrics().getCacheEvictions(), cache.metrics().getSwapPuts()); - assertEquals(KEYS_CNT * 3, cache.metrics().getSwapGets()); - assertEquals(KEYS_CNT, cache.metrics().getSwapHits()); - assertEquals(100 / 3.0, cache.metrics().getSwapHitPercentage(), 0.1); - assertEquals(KEYS_CNT * 2, cache.metrics().getSwapMisses()); - assertEquals(100 - (100 / 3.0), cache.metrics().getSwapMissPercentage(), 0.1); - assertEquals(KEYS_CNT, cache.metrics().getSwapRemovals()); + assertEquals(cache.localMetrics().getCacheEvictions(), cache.localMetrics().getSwapPuts()); + assertEquals(KEYS_CNT * 3, cache.localMetrics().getSwapGets()); + assertEquals(KEYS_CNT, cache.localMetrics().getSwapHits()); + assertEquals(100 / 3.0, cache.localMetrics().getSwapHitPercentage(), 0.1); + assertEquals(KEYS_CNT * 2, cache.localMetrics().getSwapMisses()); + assertEquals(100 - (100 / 3.0), cache.localMetrics().getSwapMissPercentage(), 0.1); + assertEquals(KEYS_CNT, cache.localMetrics().getSwapRemovals()); - assertEquals(KEYS_CNT - MAX_SIZE, cache.metrics().getSwapEntriesCount()); + assertEquals(KEYS_CNT - MAX_SIZE, cache.localMetrics().getSwapEntriesCount()); for (int i = 0; i < KEYS_CNT; i++) cache.remove(i); printStat(); - assertEquals(cache.metrics().getCacheEvictions(), cache.metrics().getSwapPuts()); - assertEquals(KEYS_CNT * 4 - MAX_SIZE, cache.metrics().getSwapGets()); - assertEquals(KEYS_CNT * 2 - MAX_SIZE, cache.metrics().getSwapHits()); + assertEquals(cache.localMetrics().getCacheEvictions(), cache.localMetrics().getSwapPuts()); + assertEquals(KEYS_CNT * 4 - MAX_SIZE, cache.localMetrics().getSwapGets()); + assertEquals(KEYS_CNT * 2 - MAX_SIZE, cache.localMetrics().getSwapHits()); assertEquals(100 * (KEYS_CNT * 2.0 - MAX_SIZE) / (KEYS_CNT * 4.0 - MAX_SIZE), - cache.metrics().getSwapHitPercentage(), 0.1); - assertEquals(KEYS_CNT * 2, cache.metrics().getSwapMisses()); + cache.localMetrics().getSwapHitPercentage(), 0.1); + assertEquals(KEYS_CNT * 2, cache.localMetrics().getSwapMisses()); assertEquals(100 * KEYS_CNT * 2.0 / (KEYS_CNT * 4.0 - MAX_SIZE), - cache.metrics().getSwapMissPercentage(), 0.1); - assertEquals(KEYS_CNT * 2 - MAX_SIZE, cache.metrics().getSwapRemovals()); + cache.localMetrics().getSwapMissPercentage(), 0.1); + assertEquals(KEYS_CNT * 2 - MAX_SIZE, cache.localMetrics().getSwapRemovals()); - assertEquals(0, cache.metrics().getSwapEntriesCount()); + assertEquals(0, cache.localMetrics().getSwapEntriesCount()); } /** @@ -263,116 +263,116 @@ public void testOffHeapAndSwapMetrics() throws Exception { printStat(); - assertEquals(cache.metrics().getCacheEvictions(), cache.metrics().getOffHeapPuts()); - assertEquals(KEYS_CNT, cache.metrics().getOffHeapGets()); - assertEquals(0, cache.metrics().getOffHeapHits()); - assertEquals(0f, cache.metrics().getOffHeapHitPercentage()); - assertEquals(KEYS_CNT, cache.metrics().getOffHeapMisses()); - assertEquals(100f, cache.metrics().getOffHeapMissPercentage()); - assertEquals(0, cache.metrics().getOffHeapRemovals()); - - assertEquals(KEYS_CNT - MAX_SIZE - OFFHEAP_MAX_CNT, cache.metrics().getOffHeapEvictions()); - assertEquals(OFFHEAP_MAX_CNT, cache.metrics().getOffHeapEntriesCount()); - assertEquals(OFFHEAP_MAX_CNT, cache.metrics().getOffHeapPrimaryEntriesCount()); - assertEquals(0, cache.metrics().getOffHeapBackupEntriesCount()); - - assertEquals(cache.metrics().getOffHeapEvictions(), cache.metrics().getSwapPuts()); - assertEquals(KEYS_CNT, cache.metrics().getSwapGets()); - assertEquals(0, cache.metrics().getSwapHits()); - assertEquals(0f, cache.metrics().getSwapHitPercentage()); - assertEquals(KEYS_CNT, cache.metrics().getSwapMisses()); - assertEquals(100f, cache.metrics().getSwapMissPercentage()); - assertEquals(0, cache.metrics().getSwapRemovals()); - - assertEquals(cache.metrics().getOffHeapEvictions(), cache.metrics().getSwapEntriesCount()); + assertEquals(cache.localMetrics().getCacheEvictions(), cache.localMetrics().getOffHeapPuts()); + assertEquals(KEYS_CNT, cache.localMetrics().getOffHeapGets()); + assertEquals(0, cache.localMetrics().getOffHeapHits()); + assertEquals(0f, cache.localMetrics().getOffHeapHitPercentage()); + assertEquals(KEYS_CNT, cache.localMetrics().getOffHeapMisses()); + assertEquals(100f, cache.localMetrics().getOffHeapMissPercentage()); + assertEquals(0, cache.localMetrics().getOffHeapRemovals()); + + assertEquals(KEYS_CNT - MAX_SIZE - OFFHEAP_MAX_CNT, cache.localMetrics().getOffHeapEvictions()); + assertEquals(OFFHEAP_MAX_CNT, cache.localMetrics().getOffHeapEntriesCount()); + assertEquals(OFFHEAP_MAX_CNT, cache.localMetrics().getOffHeapPrimaryEntriesCount()); + assertEquals(0, cache.localMetrics().getOffHeapBackupEntriesCount()); + + assertEquals(cache.localMetrics().getOffHeapEvictions(), cache.localMetrics().getSwapPuts()); + assertEquals(KEYS_CNT, cache.localMetrics().getSwapGets()); + assertEquals(0, cache.localMetrics().getSwapHits()); + assertEquals(0f, cache.localMetrics().getSwapHitPercentage()); + assertEquals(KEYS_CNT, cache.localMetrics().getSwapMisses()); + assertEquals(100f, cache.localMetrics().getSwapMissPercentage()); + assertEquals(0, cache.localMetrics().getSwapRemovals()); + + assertEquals(cache.localMetrics().getOffHeapEvictions(), cache.localMetrics().getSwapEntriesCount()); for (int i = 0; i < KEYS_CNT; i++) cache.get(i); printStat(); - assertEquals(cache.metrics().getCacheEvictions(), cache.metrics().getOffHeapPuts()); - assertEquals(KEYS_CNT * 2, cache.metrics().getOffHeapGets()); - assertEquals(0, cache.metrics().getOffHeapHits()); - assertEquals(0.0, cache.metrics().getOffHeapHitPercentage(), 0.1); - assertEquals(KEYS_CNT * 2, cache.metrics().getOffHeapMisses()); - assertEquals(100.0, cache.metrics().getOffHeapMissPercentage(), 0.1); - assertEquals(0, cache.metrics().getOffHeapRemovals()); - - assertEquals(cache.metrics().getCacheEvictions() - OFFHEAP_MAX_CNT, cache.metrics().getOffHeapEvictions()); - assertEquals(OFFHEAP_MAX_CNT, cache.metrics().getOffHeapEntriesCount()); - assertEquals(OFFHEAP_MAX_CNT, cache.metrics().getOffHeapPrimaryEntriesCount()); - assertEquals(0, cache.metrics().getOffHeapBackupEntriesCount()); - - assertEquals(cache.metrics().getOffHeapEvictions(), cache.metrics().getSwapPuts()); - assertEquals(KEYS_CNT * 2, cache.metrics().getSwapGets()); - assertEquals(KEYS_CNT, cache.metrics().getSwapHits()); - assertEquals(100 * KEYS_CNT / (KEYS_CNT * 2.0), cache.metrics().getSwapHitPercentage(), 0.1); - assertEquals(KEYS_CNT, cache.metrics().getSwapMisses()); - assertEquals(100 * KEYS_CNT / (KEYS_CNT * 2.0), cache.metrics().getSwapMissPercentage(), 0.1); - assertEquals(KEYS_CNT, cache.metrics().getSwapRemovals()); - - assertEquals(KEYS_CNT - MAX_SIZE - OFFHEAP_MAX_CNT, cache.metrics().getSwapEntriesCount()); + assertEquals(cache.localMetrics().getCacheEvictions(), cache.localMetrics().getOffHeapPuts()); + assertEquals(KEYS_CNT * 2, cache.localMetrics().getOffHeapGets()); + assertEquals(0, cache.localMetrics().getOffHeapHits()); + assertEquals(0.0, cache.localMetrics().getOffHeapHitPercentage(), 0.1); + assertEquals(KEYS_CNT * 2, cache.localMetrics().getOffHeapMisses()); + assertEquals(100.0, cache.localMetrics().getOffHeapMissPercentage(), 0.1); + assertEquals(0, cache.localMetrics().getOffHeapRemovals()); + + assertEquals(cache.localMetrics().getCacheEvictions() - OFFHEAP_MAX_CNT, cache.localMetrics().getOffHeapEvictions()); + assertEquals(OFFHEAP_MAX_CNT, cache.localMetrics().getOffHeapEntriesCount()); + assertEquals(OFFHEAP_MAX_CNT, cache.localMetrics().getOffHeapPrimaryEntriesCount()); + assertEquals(0, cache.localMetrics().getOffHeapBackupEntriesCount()); + + assertEquals(cache.localMetrics().getOffHeapEvictions(), cache.localMetrics().getSwapPuts()); + assertEquals(KEYS_CNT * 2, cache.localMetrics().getSwapGets()); + assertEquals(KEYS_CNT, cache.localMetrics().getSwapHits()); + assertEquals(100 * KEYS_CNT / (KEYS_CNT * 2.0), cache.localMetrics().getSwapHitPercentage(), 0.1); + assertEquals(KEYS_CNT, cache.localMetrics().getSwapMisses()); + assertEquals(100 * KEYS_CNT / (KEYS_CNT * 2.0), cache.localMetrics().getSwapMissPercentage(), 0.1); + assertEquals(KEYS_CNT, cache.localMetrics().getSwapRemovals()); + + assertEquals(KEYS_CNT - MAX_SIZE - OFFHEAP_MAX_CNT, cache.localMetrics().getSwapEntriesCount()); for (int i = KEYS_CNT; i < KEYS_CNT * 2; i++) cache.get(i); printStat(); - assertEquals(cache.metrics().getCacheEvictions(), cache.metrics().getOffHeapPuts()); - assertEquals(KEYS_CNT * 3, cache.metrics().getOffHeapGets()); - assertEquals(0, cache.metrics().getOffHeapHits()); - assertEquals(0.0, cache.metrics().getOffHeapHitPercentage(), 0.1); - assertEquals(KEYS_CNT * 3, cache.metrics().getOffHeapMisses()); - assertEquals(100.0, cache.metrics().getOffHeapMissPercentage(), 0.1); - assertEquals(0, cache.metrics().getOffHeapRemovals()); - - assertEquals(cache.metrics().getCacheEvictions() - OFFHEAP_MAX_CNT, cache.metrics().getOffHeapEvictions()); - assertEquals(OFFHEAP_MAX_CNT, cache.metrics().getOffHeapEntriesCount()); - assertEquals(OFFHEAP_MAX_CNT, cache.metrics().getOffHeapPrimaryEntriesCount()); - assertEquals(0, cache.metrics().getOffHeapBackupEntriesCount()); - - assertEquals(cache.metrics().getOffHeapEvictions(), cache.metrics().getSwapPuts()); - assertEquals(KEYS_CNT * 3, cache.metrics().getSwapGets()); - assertEquals(KEYS_CNT, cache.metrics().getSwapHits()); - assertEquals(100 / 3.0, cache.metrics().getSwapHitPercentage(), 0.1); - assertEquals(KEYS_CNT * 2, cache.metrics().getSwapMisses()); - assertEquals(100 - (100 / 3.0), cache.metrics().getSwapMissPercentage(), 0.1); - assertEquals(KEYS_CNT, cache.metrics().getSwapRemovals()); - - assertEquals(KEYS_CNT - MAX_SIZE - OFFHEAP_MAX_CNT, cache.metrics().getSwapEntriesCount()); + assertEquals(cache.localMetrics().getCacheEvictions(), cache.localMetrics().getOffHeapPuts()); + assertEquals(KEYS_CNT * 3, cache.localMetrics().getOffHeapGets()); + assertEquals(0, cache.localMetrics().getOffHeapHits()); + assertEquals(0.0, cache.localMetrics().getOffHeapHitPercentage(), 0.1); + assertEquals(KEYS_CNT * 3, cache.localMetrics().getOffHeapMisses()); + assertEquals(100.0, cache.localMetrics().getOffHeapMissPercentage(), 0.1); + assertEquals(0, cache.localMetrics().getOffHeapRemovals()); + + assertEquals(cache.localMetrics().getCacheEvictions() - OFFHEAP_MAX_CNT, cache.localMetrics().getOffHeapEvictions()); + assertEquals(OFFHEAP_MAX_CNT, cache.localMetrics().getOffHeapEntriesCount()); + assertEquals(OFFHEAP_MAX_CNT, cache.localMetrics().getOffHeapPrimaryEntriesCount()); + assertEquals(0, cache.localMetrics().getOffHeapBackupEntriesCount()); + + assertEquals(cache.localMetrics().getOffHeapEvictions(), cache.localMetrics().getSwapPuts()); + assertEquals(KEYS_CNT * 3, cache.localMetrics().getSwapGets()); + assertEquals(KEYS_CNT, cache.localMetrics().getSwapHits()); + assertEquals(100 / 3.0, cache.localMetrics().getSwapHitPercentage(), 0.1); + assertEquals(KEYS_CNT * 2, cache.localMetrics().getSwapMisses()); + assertEquals(100 - (100 / 3.0), cache.localMetrics().getSwapMissPercentage(), 0.1); + assertEquals(KEYS_CNT, cache.localMetrics().getSwapRemovals()); + + assertEquals(KEYS_CNT - MAX_SIZE - OFFHEAP_MAX_CNT, cache.localMetrics().getSwapEntriesCount()); for (int i = 0; i < KEYS_CNT; i++) cache.remove(i); printStat(); - assertEquals(cache.metrics().getCacheEvictions(), cache.metrics().getOffHeapPuts()); - assertEquals(KEYS_CNT * 4 - MAX_SIZE, cache.metrics().getOffHeapGets()); - assertEquals(OFFHEAP_MAX_CNT, cache.metrics().getOffHeapHits()); + assertEquals(cache.localMetrics().getCacheEvictions(), cache.localMetrics().getOffHeapPuts()); + assertEquals(KEYS_CNT * 4 - MAX_SIZE, cache.localMetrics().getOffHeapGets()); + assertEquals(OFFHEAP_MAX_CNT, cache.localMetrics().getOffHeapHits()); assertEquals(100 * OFFHEAP_MAX_CNT / (KEYS_CNT * 4.0 - MAX_SIZE), - cache.metrics().getOffHeapHitPercentage(), 0.1); - assertEquals(KEYS_CNT * 4 - OFFHEAP_MAX_CNT - MAX_SIZE, cache.metrics().getOffHeapMisses()); + cache.localMetrics().getOffHeapHitPercentage(), 0.1); + assertEquals(KEYS_CNT * 4 - OFFHEAP_MAX_CNT - MAX_SIZE, cache.localMetrics().getOffHeapMisses()); assertEquals(100 * (KEYS_CNT * 4 - OFFHEAP_MAX_CNT - MAX_SIZE) / (KEYS_CNT * 4.0 - MAX_SIZE), - cache.metrics().getOffHeapMissPercentage(), 0.1); - assertEquals(OFFHEAP_MAX_CNT, cache.metrics().getOffHeapRemovals()); + cache.localMetrics().getOffHeapMissPercentage(), 0.1); + assertEquals(OFFHEAP_MAX_CNT, cache.localMetrics().getOffHeapRemovals()); - assertEquals(cache.metrics().getCacheEvictions() - OFFHEAP_MAX_CNT, cache.metrics().getOffHeapEvictions()); - assertEquals(0, cache.metrics().getOffHeapEntriesCount()); - assertEquals(0, cache.metrics().getOffHeapPrimaryEntriesCount()); - assertEquals(0, cache.metrics().getOffHeapBackupEntriesCount()); + assertEquals(cache.localMetrics().getCacheEvictions() - OFFHEAP_MAX_CNT, cache.localMetrics().getOffHeapEvictions()); + assertEquals(0, cache.localMetrics().getOffHeapEntriesCount()); + assertEquals(0, cache.localMetrics().getOffHeapPrimaryEntriesCount()); + assertEquals(0, cache.localMetrics().getOffHeapBackupEntriesCount()); - assertEquals(cache.metrics().getOffHeapEvictions(), cache.metrics().getSwapPuts()); - assertEquals(KEYS_CNT * 4 - MAX_SIZE - OFFHEAP_MAX_CNT, cache.metrics().getSwapGets()); - assertEquals(KEYS_CNT * 2 - MAX_SIZE - OFFHEAP_MAX_CNT, cache.metrics().getSwapHits()); + assertEquals(cache.localMetrics().getOffHeapEvictions(), cache.localMetrics().getSwapPuts()); + assertEquals(KEYS_CNT * 4 - MAX_SIZE - OFFHEAP_MAX_CNT, cache.localMetrics().getSwapGets()); + assertEquals(KEYS_CNT * 2 - MAX_SIZE - OFFHEAP_MAX_CNT, cache.localMetrics().getSwapHits()); assertEquals(100 * (KEYS_CNT * 2.0 - MAX_SIZE - OFFHEAP_MAX_CNT) / (KEYS_CNT * 4.0 - MAX_SIZE - OFFHEAP_MAX_CNT), - cache.metrics().getSwapHitPercentage(), 0.1); - assertEquals(KEYS_CNT * 2, cache.metrics().getSwapMisses()); + cache.localMetrics().getSwapHitPercentage(), 0.1); + assertEquals(KEYS_CNT * 2, cache.localMetrics().getSwapMisses()); assertEquals(100 * KEYS_CNT * 2.0 / (KEYS_CNT * 4.0 - MAX_SIZE - OFFHEAP_MAX_CNT), - cache.metrics().getSwapMissPercentage(), 0.1); - assertEquals(KEYS_CNT * 2 - MAX_SIZE - OFFHEAP_MAX_CNT, cache.metrics().getSwapRemovals()); + cache.localMetrics().getSwapMissPercentage(), 0.1); + assertEquals(KEYS_CNT * 2 - MAX_SIZE - OFFHEAP_MAX_CNT, cache.localMetrics().getSwapRemovals()); - assertEquals(0, cache.metrics().getSwapEntriesCount()); + assertEquals(0, cache.localMetrics().getSwapEntriesCount()); } /** @@ -380,36 +380,36 @@ public void testOffHeapAndSwapMetrics() throws Exception { */ protected void printStat() { System.out.println("!!! -------------------------------------------------------"); - System.out.println("!!! Puts: cache = " + cache.metrics().getCachePuts() + - ", offheap = " + cache.metrics().getOffHeapPuts() + - ", swap = " + cache.metrics().getSwapPuts()); - System.out.println("!!! Gets: cache = " + cache.metrics().getCacheGets() + - ", offheap = " + cache.metrics().getOffHeapGets() + - ", swap = " + cache.metrics().getSwapGets()); - System.out.println("!!! Removes: cache = " + cache.metrics().getCacheRemovals() + - ", offheap = " + cache.metrics().getOffHeapRemovals() + - ", swap = " + cache.metrics().getSwapRemovals()); - System.out.println("!!! Evictions: cache = " + cache.metrics().getCacheEvictions() + - ", offheap = " + cache.metrics().getOffHeapEvictions() + + System.out.println("!!! Puts: cache = " + cache.localMetrics().getCachePuts() + + ", offheap = " + cache.localMetrics().getOffHeapPuts() + + ", swap = " + cache.localMetrics().getSwapPuts()); + System.out.println("!!! Gets: cache = " + cache.localMetrics().getCacheGets() + + ", offheap = " + cache.localMetrics().getOffHeapGets() + + ", swap = " + cache.localMetrics().getSwapGets()); + System.out.println("!!! Removes: cache = " + cache.localMetrics().getCacheRemovals() + + ", offheap = " + cache.localMetrics().getOffHeapRemovals() + + ", swap = " + cache.localMetrics().getSwapRemovals()); + System.out.println("!!! Evictions: cache = " + cache.localMetrics().getCacheEvictions() + + ", offheap = " + cache.localMetrics().getOffHeapEvictions() + ", swap = none" ); - System.out.println("!!! Hits: cache = " + cache.metrics().getCacheHits() + - ", offheap = " + cache.metrics().getOffHeapHits() + - ", swap = " + cache.metrics().getSwapHits()); - System.out.println("!!! Hit(%): cache = " + cache.metrics().getCacheHitPercentage() + - ", offheap = " + cache.metrics().getOffHeapHitPercentage() + - ", swap = " + cache.metrics().getSwapHitPercentage()); - System.out.println("!!! Misses: cache = " + cache.metrics().getCacheMisses() + - ", offheap = " + cache.metrics().getOffHeapMisses() + - ", swap = " + cache.metrics().getSwapMisses()); - System.out.println("!!! Miss(%): cache = " + cache.metrics().getCacheMissPercentage() + - ", offheap = " + cache.metrics().getOffHeapMissPercentage() + - ", swap = " + cache.metrics().getSwapMissPercentage()); - System.out.println("!!! Entries: cache = " + cache.metrics().getSize() + - ", offheap = " + cache.metrics().getOffHeapEntriesCount() + - ", swap = " + cache.metrics().getSwapEntriesCount()); + System.out.println("!!! Hits: cache = " + cache.localMetrics().getCacheHits() + + ", offheap = " + cache.localMetrics().getOffHeapHits() + + ", swap = " + cache.localMetrics().getSwapHits()); + System.out.println("!!! Hit(%): cache = " + cache.localMetrics().getCacheHitPercentage() + + ", offheap = " + cache.localMetrics().getOffHeapHitPercentage() + + ", swap = " + cache.localMetrics().getSwapHitPercentage()); + System.out.println("!!! Misses: cache = " + cache.localMetrics().getCacheMisses() + + ", offheap = " + cache.localMetrics().getOffHeapMisses() + + ", swap = " + cache.localMetrics().getSwapMisses()); + System.out.println("!!! Miss(%): cache = " + cache.localMetrics().getCacheMissPercentage() + + ", offheap = " + cache.localMetrics().getOffHeapMissPercentage() + + ", swap = " + cache.localMetrics().getSwapMissPercentage()); + System.out.println("!!! Entries: cache = " + cache.localMetrics().getSize() + + ", offheap = " + cache.localMetrics().getOffHeapEntriesCount() + + ", swap = " + cache.localMetrics().getSwapEntriesCount()); System.out.println("!!! Size: cache = none" + - ", offheap = " + cache.metrics().getOffHeapAllocatedSize() + - ", swap = " + cache.metrics().getSwapSize()); + ", offheap = " + cache.localMetrics().getOffHeapAllocatedSize() + + ", swap = " + cache.localMetrics().getSwapSize()); System.out.println(); } } \ No newline at end of file diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/local/GridCacheAtomicLocalTckMetricsSelfTestImpl.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/local/GridCacheAtomicLocalTckMetricsSelfTestImpl.java index 0cc237704cd0b..fa21de906740c 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/local/GridCacheAtomicLocalTckMetricsSelfTestImpl.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/local/GridCacheAtomicLocalTckMetricsSelfTestImpl.java @@ -45,19 +45,19 @@ public void testEntryProcessorRemove() throws Exception { } }); - assertEquals(1L, cache.metrics().getCachePuts()); + assertEquals(1L, cache.localMetrics().getCachePuts()); assertEquals(20, result); - assertEquals(1L, cache.metrics().getCacheHits()); - assertEquals(100.0f, cache.metrics().getCacheHitPercentage()); - assertEquals(0L, cache.metrics().getCacheMisses()); - assertEquals(0f, cache.metrics().getCacheMissPercentage()); - assertEquals(1L, cache.metrics().getCachePuts()); - assertEquals(1L, cache.metrics().getCacheRemovals()); - assertEquals(0L, cache.metrics().getCacheEvictions()); - assert cache.metrics().getAveragePutTime() >= 0; - assert cache.metrics().getAverageGetTime() >= 0; - assert cache.metrics().getAverageRemoveTime() >= 0; + assertEquals(1L, cache.localMetrics().getCacheHits()); + assertEquals(100.0f, cache.localMetrics().getCacheHitPercentage()); + assertEquals(0L, cache.localMetrics().getCacheMisses()); + assertEquals(0f, cache.localMetrics().getCacheMissPercentage()); + assertEquals(1L, cache.localMetrics().getCachePuts()); + assertEquals(1L, cache.localMetrics().getCacheRemovals()); + assertEquals(0L, cache.localMetrics().getCacheEvictions()); + assert cache.localMetrics().getAveragePutTime() >= 0; + assert cache.localMetrics().getAverageGetTime() >= 0; + assert cache.localMetrics().getAverageRemoveTime() >= 0; } /** @@ -68,36 +68,36 @@ public void testCacheStatistics() throws Exception { cache.put(1, 10); - assertEquals(0, cache.metrics().getCacheRemovals()); - assertEquals(1, cache.metrics().getCachePuts()); + assertEquals(0, cache.localMetrics().getCacheRemovals()); + assertEquals(1, cache.localMetrics().getCachePuts()); cache.remove(1); - assertEquals(0, cache.metrics().getCacheHits()); - assertEquals(1, cache.metrics().getCacheRemovals()); - assertEquals(1, cache.metrics().getCachePuts()); + assertEquals(0, cache.localMetrics().getCacheHits()); + assertEquals(1, cache.localMetrics().getCacheRemovals()); + assertEquals(1, cache.localMetrics().getCachePuts()); cache.remove(1); - assertEquals(0, cache.metrics().getCacheHits()); - assertEquals(0, cache.metrics().getCacheMisses()); - assertEquals(1, cache.metrics().getCacheRemovals()); - assertEquals(1, cache.metrics().getCachePuts()); + assertEquals(0, cache.localMetrics().getCacheHits()); + assertEquals(0, cache.localMetrics().getCacheMisses()); + assertEquals(1, cache.localMetrics().getCacheRemovals()); + assertEquals(1, cache.localMetrics().getCachePuts()); cache.put(1, 10); assertTrue(cache.remove(1, 10)); - assertEquals(1, cache.metrics().getCacheHits()); - assertEquals(0, cache.metrics().getCacheMisses()); - assertEquals(2, cache.metrics().getCacheRemovals()); - assertEquals(2, cache.metrics().getCachePuts()); + assertEquals(1, cache.localMetrics().getCacheHits()); + assertEquals(0, cache.localMetrics().getCacheMisses()); + assertEquals(2, cache.localMetrics().getCacheRemovals()); + assertEquals(2, cache.localMetrics().getCachePuts()); assertFalse(cache.remove(1, 10)); - assertEquals(1, cache.metrics().getCacheHits()); - assertEquals(1, cache.metrics().getCacheMisses()); - assertEquals(2, cache.metrics().getCacheRemovals()); - assertEquals(2, cache.metrics().getCachePuts()); + assertEquals(1, cache.localMetrics().getCacheHits()); + assertEquals(1, cache.localMetrics().getCacheMisses()); + assertEquals(2, cache.localMetrics().getCacheRemovals()); + assertEquals(2, cache.localMetrics().getCachePuts()); } /** @@ -115,18 +115,18 @@ public void testConditionReplace() throws Exception { ++missCount; assertFalse(result); - assertEquals(missCount, cache.metrics().getCacheMisses()); - assertEquals(hitCount, cache.metrics().getCacheHits()); - assertEquals(putCount, cache.metrics().getCachePuts()); + assertEquals(missCount, cache.localMetrics().getCacheMisses()); + assertEquals(hitCount, cache.localMetrics().getCacheHits()); + assertEquals(putCount, cache.localMetrics().getCachePuts()); assertNull(cache.localPeek(1)); cache.put(1, 10); ++putCount; - assertEquals(missCount, cache.metrics().getCacheMisses()); - assertEquals(hitCount, cache.metrics().getCacheHits()); - assertEquals(putCount, cache.metrics().getCachePuts()); + assertEquals(missCount, cache.localMetrics().getCacheMisses()); + assertEquals(hitCount, cache.localMetrics().getCacheHits()); + assertEquals(putCount, cache.localMetrics().getCachePuts()); assertNotNull(cache.localPeek(1)); @@ -136,18 +136,18 @@ public void testConditionReplace() throws Exception { ++hitCount; ++putCount; - assertEquals(missCount, cache.metrics().getCacheMisses()); - assertEquals(hitCount, cache.metrics().getCacheHits()); - assertEquals(putCount, cache.metrics().getCachePuts()); + assertEquals(missCount, cache.localMetrics().getCacheMisses()); + assertEquals(hitCount, cache.localMetrics().getCacheHits()); + assertEquals(putCount, cache.localMetrics().getCachePuts()); result = cache.replace(1, 40, 50); assertFalse(result); ++hitCount; - assertEquals(hitCount, cache.metrics().getCacheHits()); - assertEquals(putCount, cache.metrics().getCachePuts()); - assertEquals(missCount, cache.metrics().getCacheMisses()); + assertEquals(hitCount, cache.localMetrics().getCacheHits()); + assertEquals(putCount, cache.localMetrics().getCachePuts()); + assertEquals(missCount, cache.localMetrics().getCacheMisses()); } /** @@ -165,15 +165,15 @@ public void testPutIfAbsent() throws Exception { ++putCount; assertTrue(result); - assertEquals(missCount, cache.metrics().getCacheMisses()); - assertEquals(hitCount, cache.metrics().getCacheHits()); - assertEquals(putCount, cache.metrics().getCachePuts()); + assertEquals(missCount, cache.localMetrics().getCacheMisses()); + assertEquals(hitCount, cache.localMetrics().getCacheHits()); + assertEquals(putCount, cache.localMetrics().getCachePuts()); result = cache.putIfAbsent(1, 1); assertFalse(result); - assertEquals(hitCount, cache.metrics().getCacheHits()); - assertEquals(putCount, cache.metrics().getCachePuts()); - assertEquals(missCount, cache.metrics().getCacheMisses()); + assertEquals(hitCount, cache.localMetrics().getCacheHits()); + assertEquals(putCount, cache.localMetrics().getCachePuts()); + assertEquals(missCount, cache.localMetrics().getCacheMisses()); } } \ No newline at end of file diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteCacheProcessProxy.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteCacheProcessProxy.java index 7286fb35af4bf..205dc83a50a9b 100644 --- a/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteCacheProcessProxy.java +++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteCacheProcessProxy.java @@ -439,11 +439,19 @@ public IgniteCacheProcessProxy(String name, boolean async, IgniteProcessProxy pr throw new UnsupportedOperationException("Method should be supported."); } + @Override public CacheMetrics localMetrics() { + throw new UnsupportedOperationException("Method should be supported."); + } + /** {@inheritDoc} */ @Override public CacheMetricsMXBean mxBean() { throw new UnsupportedOperationException("Method should be supported."); } + @Override public CacheMetricsMXBean localMxBean() { + throw new UnsupportedOperationException("Method should be supported."); + } + /** {@inheritDoc} */ @Override public IgniteCache withKeepBinary() { throw new UnsupportedOperationException("Method should be supported.");