Repository: incubator-ignite Updated Branches: refs/heads/ignite-37 [created] 0a945ade0
ignite-37 Improve offheap metrics for cache Project: http://git-wip-us.apache.org/repos/asf/incubator-ignite/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-ignite/commit/0a945ade Tree: http://git-wip-us.apache.org/repos/asf/incubator-ignite/tree/0a945ade Diff: http://git-wip-us.apache.org/repos/asf/incubator-ignite/diff/0a945ade Branch: refs/heads/ignite-37 Commit: 0a945ade0ba982858f2f71e594972624137f88f9 Parents: b4c424f Author: agura <[email protected]> Authored: Thu Apr 30 20:53:53 2015 +0300 Committer: agura <[email protected]> Committed: Thu Apr 30 20:53:53 2015 +0300 ---------------------------------------------------------------------- .../org/apache/ignite/cache/CacheMetrics.java | 64 ++++- .../processors/cache/CacheMetricsImpl.java | 119 ++++++++- .../cache/CacheMetricsMXBeanImpl.java | 45 ++++ .../processors/cache/CacheMetricsSnapshot.java | 248 +++++++++++++------ .../processors/cache/GridCacheSwapManager.java | 12 +- .../ignite/mxbean/CacheMetricsMXBean.java | 36 +++ 6 files changed, 441 insertions(+), 83 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a945ade/modules/core/src/main/java/org/apache/ignite/cache/CacheMetrics.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/cache/CacheMetrics.java b/modules/core/src/main/java/org/apache/ignite/cache/CacheMetrics.java index 0d87326..f0b7cf5 100644 --- a/modules/core/src/main/java/org/apache/ignite/cache/CacheMetrics.java +++ b/modules/core/src/main/java/org/apache/ignite/cache/CacheMetrics.java @@ -124,7 +124,6 @@ public interface CacheMetrics { */ public float getAverageTxRollbackTime(); - /** * Gets total number of transaction commits. * @@ -154,6 +153,48 @@ public interface CacheMetrics { public long getOverflowSize(); /** + * The total number of get requests to the off-heap memory. + * + * @return The number of gets. + */ + public long getOffHeapGets(); + + /** + * The total number of put requests to the off-heap memory. + * + * @return The number of puts. + */ + public long getOffHeapPuts(); + + /** + * The number of get requests that were satisfied by the off-heap memory. + * + * @return The off-heap hits number. + */ + public long getOffHeapHits(); + + /** + * Gets the percentage of hits on off-heap memory. + * + * @return The percentage of hits on off-heap memory. + */ + public float getOffHeapHitPercentage(); + + /** + * A miss is a get request that is not satisfied by off-heap memory. + * + * @return The off-heap misses number. + */ + public long getOffHeapMisses(); + + /** + * Gets the percentage of misses on off-heap memory. + * + * @return The percentage of misses on off-heap memory. + */ + public float getOffHeapMissPercentage(); + + /** * Gets number of entries stored in off-heap memory. * * @return Number of entries stored in off-heap memory. @@ -161,6 +202,20 @@ public interface CacheMetrics { public long getOffHeapEntriesCount(); /** + * Gets number of primary entries stored in off-heap memory. + * + * @return Number of primary entries stored in off-heap memory. + */ + public long getOffHeapPrimaryEntriesCount(); + + /** + * Gets number of backup entries stored in off-heap memory. + * + * @return Number of backup entries stored in off-heap memory. + */ + public long getOffHeapBackupEntriesCount(); + + /** * Gets memory size allocated in off-heap. * * @return Memory size allocated in off-heap. @@ -168,6 +223,13 @@ public interface CacheMetrics { public long getOffHeapAllocatedSize(); /** + * Gets off-heap memory maximum size. + * + * @return Off-heap memory maximum size. + */ + public long getOffHeapMaxSize(); + + /** * Gets number of non-{@code null} values in the cache. * * @return Number of non-{@code null} values in the cache. http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a945ade/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsImpl.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsImpl.java index 560de97..4d7941f 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsImpl.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsImpl.java @@ -25,6 +25,8 @@ import org.apache.ignite.internal.util.typedef.internal.*; import java.util.concurrent.atomic.*; +import static org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion.*; + /** * Adapter for cache metrics. */ @@ -63,7 +65,7 @@ public class CacheMetricsImpl implements CacheMetrics { private AtomicLong getTimeNanos = new AtomicLong(); /** Remove time taken nanos. */ - private AtomicLong removeTimeNanos = new AtomicLong(); + private AtomicLong rmvTimeNanos = new AtomicLong(); /** Commit transaction time taken nanos. */ private AtomicLong commitTimeNanos = new AtomicLong(); @@ -71,6 +73,18 @@ public class CacheMetricsImpl implements CacheMetrics { /** Commit transaction time taken nanos. */ private AtomicLong rollbackTimeNanos = new AtomicLong(); + /** Number of reads from off-heap memory. */ + private AtomicLong offHeapGets = new AtomicLong(); + + /** Number of writes to off-heap memory. */ + private AtomicLong offHeapPuts = new AtomicLong(); + + /** Number of off-heap hits. */ + private AtomicLong offHeapHits = new AtomicLong(); + + /** Number of off-heap misses. */ + private AtomicLong offHeapMisses = new AtomicLong(); + /** Cache metrics. */ @GridToStringExclude private transient CacheMetricsImpl delegate; @@ -126,16 +140,83 @@ public class CacheMetricsImpl implements CacheMetrics { } /** {@inheritDoc} */ + @Override public long getOffHeapGets() { + return offHeapGets.get(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapPuts() { + return offHeapPuts.get(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapHits() { + return offHeapHits.get(); + } + + /** {@inheritDoc} */ + @Override public float getOffHeapHitPercentage() { + long hits0 = offHeapHits.get(); + long gets0 = offHeapGets.get(); + + if (hits0 == 0) + return 0; + + return (float) hits0 / gets0 * 100.0f; + } + + /** {@inheritDoc} */ + @Override public long getOffHeapMisses() { + return offHeapMisses.get(); + } + + /** {@inheritDoc} */ + @Override public float getOffHeapMissPercentage() { + long misses0 = offHeapMisses.get(); + long reads0 = offHeapGets.get(); + + if (misses0 == 0) + return 0; + + return (float) misses0 / reads0 * 100.0f; + } + + /** {@inheritDoc} */ @Override public long getOffHeapEntriesCount() { return cctx.cache().offHeapEntriesCount(); } /** {@inheritDoc} */ + @Override public long getOffHeapPrimaryEntriesCount() { + try { + return cctx.swap().offheapEntriesCount(true, false, NONE); + } + catch (IgniteCheckedException e) { + return 0; + } + } + + /** {@inheritDoc} */ + @Override public long getOffHeapBackupEntriesCount() { + try { + return cctx.swap().offheapEntriesCount(false, true, NONE); + } + catch (IgniteCheckedException e) { + return 0; + } + } + + /** {@inheritDoc} */ @Override public long getOffHeapAllocatedSize() { return cctx.cache().offHeapAllocatedSize(); } /** {@inheritDoc} */ + @Override public long getOffHeapMaxSize() { + return cctx.config().getOffHeapMaxMemory(); + } + + /** {@inheritDoc} */ @Override public int getSize() { return cctx.cache().size(); } @@ -317,7 +398,7 @@ public class CacheMetricsImpl implements CacheMetrics { txCommits.set(0); txRollbacks.set(0); putTimeNanos.set(0); - removeTimeNanos.set(0); + rmvTimeNanos.set(0); getTimeNanos.set(0); commitTimeNanos.set(0); rollbackTimeNanos.set(0); @@ -402,7 +483,7 @@ public class CacheMetricsImpl implements CacheMetrics { /** {@inheritDoc} */ @Override public float getAverageRemoveTime() { - long timeNanos = removeTimeNanos.get(); + long timeNanos = rmvTimeNanos.get(); long removesCnt = rmCnt.get(); if (timeNanos == 0 || removesCnt == 0) @@ -483,7 +564,6 @@ public class CacheMetricsImpl implements CacheMetrics { delegate.onTxRollback(duration); } - /** * Increments the get time accumulator. * @@ -514,7 +594,7 @@ public class CacheMetricsImpl implements CacheMetrics { * @param duration the time taken in nanoseconds. */ public void addRemoveTimeNanos(long duration) { - removeTimeNanos.addAndGet(duration); + rmvTimeNanos.addAndGet(duration); if (delegate != null) delegate.addRemoveTimeNanos(duration); @@ -526,7 +606,7 @@ public class CacheMetricsImpl implements CacheMetrics { * @param duration the time taken in nanoseconds. */ public void addRemoveAndGetTimeNanos(long duration) { - removeTimeNanos.addAndGet(duration); + rmvTimeNanos.addAndGet(duration); getTimeNanos.addAndGet(duration); if (delegate != null) @@ -581,6 +661,33 @@ public class CacheMetricsImpl implements CacheMetrics { return cctx.config().isManagementEnabled(); } + /** + * Off-heap read callback. + * + * @param hit Hit or miss flag. + */ + public void onOffHeapRead(boolean hit) { + offHeapGets.incrementAndGet(); + + if (hit) + offHeapHits.incrementAndGet(); + else + offHeapMisses.incrementAndGet(); + + if (delegate != null) + delegate.onOffHeapRead(hit); + } + + /** + * Off-heap write callback. + */ + public void onOffHeapWrite() { + offHeapPuts.incrementAndGet(); + + if (delegate != null) + delegate.onWrite(); + } + /** {@inheritDoc} */ @Override public String toString() { return S.toString(CacheMetricsImpl.class, this); http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a945ade/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsMXBeanImpl.java ---------------------------------------------------------------------- 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/CacheMetricsMXBeanImpl.java index e9d547c..321d143 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/CacheMetricsMXBeanImpl.java @@ -49,16 +49,61 @@ class CacheMetricsMXBeanImpl implements CacheMetricsMXBean { } /** {@inheritDoc} */ + @Override public long getOffHeapGets() { + return cache.metrics0().getOffHeapGets(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapPuts() { + return cache.metrics0().getOffHeapPuts(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapHits() { + return cache.metrics0().getOffHeapHits(); + } + + /** {@inheritDoc} */ + @Override public float getOffHeapHitPercentage() { + return cache.metrics0().getOffHeapHitPercentage(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapMisses() { + return cache.metrics0().getOffHeapMisses(); + } + + /** {@inheritDoc} */ + @Override public float getOffHeapMissPercentage() { + return cache.metrics0().getOffHeapMissPercentage(); + } + + /** {@inheritDoc} */ @Override public long getOffHeapEntriesCount() { return cache.metrics0().getOffHeapEntriesCount(); } /** {@inheritDoc} */ + @Override public long getOffHeapPrimaryEntriesCount() { + return cache.metrics0().getOffHeapPrimaryEntriesCount(); + } + + /** {@inheritDoc} */ + @Override public long getOffHeapBackupEntriesCount() { + return cache.metrics0().getOffHeapBackupEntriesCount(); + } + + /** {@inheritDoc} */ @Override public long getOffHeapAllocatedSize() { return cache.metrics0().getOffHeapAllocatedSize(); } /** {@inheritDoc} */ + @Override public long getOffHeapMaxSize() { + return cache.metrics0().getOffHeapMaxSize(); + } + + /** {@inheritDoc} */ @Override public int getSize() { return cache.metrics0().getSize(); } http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a945ade/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsSnapshot.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsSnapshot.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsSnapshot.java index 4fe152a..b4b96e5 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsSnapshot.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsSnapshot.java @@ -61,7 +61,7 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { private float getAvgTimeNanos = 0; /** Remove time taken nanos. */ - private float removeAvgTimeNanos = 0; + private float rmvAvgTimeNanos = 0; /** Commit transaction time taken nanos. */ private float commitAvgTimeNanos = 0; @@ -75,12 +75,33 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { /** Number of entries that was swapped to disk. */ private long overflowSize; + /** Number of reads from off-heap. */ + private long offHeapGets; + + /** Number of writes to off-heap. */ + private long offHeapPuts; + + /** Off-heap hits number. */ + private long offHeapHits; + + /** Off-heap misses number. */ + private long offHeapMisses; + /** Number of entries stored in off-heap memory. */ - private long offHeapEntriesCount; + private long offHeapEntriesCnt; + + /** Number of primary entries stored in off-heap memory. */ + private long offHeapPrimaryEntriesCnt; + + /** Number of backup entries stored in off-heap memory. */ + private long offHeapBackupEntriesCnt; /** Memory size allocated in off-heap. */ private long offHeapAllocatedSize; + /** Off-heap memory maximum size*/ + private long offHeapMaxSize; + /** Number of non-{@code null} values in the cache. */ private int size; @@ -91,7 +112,7 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { private boolean isEmpty; /** Gets current size of evict queue used to batch up evictions. */ - private int dhtEvictQueueCurrentSize; + private int dhtEvictQueueCurrSize; /** Transaction per-thread map size. */ private int txThreadMapSize; @@ -106,7 +127,7 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { private int txPrepareQueueSize; /** Start version counts map size. */ - private int txStartVersionCountsSize; + private int txStartVerCountsSize; /** Number of cached committed transaction IDs. */ private int txCommittedVersionsSize; @@ -127,7 +148,7 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { private int txDhtPrepareQueueSize; /** DHT start version counts map size. */ - private int txDhtStartVersionCountsSize; + private int txDhtStartVerCountsSize; /** Number of cached committed DHT transaction IDs. */ private int txDhtCommittedVersionsSize; @@ -142,34 +163,34 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { private int writeBehindFlushSize; /** Count of worker threads. */ - private int writeBehindFlushThreadCount; + private int writeBehindFlushThreadCnt; /** Flush frequency in milliseconds. */ - private long writeBehindFlushFrequency; + private long writeBehindFlushFreq; /** Maximum size of batch. */ private int writeBehindStoreBatchSize; /** Count of cache overflow events since start. */ - private int writeBehindTotalCriticalOverflowCount; + private int writeBehindTotalCriticalOverflowCnt; /** Count of cache overflow events since start. */ - private int writeBehindCriticalOverflowCount; + private int writeBehindCriticalOverflowCnt; /** Count of entries in store-retry state. */ - private int writeBehindErrorRetryCount; + private int writeBehindErrorRetryCnt; /** Total count of entries in cache store internal buffer. */ - private int writeBehindBufferSize; + private int writeBehindBufSize; /** */ private String keyType; /** */ - private String valueType; + private String valType; /** */ - private boolean isStoreByValue; + private boolean isStoreByVal; /** */ private boolean isStatisticsEnabled; @@ -207,45 +228,52 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { putAvgTimeNanos = m.getAveragePutTime(); getAvgTimeNanos = m.getAverageGetTime(); - removeAvgTimeNanos = m.getAverageRemoveTime(); + rmvAvgTimeNanos = m.getAverageRemoveTime(); commitAvgTimeNanos = m.getAverageTxCommitTime(); rollbackAvgTimeNanos = m.getAverageTxRollbackTime(); cacheName = m.name(); overflowSize = m.getOverflowSize(); - offHeapEntriesCount = m.getOffHeapEntriesCount(); + offHeapGets = m.getOffHeapGets(); + offHeapPuts = m.getOffHeapPuts(); + offHeapHits = m.getOffHeapHits(); + offHeapMisses = m.getOffHeapMisses(); + offHeapEntriesCnt = m.getOffHeapEntriesCount(); + offHeapPrimaryEntriesCnt = m.getOffHeapPrimaryEntriesCount(); + offHeapBackupEntriesCnt = m.getOffHeapBackupEntriesCount(); offHeapAllocatedSize = m.getOffHeapAllocatedSize(); + offHeapMaxSize = m.getOffHeapMaxSize(); size = m.getSize(); keySize = m.getKeySize(); isEmpty = m.isEmpty(); - dhtEvictQueueCurrentSize = m.getDhtEvictQueueCurrentSize(); + dhtEvictQueueCurrSize = m.getDhtEvictQueueCurrentSize(); txThreadMapSize = m.getTxThreadMapSize(); txXidMapSize = m.getTxXidMapSize(); txCommitQueueSize = m.getTxCommitQueueSize(); txPrepareQueueSize = m.getTxPrepareQueueSize(); - txStartVersionCountsSize = m.getTxStartVersionCountsSize(); + txStartVerCountsSize = m.getTxStartVersionCountsSize(); txCommittedVersionsSize = m.getTxCommittedVersionsSize(); txRolledbackVersionsSize = m.getTxRolledbackVersionsSize(); txDhtThreadMapSize = m.getTxDhtThreadMapSize(); txDhtXidMapSize = m.getTxDhtXidMapSize(); txDhtCommitQueueSize = m.getTxDhtCommitQueueSize(); txDhtPrepareQueueSize = m.getTxDhtPrepareQueueSize(); - txDhtStartVersionCountsSize = m.getTxDhtStartVersionCountsSize(); + txDhtStartVerCountsSize = m.getTxDhtStartVersionCountsSize(); txDhtCommittedVersionsSize = m.getTxDhtCommittedVersionsSize(); txDhtRolledbackVersionsSize = m.getTxDhtRolledbackVersionsSize(); isWriteBehindEnabled = m.isWriteBehindEnabled(); writeBehindFlushSize = m.getWriteBehindFlushSize(); - writeBehindFlushThreadCount = m.getWriteBehindFlushThreadCount(); - writeBehindFlushFrequency = m.getWriteBehindFlushFrequency(); + writeBehindFlushThreadCnt = m.getWriteBehindFlushThreadCount(); + writeBehindFlushFreq = m.getWriteBehindFlushFrequency(); writeBehindStoreBatchSize = m.getWriteBehindStoreBatchSize(); - writeBehindTotalCriticalOverflowCount = m.getWriteBehindTotalCriticalOverflowCount(); - writeBehindCriticalOverflowCount = m.getWriteBehindCriticalOverflowCount(); - writeBehindErrorRetryCount = m.getWriteBehindErrorRetryCount(); - writeBehindBufferSize = m.getWriteBehindBufferSize(); + writeBehindTotalCriticalOverflowCnt = m.getWriteBehindTotalCriticalOverflowCount(); + writeBehindCriticalOverflowCnt = m.getWriteBehindCriticalOverflowCount(); + writeBehindErrorRetryCnt = m.getWriteBehindErrorRetryCount(); + writeBehindBufSize = m.getWriteBehindBufferSize(); keyType = m.getKeyType(); - valueType = m.getValueType(); - isStoreByValue = m.isStoreByValue(); + valType = m.getValueType(); + isStoreByVal = m.isStoreByValue(); isStatisticsEnabled = m.isStatisticsEnabled(); isManagementEnabled = m.isManagementEnabled(); isReadThrough = m.isReadThrough(); @@ -263,21 +291,23 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { isEmpty = loc.isEmpty(); isWriteBehindEnabled = loc.isWriteBehindEnabled(); writeBehindFlushSize = loc.getWriteBehindFlushSize(); - writeBehindFlushThreadCount = loc.getWriteBehindFlushThreadCount(); - writeBehindFlushFrequency = loc.getWriteBehindFlushFrequency(); + writeBehindFlushThreadCnt = loc.getWriteBehindFlushThreadCount(); + writeBehindFlushFreq = loc.getWriteBehindFlushFrequency(); writeBehindStoreBatchSize = loc.getWriteBehindStoreBatchSize(); - writeBehindBufferSize = loc.getWriteBehindBufferSize(); + writeBehindBufSize = loc.getWriteBehindBufferSize(); size = loc.getSize(); keySize = loc.getKeySize(); keyType = loc.getKeyType(); - valueType = loc.getValueType(); - isStoreByValue = loc.isStoreByValue(); + valType = loc.getValueType(); + isStoreByVal = loc.isStoreByValue(); isStatisticsEnabled = loc.isStatisticsEnabled(); isManagementEnabled = loc.isManagementEnabled(); isReadThrough = loc.isReadThrough(); isWriteThrough = loc.isWriteThrough(); + offHeapMaxSize = loc.getOffHeapMaxSize(); + for (CacheMetrics e : metrics) { reads += e.getCacheGets(); puts += e.getCachePuts(); @@ -290,7 +320,7 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { putAvgTimeNanos += e.getAveragePutTime(); getAvgTimeNanos += e.getAverageGetTime(); - removeAvgTimeNanos += e.getAverageRemoveTime(); + rmvAvgTimeNanos += e.getAverageRemoveTime(); commitAvgTimeNanos += e.getAverageTxCommitTime(); rollbackAvgTimeNanos += e.getAverageTxRollbackTime(); @@ -299,19 +329,25 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { else overflowSize = -1; - offHeapEntriesCount += e.getOffHeapEntriesCount(); + offHeapGets += e.getOffHeapGets(); + offHeapPuts += e.getOffHeapPuts(); + offHeapHits += e.getOffHeapHits(); + offHeapMisses += e.getOffHeapMisses(); + offHeapEntriesCnt += e.getOffHeapEntriesCount(); + offHeapPrimaryEntriesCnt += e.getOffHeapPrimaryEntriesCount(); + offHeapBackupEntriesCnt += e.getOffHeapBackupEntriesCount(); offHeapAllocatedSize += e.getOffHeapAllocatedSize(); if (e.getDhtEvictQueueCurrentSize() > -1) - dhtEvictQueueCurrentSize += e.getDhtEvictQueueCurrentSize(); + dhtEvictQueueCurrSize += e.getDhtEvictQueueCurrentSize(); else - dhtEvictQueueCurrentSize = -1; + dhtEvictQueueCurrSize = -1; txThreadMapSize += e.getTxThreadMapSize(); txXidMapSize += e.getTxXidMapSize(); txCommitQueueSize += e.getTxCommitQueueSize(); txPrepareQueueSize += e.getTxPrepareQueueSize(); - txStartVersionCountsSize += e.getTxStartVersionCountsSize(); + txStartVerCountsSize += e.getTxStartVersionCountsSize(); txCommittedVersionsSize += e.getTxCommittedVersionsSize(); txRolledbackVersionsSize += e.getTxRolledbackVersionsSize(); @@ -336,9 +372,9 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { txDhtPrepareQueueSize = -1; if (e.getTxDhtStartVersionCountsSize() > -1) - txDhtStartVersionCountsSize += e.getTxDhtStartVersionCountsSize(); + txDhtStartVerCountsSize += e.getTxDhtStartVersionCountsSize(); else - txDhtStartVersionCountsSize = -1; + txDhtStartVerCountsSize = -1; if (e.getTxDhtCommittedVersionsSize() > -1) txDhtCommittedVersionsSize += e.getTxDhtCommittedVersionsSize(); @@ -351,19 +387,19 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { txDhtRolledbackVersionsSize = -1; if (e.getWriteBehindTotalCriticalOverflowCount() > -1) - writeBehindTotalCriticalOverflowCount += e.getWriteBehindTotalCriticalOverflowCount(); + writeBehindTotalCriticalOverflowCnt += e.getWriteBehindTotalCriticalOverflowCount(); else - writeBehindTotalCriticalOverflowCount = -1; + writeBehindTotalCriticalOverflowCnt = -1; if (e.getWriteBehindCriticalOverflowCount() > -1) - writeBehindCriticalOverflowCount += e.getWriteBehindCriticalOverflowCount(); + writeBehindCriticalOverflowCnt += e.getWriteBehindCriticalOverflowCount(); else - writeBehindCriticalOverflowCount = -1; + writeBehindCriticalOverflowCnt = -1; if (e.getWriteBehindErrorRetryCount() > -1) - writeBehindErrorRetryCount += e.getWriteBehindErrorRetryCount(); + writeBehindErrorRetryCnt += e.getWriteBehindErrorRetryCount(); else - writeBehindErrorRetryCount = -1; + writeBehindErrorRetryCnt = -1; } int size = metrics.size(); @@ -371,7 +407,7 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { if (size > 1) { putAvgTimeNanos /= size; getAvgTimeNanos /= size; - removeAvgTimeNanos /= size; + rmvAvgTimeNanos /= size; commitAvgTimeNanos /= size; rollbackAvgTimeNanos /= size; } @@ -435,7 +471,7 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { /** {@inheritDoc} */ @Override public float getAverageRemoveTime() { - return removeAvgTimeNanos; + return rmvAvgTimeNanos; } /** {@inheritDoc} */ @@ -469,8 +505,53 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { } /** {@inheritDoc} */ + @Override public long getOffHeapGets() { + return offHeapGets; + } + + /** {@inheritDoc} */ + @Override public long getOffHeapPuts() { + return offHeapPuts; + } + + /** {@inheritDoc} */ + @Override public long getOffHeapHits() { + return offHeapHits; + } + + /** {@inheritDoc} */ + @Override public float getOffHeapHitPercentage() { + if (offHeapHits == 0 || offHeapGets == 0) + return 0; + + return (float) offHeapHits / offHeapGets * 100.0f; + } + + /** {@inheritDoc} */ + @Override public long getOffHeapMisses() { + return offHeapMisses; + } + + /** {@inheritDoc} */ + @Override public float getOffHeapMissPercentage() { + if (offHeapMisses == 0 || offHeapGets == 0) + return 0; + + return (float) offHeapMisses / offHeapGets * 100.0f; + } + /** {@inheritDoc} */ @Override public long getOffHeapEntriesCount() { - return offHeapEntriesCount; + return offHeapEntriesCnt; + } + + /** {@inheritDoc} */ + @Override public long getOffHeapPrimaryEntriesCount() { + return offHeapPrimaryEntriesCnt; + } + + /** {@inheritDoc} */ + @Override public long getOffHeapBackupEntriesCount() { + return offHeapBackupEntriesCnt; } /** {@inheritDoc} */ @@ -479,6 +560,11 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { } /** {@inheritDoc} */ + @Override public long getOffHeapMaxSize() { + return offHeapMaxSize; + } + + /** {@inheritDoc} */ @Override public int getSize() { return size; } @@ -495,7 +581,7 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { /** {@inheritDoc} */ @Override public int getDhtEvictQueueCurrentSize() { - return dhtEvictQueueCurrentSize; + return dhtEvictQueueCurrSize; } /** {@inheritDoc} */ @@ -520,7 +606,7 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { /** {@inheritDoc} */ @Override public int getTxStartVersionCountsSize() { - return txStartVersionCountsSize; + return txStartVerCountsSize; } /** {@inheritDoc} */ @@ -555,7 +641,7 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { /** {@inheritDoc} */ @Override public int getTxDhtStartVersionCountsSize() { - return txDhtStartVersionCountsSize; + return txDhtStartVerCountsSize; } /** {@inheritDoc} */ @@ -580,12 +666,12 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { /** {@inheritDoc} */ @Override public int getWriteBehindFlushThreadCount() { - return writeBehindFlushThreadCount; + return writeBehindFlushThreadCnt; } /** {@inheritDoc} */ @Override public long getWriteBehindFlushFrequency() { - return writeBehindFlushFrequency; + return writeBehindFlushFreq; } /** {@inheritDoc} */ @@ -595,22 +681,22 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { /** {@inheritDoc} */ @Override public int getWriteBehindTotalCriticalOverflowCount() { - return writeBehindTotalCriticalOverflowCount; + return writeBehindTotalCriticalOverflowCnt; } /** {@inheritDoc} */ @Override public int getWriteBehindCriticalOverflowCount() { - return writeBehindCriticalOverflowCount; + return writeBehindCriticalOverflowCnt; } /** {@inheritDoc} */ @Override public int getWriteBehindErrorRetryCount() { - return writeBehindErrorRetryCount; + return writeBehindErrorRetryCnt; } /** {@inheritDoc} */ @Override public int getWriteBehindBufferSize() { - return writeBehindBufferSize; + return writeBehindBufSize; } /** {@inheritDoc} */ @@ -620,12 +706,12 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { /** {@inheritDoc} */ @Override public String getValueType() { - return valueType; + return valType; } /** {@inheritDoc} */ @Override public boolean isStoreByValue() { - return isStoreByValue; + return isStoreByVal; } /** {@inheritDoc} */ @@ -666,31 +752,38 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { out.writeFloat(putAvgTimeNanos); out.writeFloat(getAvgTimeNanos); - out.writeFloat(removeAvgTimeNanos); + out.writeFloat(rmvAvgTimeNanos); out.writeFloat(commitAvgTimeNanos); out.writeFloat(rollbackAvgTimeNanos); out.writeLong(overflowSize); - out.writeLong(offHeapEntriesCount); + out.writeLong(offHeapGets); + out.writeLong(offHeapPuts); + out.writeLong(offHeapHits); + out.writeLong(offHeapMisses); + out.writeLong(offHeapEntriesCnt); + out.writeLong(offHeapPrimaryEntriesCnt); + out.writeLong(offHeapBackupEntriesCnt); out.writeLong(offHeapAllocatedSize); - out.writeInt(dhtEvictQueueCurrentSize); + out.writeLong(offHeapMaxSize); + out.writeInt(dhtEvictQueueCurrSize); out.writeInt(txThreadMapSize); out.writeInt(txXidMapSize); out.writeInt(txCommitQueueSize); out.writeInt(txPrepareQueueSize); - out.writeInt(txStartVersionCountsSize); + out.writeInt(txStartVerCountsSize); out.writeInt(txCommittedVersionsSize); out.writeInt(txRolledbackVersionsSize); out.writeInt(txDhtThreadMapSize); out.writeInt(txDhtXidMapSize); out.writeInt(txDhtCommitQueueSize); out.writeInt(txDhtPrepareQueueSize); - out.writeInt(txDhtStartVersionCountsSize); + out.writeInt(txDhtStartVerCountsSize); out.writeInt(txDhtCommittedVersionsSize); out.writeInt(txDhtRolledbackVersionsSize); - out.writeInt(writeBehindTotalCriticalOverflowCount); - out.writeInt(writeBehindCriticalOverflowCount); - out.writeInt(writeBehindErrorRetryCount); + out.writeInt(writeBehindTotalCriticalOverflowCnt); + out.writeInt(writeBehindCriticalOverflowCnt); + out.writeInt(writeBehindErrorRetryCnt); } /** {@inheritDoc} */ @@ -706,30 +799,37 @@ public class CacheMetricsSnapshot implements CacheMetrics, Externalizable { putAvgTimeNanos = in.readFloat(); getAvgTimeNanos = in.readFloat(); - removeAvgTimeNanos = in.readFloat(); + rmvAvgTimeNanos = in.readFloat(); commitAvgTimeNanos = in.readFloat(); rollbackAvgTimeNanos = in.readFloat(); overflowSize = in.readLong(); - offHeapEntriesCount = in.readLong(); + offHeapGets = in.readLong(); + offHeapPuts = in.readLong(); + offHeapHits = in.readLong(); + offHeapMisses = in.readLong(); + offHeapEntriesCnt = in.readLong(); + offHeapPrimaryEntriesCnt = in.readLong(); + offHeapBackupEntriesCnt = in.readLong(); offHeapAllocatedSize = in.readLong(); - dhtEvictQueueCurrentSize = in.readInt(); + offHeapMaxSize = in.readLong(); + dhtEvictQueueCurrSize = in.readInt(); txThreadMapSize = in.readInt(); txXidMapSize = in.readInt(); txCommitQueueSize = in.readInt(); txPrepareQueueSize = in.readInt(); - txStartVersionCountsSize = in.readInt(); + txStartVerCountsSize = in.readInt(); txCommittedVersionsSize = in.readInt(); txRolledbackVersionsSize = in.readInt(); txDhtThreadMapSize = in.readInt(); txDhtXidMapSize = in.readInt(); txDhtCommitQueueSize = in.readInt(); txDhtPrepareQueueSize = in.readInt(); - txDhtStartVersionCountsSize = in.readInt(); + txDhtStartVerCountsSize = in.readInt(); txDhtCommittedVersionsSize = in.readInt(); txDhtRolledbackVersionsSize = in.readInt(); - writeBehindTotalCriticalOverflowCount = in.readInt(); - writeBehindCriticalOverflowCount = in.readInt(); - writeBehindErrorRetryCount = in.readInt(); + writeBehindTotalCriticalOverflowCnt = in.readInt(); + writeBehindCriticalOverflowCnt = in.readInt(); + writeBehindErrorRetryCnt = in.readInt(); } } http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a945ade/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheSwapManager.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheSwapManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheSwapManager.java index 6444e37..66bdc19 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheSwapManager.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheSwapManager.java @@ -395,8 +395,7 @@ public class GridCacheSwapManager extends GridCacheManagerAdapter { * @return Reconstituted swap entry or {@code null} if entry is obsolete. * @throws IgniteCheckedException If failed. */ - @Nullable private <X extends GridCacheSwapEntry> X swapEntry(X e) throws IgniteCheckedException - { + @Nullable private <X extends GridCacheSwapEntry> X swapEntry(X e) throws IgniteCheckedException { assert e != null; checkIteratorQueue(); @@ -481,6 +480,9 @@ public class GridCacheSwapManager extends GridCacheManagerAdapter { if (readOffheap && offheapEnabled) { byte[] bytes = offheap.get(spaceName, part, key, keyBytes); + if (cctx.config().isStatisticsEnabled()) + cctx.cache().metrics0().onOffHeapRead(bytes != null); + if (bytes != null) return swapEntry(unmarshalSwapEntry(bytes)); } @@ -1007,6 +1009,9 @@ public class GridCacheSwapManager extends GridCacheManagerAdapter { if (offheapEnabled) { offheap.put(spaceName, part, key, key.valueBytes(cctx.cacheObjectContext()), entry.marshal()); + if (cctx.config().isStatisticsEnabled()) + cctx.cache().metrics0().onOffHeapWrite(); + if (cctx.events().isRecordable(EVT_CACHE_OBJECT_TO_OFFHEAP)) cctx.events().addEvent(part, key, cctx.nodeId(), (IgniteUuid)null, null, EVT_CACHE_OBJECT_TO_OFFHEAP, null, false, null, true, null, null, null); @@ -1041,6 +1046,9 @@ public class GridCacheSwapManager extends GridCacheManagerAdapter { swapEntry.key().valueBytes(cctx.cacheObjectContext()), swapEntry.marshal()); + if (cctx.config().isStatisticsEnabled()) + cctx.cache().metrics0().onOffHeapWrite(); + if (cctx.events().isRecordable(EVT_CACHE_OBJECT_TO_OFFHEAP)) cctx.events().addEvent(swapEntry.partition(), swapEntry.key(), cctx.nodeId(), (IgniteUuid)null, null, EVT_CACHE_OBJECT_TO_OFFHEAP, null, false, null, true, null, null, null); http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a945ade/modules/core/src/main/java/org/apache/ignite/mxbean/CacheMetricsMXBean.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/mxbean/CacheMetricsMXBean.java b/modules/core/src/main/java/org/apache/ignite/mxbean/CacheMetricsMXBean.java index 2ad07b5..0dc55f2 100644 --- a/modules/core/src/main/java/org/apache/ignite/mxbean/CacheMetricsMXBean.java +++ b/modules/core/src/main/java/org/apache/ignite/mxbean/CacheMetricsMXBean.java @@ -100,14 +100,50 @@ public interface CacheMetricsMXBean extends CacheStatisticsMXBean, CacheMXBean, public long getOverflowSize(); /** {@inheritDoc} */ + @MXBeanDescription("Number of gets from off-heap memory.") + public long getOffHeapGets(); + + /** {@inheritDoc} */ + @MXBeanDescription("Number of puts to off-heap memory.") + public long getOffHeapPuts(); + + /** {@inheritDoc} */ + @MXBeanDescription("Number of hits on off-heap memory.") + public long getOffHeapHits(); + + /** {@inheritDoc} */ + @MXBeanDescription("Percentage of hits on off-heap memory.") + public float getOffHeapHitPercentage(); + + /** {@inheritDoc} */ + @MXBeanDescription("Number of misses on off-heap memory.") + public long getOffHeapMisses(); + + /** {@inheritDoc} */ + @MXBeanDescription("Percentage of misses on off-heap memory.") + public float getOffHeapMissPercentage(); + + /** {@inheritDoc} */ @MXBeanDescription("Number of entries stored in off-heap memory.") public long getOffHeapEntriesCount(); /** {@inheritDoc} */ + @MXBeanDescription("Number of primary entries stored in off-heap memory.") + public long getOffHeapPrimaryEntriesCount(); + + /** {@inheritDoc} */ + @MXBeanDescription("Number of backup stored in off-heap memory.") + public long getOffHeapBackupEntriesCount(); + + /** {@inheritDoc} */ @MXBeanDescription("Memory size allocated in off-heap.") public long getOffHeapAllocatedSize(); /** {@inheritDoc} */ + @MXBeanDescription("Off-heap memory maximum size.") + public long getOffHeapMaxSize(); + + /** {@inheritDoc} */ @MXBeanDescription("Number of non-null values in the cache.") public int getSize();
