ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [73/79] [abbrv] incubator-ignite git commit: IGNITE-49 merged from sprint-1 into ignite-49
Date Fri, 23 Jan 2015 16:07:12 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/c7a9a1db/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsAdapter.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsAdapter.java
index 0000000,0000000..0752544
new file mode 100644
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsAdapter.java
@@@ -1,0 -1,0 +1,551 @@@
++/*
++ * 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.*;
++import org.apache.ignite.cache.*;
++import org.apache.ignite.internal.util.tostring.*;
++import org.apache.ignite.internal.util.typedef.internal.*;
++
++import java.util.concurrent.atomic.*;
++
++/**
++ * Adapter for cache metrics.
++ */
++public class CacheMetricsAdapter implements CacheMetrics {
++    /** */
++    private static final long NANOS_IN_MICROSECOND = 1000L;
++
++    /** Number of reads. */
++    private AtomicLong reads = new AtomicLong();
++
++    /** Number of writes. */
++    private AtomicLong writes = new AtomicLong();
++
++    /** Number of hits. */
++    private AtomicLong hits = new AtomicLong();
++
++    /** Number of misses. */
++    private AtomicLong misses = new AtomicLong();
++
++    /** Number of transaction commits. */
++    private AtomicLong txCommits = new AtomicLong();
++
++    /** Number of transaction rollbacks. */
++    private AtomicLong txRollbacks = new AtomicLong();
++
++    /** Number of evictions. */
++    private AtomicLong evictCnt = new AtomicLong();
++
++    /** Number of removed entries. */
++    private AtomicLong rmCnt = new AtomicLong();
++
++    /** Put time taken nanos. */
++    private AtomicLong putTimeNanos = new AtomicLong();
++
++    /** Get time taken nanos. */
++    private AtomicLong getTimeNanos = new AtomicLong();
++
++    /** Remove time taken nanos. */
++    private AtomicLong removeTimeNanos = new AtomicLong();
++
++    /** Commit transaction time taken nanos. */
++    private AtomicLong commitTimeNanos = new AtomicLong();
++
++    /** Commit transaction time taken nanos. */
++    private AtomicLong rollbackTimeNanos = new AtomicLong();
++
++    /** Cache metrics. */
++    @GridToStringExclude
++    private transient CacheMetricsAdapter delegate;
++
++    /** Cache context. */
++    private GridCacheContext<?, ?> cctx;
++
++    /** DHT context. */
++    private GridCacheContext<?, ?> dhtCtx;
++
++    /** Write-behind store, if configured. */
++    private GridCacheWriteBehindStore store;
++
++    /**
++     * Creates cache metrics;
++     *
++     * @param cctx Cache context.
++     */
++    public CacheMetricsAdapter(GridCacheContext<?, ?> cctx) {
++        assert cctx != null;
++
++        this.cctx = cctx;
++
++        if (cctx.isNear())
++            dhtCtx = cctx.near().dht().context();
++
++        if (cctx.store().store() instanceof GridCacheWriteBehindStore)
++            store = (GridCacheWriteBehindStore)cctx.store().store();
++
++        delegate = null;
++    }
++
++    /**
++     * @param delegate Metrics to delegate to.
++     */
++    public void delegate(CacheMetricsAdapter delegate) {
++        this.delegate = delegate;
++    }
++
++
++    /** {@inheritDoc} */
++    @Override public String name() {
++        return cctx.name();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getOverflowSize() {
++        try {
++            return cctx.cache().overflowSize();
++        }
++        catch (IgniteCheckedException ignored) {
++            return -1;
++        }
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getOffHeapEntriesCount() {
++        return cctx.cache().offHeapEntriesCount();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getOffHeapAllocatedSize() {
++        return cctx.cache().offHeapAllocatedSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getSize() {
++        return cctx.cache().size();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getKeySize() {
++        return cctx.cache().size();
++    }
++
++    /** {@inheritDoc} */
++    @Override public boolean isEmpty() {
++        return cctx.cache().isEmpty();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getDhtEvictQueueCurrentSize() {
++        return cctx.isNear() ?
++                dhtCtx != null ? dhtCtx.evicts().evictQueueSize() : -1
++                : cctx.evicts().evictQueueSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxCommitQueueSize() {
++        return cctx.tm().commitQueueSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxThreadMapSize() {
++        return cctx.tm().threadMapSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxXidMapSize() {
++        return cctx.tm().idMapSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxPrepareQueueSize() {
++        return cctx.tm().prepareQueueSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxStartVersionCountsSize() {
++        return cctx.tm().startVersionCountsSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxCommittedVersionsSize() {
++        return cctx.tm().committedVersionsSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxRolledbackVersionsSize() {
++        return cctx.tm().rolledbackVersionsSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtThreadMapSize() {
++        return cctx.isNear() && dhtCtx != null ? dhtCtx.tm().threadMapSize() : -1;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtXidMapSize() {
++        return cctx.isNear() && dhtCtx != null ? dhtCtx.tm().idMapSize() : -1;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtCommitQueueSize() {
++        return cctx.isNear() && dhtCtx != null ? dhtCtx.tm().commitQueueSize() :
-1;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtPrepareQueueSize() {
++        return cctx.isNear() && dhtCtx != null ? dhtCtx.tm().prepareQueueSize()
: -1;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtStartVersionCountsSize() {
++        return cctx.isNear() && dhtCtx != null ? dhtCtx.tm().startVersionCountsSize()
: -1;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtCommittedVersionsSize() {
++        return cctx.isNear() && dhtCtx != null ? dhtCtx.tm().committedVersionsSize()
: -1;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtRolledbackVersionsSize() {
++        return cctx.isNear() && dhtCtx != null ? dhtCtx.tm().rolledbackVersionsSize()
: -1;
++    }
++
++    /** {@inheritDoc} */
++    @Override public boolean isWriteBehindEnabled() {
++        return store != null;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindFlushSize() {
++        return store != null ? store.getWriteBehindFlushSize() : -1;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindFlushThreadCount() {
++        return store != null ? store.getWriteBehindFlushThreadCount() : -1;
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getWriteBehindFlushFrequency() {
++        return store != null ? store.getWriteBehindFlushFrequency() : -1;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindStoreBatchSize() {
++        return store != null ? store.getWriteBehindStoreBatchSize() : -1;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindTotalCriticalOverflowCount() {
++        return store != null ? store.getWriteBehindTotalCriticalOverflowCount() : -1;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindCriticalOverflowCount() {
++        return store != null ? store.getWriteBehindCriticalOverflowCount() : -1;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindErrorRetryCount() {
++        return store != null ? store.getWriteBehindErrorRetryCount() : -1;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindBufferSize() {
++        return store != null ? store.getWriteBehindBufferSize() : -1;
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getAverageTxCommitTime() {
++        long timeNanos = commitTimeNanos.get();
++        long commitsCnt = txCommits.get();
++
++        if (timeNanos == 0 || commitsCnt == 0)
++            return 0;
++
++        return ((1f * timeNanos) / commitsCnt) / NANOS_IN_MICROSECOND;
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getAverageTxRollbackTime() {
++        long timeNanos = rollbackTimeNanos.get();
++        long rollbacksCnt = txRollbacks.get();
++
++        if (timeNanos == 0 || rollbacksCnt == 0)
++            return 0;
++
++        return ((1f * timeNanos) / rollbacksCnt) / NANOS_IN_MICROSECOND;
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheTxCommits() {
++        return txCommits.get();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheTxRollbacks() {
++        return txRollbacks.get();
++    }
++
++    /**
++     * Clear metrics.
++     */
++    public void clear() {
++        reads.set(0);
++        writes.set(0);
++        rmCnt.set(0);
++        hits.set(0);
++        misses.set(0);
++        evictCnt.set(0);
++        txCommits.set(0);
++        txRollbacks.set(0);
++        putTimeNanos.set(0);
++        removeTimeNanos.set(0);
++        getTimeNanos.set(0);
++        commitTimeNanos.set(0);
++        rollbackTimeNanos.set(0);
++
++        if (delegate != null)
++            delegate.clear();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheHits() {
++        return hits.get();
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getCacheHitPercentage() {
++        long hits0 = hits.get();
++        long gets0 = reads.get();
++
++        if (hits0 == 0)
++            return 0;
++
++        return (float) hits0 / gets0 * 100.0f;
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheMisses() {
++        return misses.get();
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getCacheMissPercentage() {
++        long misses0 = misses.get();
++        long reads0 = reads.get();
++
++        if (misses0 == 0) {
++            return 0;
++        }
++
++        return (float) misses0 / reads0 * 100.0f;
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheGets() {
++        return reads.get();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCachePuts() {
++        return writes.get();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheRemovals() {
++        return rmCnt.get();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheEvictions() {
++        return evictCnt.get();
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getAverageGetTime() {
++        long timeNanos = getTimeNanos.get();
++        long readsCnt = reads.get();
++
++        if (timeNanos == 0 || readsCnt == 0)
++            return 0;
++
++        return ((1f * timeNanos) / readsCnt) / NANOS_IN_MICROSECOND;
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getAveragePutTime() {
++        long timeNanos = putTimeNanos.get();
++        long putsCnt = writes.get();
++
++        if (timeNanos == 0 || putsCnt == 0)
++            return 0;
++
++        return ((1f * timeNanos) / putsCnt) / NANOS_IN_MICROSECOND;
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getAverageRemoveTime() {
++        long timeNanos = removeTimeNanos.get();
++        long removesCnt = rmCnt.get();
++
++        if (timeNanos == 0 || removesCnt == 0)
++            return 0;
++
++        return ((1f * timeNanos) / removesCnt) / NANOS_IN_MICROSECOND;
++    }
++
++    /**
++     * Cache read callback.
++     * @param isHit Hit or miss flag.
++     */
++    public void onRead(boolean isHit) {
++        reads.incrementAndGet();
++
++        if (isHit)
++            hits.incrementAndGet();
++        else
++            misses.incrementAndGet();
++
++        if (delegate != null)
++            delegate.onRead(isHit);
++    }
++
++    /**
++     * Cache write callback.
++     */
++    public void onWrite() {
++        writes.incrementAndGet();
++
++        if (delegate != null)
++            delegate.onWrite();
++    }
++
++    /**
++     * Cache remove callback.
++     */
++    public void onRemove(){
++        rmCnt.incrementAndGet();
++
++        if (delegate != null)
++            delegate.onRemove();
++    }
++
++    /**
++     * Cache remove callback.
++     */
++    public void onEvict() {
++        evictCnt.incrementAndGet();
++
++        if (delegate != null)
++            delegate.onEvict();
++    }
++
++    /**
++     * Transaction commit callback.
++     */
++    public void onTxCommit(long duration) {
++        txCommits.incrementAndGet();
++        commitTimeNanos.addAndGet(duration);
++
++        if (delegate != null) {
++            delegate.onTxCommit(duration);
++        }
++    }
++
++    /**
++     * Transaction rollback callback.
++     */
++    public void onTxRollback(long duration) {
++        txRollbacks.incrementAndGet();
++        rollbackTimeNanos.addAndGet(duration);
++
++        if (delegate != null)
++            delegate.onTxRollback(duration);
++    }
++
++
++    /**
++     * Increments the get time accumulator.
++     *
++     * @param duration the time taken in nanoseconds.
++     */
++    public void addGetTimeNanos(long duration) {
++        getTimeNanos.addAndGet(duration);
++
++        if (delegate != null)
++            delegate.addGetTimeNanos(duration);
++    }
++
++    /**
++     * Increments the put time accumulator.
++     *
++     * @param duration the time taken in nanoseconds.
++     */
++    public void addPutTimeNanos(long duration) {
++        putTimeNanos.addAndGet(duration);
++
++        if (delegate != null)
++            delegate.addPutTimeNanos(duration);
++    }
++
++    /**
++     * Increments the remove time accumulator.
++     *
++     * @param duration the time taken in nanoseconds.
++     */
++    public void addRemoveTimeNanos(long duration) {
++        removeTimeNanos.addAndGet(duration);
++
++        if (delegate != null)
++            delegate.addRemoveTimeNanos(duration);
++    }
++
++    /**
++     * Increments remove and get time accumulators.
++     *
++     * @param duration the time taken in nanoseconds.
++     */
++    public void addRemoveAndGetTimeNanos(long duration) {
++        removeTimeNanos.addAndGet(duration);
++        getTimeNanos.addAndGet(duration);
++
++        if (delegate != null)
++            delegate.addRemoveAndGetTimeNanos(duration);
++    }
++
++    /**
++     * Increments put and get time accumulators.
++     *
++     * @param duration the time taken in nanoseconds.
++     */
++    public void addPutAndGetTimeNanos(long duration) {
++        putTimeNanos.addAndGet(duration);
++        getTimeNanos.addAndGet(duration);
++
++        if (delegate != null)
++            delegate.addPutAndGetTimeNanos(duration);
++    }
++
++    /** {@inheritDoc} */
++    @Override public String toString() {
++        return S.toString(CacheMetricsAdapter.class, this);
++    }
++}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/c7a9a1db/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsSnapshot.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsSnapshot.java
index 0000000,0000000..23c757c
new file mode 100644
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMetricsSnapshot.java
@@@ -1,0 -1,0 +1,559 @@@
++/*
++ * 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.cache.*;
++import org.apache.ignite.internal.util.typedef.internal.*;
++
++import java.io.*;
++
++/**
++ * Metrics snapshot.
++ */
++class CacheMetricsSnapshot implements CacheMetrics, Externalizable {
++    /** */
++    private static final long serialVersionUID = 0L;
++
++    /** Number of reads. */
++    private long reads = 0;
++
++    /** Number of puts. */
++    private long puts = 0;
++
++    /** Number of hits. */
++    private long hits = 0;
++
++    /** Number of misses. */
++    private long misses = 0;
++
++    /** Number of transaction commits. */
++    private long txCommits = 0;
++
++    /** Number of transaction rollbacks. */
++    private long txRollbacks = 0;
++
++    /** Number of evictions. */
++    private long evicts = 0;
++
++    /** Number of removed entries. */
++    private long removes = 0;
++
++    /** Put time taken nanos. */
++    private float putAvgTimeNanos = 0;
++
++    /** Get time taken nanos. */
++    private float getAvgTimeNanos = 0;
++
++    /** Remove time taken nanos. */
++    private float removeAvgTimeNanos = 0;
++
++    /** Commit transaction time taken nanos. */
++    private float commitAvgTimeNanos = 0;
++
++    /** Commit transaction time taken nanos. */
++    private float rollbackAvgTimeNanos = 0;
++
++    /** Cache name */
++    private String cacheName;
++
++    /** Number of entries that was swapped to disk. */
++    private long overflowSize;
++
++    /** Number of entries stored in off-heap memory. */
++    private long offHeapEntriesCount;
++
++    /** Memory size allocated in off-heap. */
++    private long offHeapAllocatedSize;
++
++    /** Number of non-{@code null} values in the cache. */
++    private int size;
++
++    /** Number of keys in the cache, possibly with {@code null} values. */
++    private int keySize;
++
++    /** Cache is empty. */
++    private boolean isEmpty;
++
++    /** Gets current size of evict queue used to batch up evictions. */
++    private int dhtEvictQueueCurrentSize;
++
++    /** Transaction per-thread map size. */
++    private int txThreadMapSize;
++
++    /** Transaction per-Xid map size. */
++    private int txXidMapSize;
++
++    /** Committed transaction queue size. */
++    private int txCommitQueueSize;
++
++    /** Prepared transaction queue size. */
++    private int txPrepareQueueSize;
++
++    /** Start version counts map size. */
++    private int txStartVersionCountsSize;
++
++    /** Number of cached committed transaction IDs. */
++    private int txCommittedVersionsSize;
++
++    /** Number of cached rolled back transaction IDs. */
++    private int txRolledbackVersionsSize;
++
++    /** DHT thread map size. */
++    private int txDhtThreadMapSize;
++
++    /** Transaction DHT per-Xid map size. */
++    private int txDhtXidMapSize;
++
++    /** Committed DHT transaction queue size. */
++    private int txDhtCommitQueueSize;
++
++    /** Prepared DHT transaction queue size. */
++    private int txDhtPrepareQueueSize;
++
++    /** DHT start version counts map size. */
++    private int txDhtStartVersionCountsSize;
++
++    /** Number of cached committed DHT transaction IDs. */
++    private int txDhtCommittedVersionsSize;
++
++    /** Number of cached rolled back DHT transaction IDs. */
++    private int txDhtRolledbackVersionsSize;
++
++    /** Write-behind is enabled. */
++    private boolean isWriteBehindEnabled;
++
++    /** Buffer size that triggers flush procedure. */
++    private int writeBehindFlushSize;
++
++    /** Count of worker threads. */
++    private int writeBehindFlushThreadCount;
++
++    /** Flush frequency in milliseconds. */
++    private long writeBehindFlushFrequency;
++
++    /** Maximum size of batch. */
++    private int writeBehindStoreBatchSize;
++
++    /** Count of cache overflow events since start. */
++    private int writeBehindTotalCriticalOverflowCount;
++
++    /** Count of cache overflow events since start. */
++    private int writeBehindCriticalOverflowCount;
++
++    /** Count of entries in store-retry state. */
++    private int writeBehindErrorRetryCount;
++
++    /** Total count of entries in cache store internal buffer. */
++    private int writeBehindBufferSize;
++
++    /**
++     * Create snapshot for given metrics.
++     *
++     * @param m Cache metrics.
++     */
++    public CacheMetricsSnapshot(CacheMetrics m) {
++        reads = m.getCacheGets();
++        puts = m.getCachePuts();
++        hits = m.getCacheHits();
++        misses = m.getCacheMisses();
++        txCommits = m.getCacheTxCommits();
++        txRollbacks = m.getCacheTxRollbacks();
++        evicts = m.getCacheEvictions();
++        removes = m.getCacheRemovals();
++
++        putAvgTimeNanos = m.getAveragePutTime();
++        getAvgTimeNanos = m.getAverageGetTime();
++        removeAvgTimeNanos = m.getAverageRemoveTime();
++        commitAvgTimeNanos = m.getAverageTxCommitTime();
++        rollbackAvgTimeNanos = m.getAverageTxRollbackTime();
++
++        cacheName = m.name();
++        overflowSize = m.getOverflowSize();
++        offHeapEntriesCount = m.getOffHeapEntriesCount();
++        offHeapAllocatedSize = m.getOffHeapAllocatedSize();
++        size = m.getSize();
++        keySize = m.getKeySize();
++        isEmpty = m.isEmpty();
++        dhtEvictQueueCurrentSize = m.getDhtEvictQueueCurrentSize();
++        txThreadMapSize = m.getTxThreadMapSize();
++        txXidMapSize = m.getTxXidMapSize();
++        txCommitQueueSize = m.getTxCommitQueueSize();
++        txPrepareQueueSize = m.getTxPrepareQueueSize();
++        txStartVersionCountsSize = m.getTxStartVersionCountsSize();
++        txCommittedVersionsSize = m.getTxCommittedVersionsSize();
++        txRolledbackVersionsSize = m.getTxRolledbackVersionsSize();
++        txDhtThreadMapSize = m.getTxDhtThreadMapSize();
++        txDhtXidMapSize = m.getTxDhtXidMapSize();
++        txDhtCommitQueueSize = m.getTxDhtCommitQueueSize();
++        txDhtPrepareQueueSize = m.getTxDhtPrepareQueueSize();
++        txDhtStartVersionCountsSize = m.getTxDhtStartVersionCountsSize();
++        txDhtCommittedVersionsSize = m.getTxDhtCommittedVersionsSize();
++        txDhtRolledbackVersionsSize = m.getTxDhtRolledbackVersionsSize();
++        isWriteBehindEnabled = m.isWriteBehindEnabled();
++        writeBehindFlushSize = m.getWriteBehindFlushSize();
++        writeBehindFlushThreadCount = m.getWriteBehindFlushThreadCount();
++        writeBehindFlushFrequency = m.getWriteBehindFlushFrequency();
++        writeBehindStoreBatchSize = m.getWriteBehindStoreBatchSize();
++        writeBehindTotalCriticalOverflowCount = m.getWriteBehindTotalCriticalOverflowCount();
++        writeBehindCriticalOverflowCount = m.getWriteBehindCriticalOverflowCount();
++        writeBehindErrorRetryCount = m.getWriteBehindErrorRetryCount();
++        writeBehindBufferSize = m.getWriteBehindBufferSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheHits() {
++        return hits;
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getCacheHitPercentage() {
++        if (hits == 0 || reads == 0)
++            return 0;
++
++        return (float) hits / reads * 100.0f;
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheMisses() {
++        return misses;
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getCacheMissPercentage() {
++        if (misses == 0 || reads == 0) {
++            return 0;
++        }
++
++        return (float) misses / reads * 100.0f;
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheGets() {
++        return reads;
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCachePuts() {
++        return puts;
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheRemovals() {
++        return removes;
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheEvictions() {
++        return evicts;
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getAverageGetTime() {
++        return getAvgTimeNanos;
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getAveragePutTime() {
++        return putAvgTimeNanos;
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getAverageRemoveTime() {
++        return removeAvgTimeNanos;
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getAverageTxCommitTime() {
++        return commitAvgTimeNanos;
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getAverageTxRollbackTime() {
++        return rollbackAvgTimeNanos;
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheTxCommits() {
++        return txCommits;
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheTxRollbacks() {
++        return txRollbacks;
++    }
++
++    /** {@inheritDoc} */
++    @Override public String name() {
++        return cacheName;
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getOverflowSize() {
++        return overflowSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getOffHeapEntriesCount() {
++        return offHeapEntriesCount;
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getOffHeapAllocatedSize() {
++        return offHeapAllocatedSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getSize() {
++        return size;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getKeySize() {
++        return keySize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public boolean isEmpty() {
++        return isEmpty;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getDhtEvictQueueCurrentSize() {
++        return dhtEvictQueueCurrentSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxThreadMapSize() {
++        return txThreadMapSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxXidMapSize() {
++        return txXidMapSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxCommitQueueSize() {
++        return txCommitQueueSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxPrepareQueueSize() {
++        return txPrepareQueueSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxStartVersionCountsSize() {
++        return txStartVersionCountsSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxCommittedVersionsSize() {
++        return txCommittedVersionsSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxRolledbackVersionsSize() {
++        return txRolledbackVersionsSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtThreadMapSize() {
++        return txDhtThreadMapSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtXidMapSize() {
++        return txDhtXidMapSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtCommitQueueSize() {
++        return txDhtCommitQueueSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtPrepareQueueSize() {
++        return txDhtPrepareQueueSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtStartVersionCountsSize() {
++        return txDhtStartVersionCountsSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtCommittedVersionsSize() {
++        return txDhtCommittedVersionsSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtRolledbackVersionsSize() {
++        return txDhtRolledbackVersionsSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public boolean isWriteBehindEnabled() {
++        return isWriteBehindEnabled;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindFlushSize() {
++        return writeBehindFlushSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindFlushThreadCount() {
++        return writeBehindFlushThreadCount;
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getWriteBehindFlushFrequency() {
++        return writeBehindFlushFrequency;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindStoreBatchSize() {
++        return writeBehindStoreBatchSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindTotalCriticalOverflowCount() {
++        return writeBehindTotalCriticalOverflowCount;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindCriticalOverflowCount() {
++        return writeBehindCriticalOverflowCount;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindErrorRetryCount() {
++        return writeBehindErrorRetryCount;
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindBufferSize() {
++        return writeBehindBufferSize;
++    }
++
++    /** {@inheritDoc} */
++    @Override public void writeExternal(ObjectOutput out) throws IOException {
++        out.writeLong(reads);
++        out.writeLong(puts);
++        out.writeLong(hits);
++        out.writeLong(misses);
++        out.writeLong(txCommits);
++        out.writeLong(txRollbacks);
++        out.writeLong(removes);
++        out.writeLong(evicts);
++
++        out.writeFloat(putAvgTimeNanos);
++        out.writeFloat(getAvgTimeNanos);
++        out.writeFloat(removeAvgTimeNanos);
++        out.writeFloat(commitAvgTimeNanos);
++        out.writeFloat(rollbackAvgTimeNanos);
++
++        out.writeObject(cacheName);
++        out.writeLong(overflowSize);
++        out.writeLong(offHeapEntriesCount);
++        out.writeLong(offHeapAllocatedSize);
++        out.writeInt(size);
++        out.writeInt(keySize);
++        out.writeBoolean(isEmpty);
++        out.writeInt(dhtEvictQueueCurrentSize);
++        out.writeInt(txThreadMapSize);
++        out.writeInt(txXidMapSize);
++        out.writeInt(txCommitQueueSize);
++        out.writeInt(txPrepareQueueSize);
++        out.writeInt(txStartVersionCountsSize);
++        out.writeInt(txCommittedVersionsSize);
++        out.writeInt(txRolledbackVersionsSize);
++        out.writeInt(txDhtThreadMapSize);
++        out.writeInt(txDhtXidMapSize);
++        out.writeInt(txDhtCommitQueueSize);
++        out.writeInt(txDhtPrepareQueueSize);
++        out.writeInt(txDhtStartVersionCountsSize);
++        out.writeInt(txDhtCommittedVersionsSize);
++        out.writeInt(txDhtRolledbackVersionsSize);
++        out.writeBoolean(isWriteBehindEnabled);
++        out.writeInt(writeBehindFlushSize);
++        out.writeInt(writeBehindFlushThreadCount);
++        out.writeLong(writeBehindFlushFrequency);
++        out.writeInt(writeBehindStoreBatchSize);
++        out.writeInt(writeBehindTotalCriticalOverflowCount);
++        out.writeInt(writeBehindCriticalOverflowCount);
++        out.writeInt(writeBehindErrorRetryCount);
++        out.writeInt(writeBehindBufferSize);
++    }
++
++    /** {@inheritDoc} */
++    @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
{
++        reads = in.readLong();
++        puts = in.readLong();
++        hits = in.readLong();
++        misses = in.readLong();
++        txCommits = in.readLong();
++        txRollbacks = in.readLong();
++        removes = in.readLong();
++        evicts = in.readLong();
++
++        putAvgTimeNanos = in.readFloat();
++        getAvgTimeNanos = in.readFloat();
++        removeAvgTimeNanos = in.readFloat();
++        commitAvgTimeNanos = in.readFloat();
++        rollbackAvgTimeNanos = in.readFloat();
++
++        cacheName = (String)in.readObject();
++        overflowSize = in.readLong();
++        offHeapEntriesCount = in.readLong();
++        offHeapAllocatedSize = in.readLong();
++        size = in.readInt();
++        keySize = in.readInt();
++        isEmpty = in.readBoolean();
++        dhtEvictQueueCurrentSize = in.readInt();
++        txThreadMapSize = in.readInt();
++        txXidMapSize = in.readInt();
++        txCommitQueueSize = in.readInt();
++        txPrepareQueueSize = in.readInt();
++        txStartVersionCountsSize = in.readInt();
++        txCommittedVersionsSize = in.readInt();
++        txRolledbackVersionsSize = in.readInt();
++        txDhtThreadMapSize = in.readInt();
++        txDhtXidMapSize = in.readInt();
++        txDhtCommitQueueSize = in.readInt();
++        txDhtPrepareQueueSize = in.readInt();
++        txDhtStartVersionCountsSize = in.readInt();
++        txDhtCommittedVersionsSize = in.readInt();
++        txDhtRolledbackVersionsSize = in.readInt();
++        isWriteBehindEnabled = in.readBoolean();
++        writeBehindFlushSize = in.readInt();
++        writeBehindFlushThreadCount = in.readInt();
++        writeBehindFlushFrequency = in.readLong();
++        writeBehindStoreBatchSize = in.readInt();
++        writeBehindTotalCriticalOverflowCount = in.readInt();
++        writeBehindCriticalOverflowCount = in.readInt();
++        writeBehindErrorRetryCount = in.readInt();
++        writeBehindBufferSize = in.readInt();
++    }
++
++    /** {@inheritDoc} */
++    @Override public String toString() {
++        return S.toString(CacheMetricsSnapshot.class, this);
++    }
++}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/c7a9a1db/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMxBeanImpl.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMxBeanImpl.java
index 0000000,0000000..2c23594
new file mode 100644
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheMxBeanImpl.java
@@@ -1,0 -1,0 +1,275 @@@
++/*
++ * 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.*;
++import org.apache.ignite.cache.*;
++
++/**
++ * Management bean that provides access to {@link IgniteCache IgniteCache}.
++ */
++class CacheMxBeanImpl implements IgniteCacheMxBean {
++    /** Cache. */
++    private GridCacheAdapter<?, ?> cache;
++
++    /**
++     * Creates MBean;
++     *
++     * @param cache Cache.
++     */
++    CacheMxBeanImpl(GridCacheAdapter<?, ?> cache) {
++        assert cache != null;
++
++        this.cache = cache;
++    }
++
++    /** {@inheritDoc} */
++    @Override public String name() {
++        return cache.metrics0().name();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getOverflowSize() {
++        return cache.metrics0().getOverflowSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getOffHeapEntriesCount() {
++        return cache.metrics0().getOffHeapEntriesCount();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getOffHeapAllocatedSize() {
++        return cache.metrics0().getOffHeapAllocatedSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getSize() {
++        return cache.metrics0().getSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getKeySize() {
++        return cache.metrics0().getKeySize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public boolean isEmpty() {
++        return cache.metrics0().isEmpty();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getDhtEvictQueueCurrentSize() {
++        return cache.metrics0().getDhtEvictQueueCurrentSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxCommitQueueSize() {
++        return cache.metrics0().getTxCommitQueueSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxThreadMapSize() {
++        return cache.metrics0().getTxThreadMapSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxXidMapSize() {
++        return cache.metrics0().getTxXidMapSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxPrepareQueueSize() {
++        return cache.metrics0().getTxPrepareQueueSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxStartVersionCountsSize() {
++        return cache.metrics0().getTxStartVersionCountsSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxCommittedVersionsSize() {
++        return cache.metrics0().getTxCommittedVersionsSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxRolledbackVersionsSize() {
++        return cache.metrics0().getTxRolledbackVersionsSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtThreadMapSize() {
++        return cache.metrics0().getTxDhtThreadMapSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtXidMapSize() {
++        return cache.metrics0().getTxDhtXidMapSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtCommitQueueSize() {
++        return cache.metrics0().getTxDhtCommitQueueSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtPrepareQueueSize() {
++        return cache.metrics0().getTxDhtPrepareQueueSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtStartVersionCountsSize() {
++        return cache.metrics0().getTxDhtStartVersionCountsSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtCommittedVersionsSize() {
++        return cache.metrics0().getTxDhtCommittedVersionsSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getTxDhtRolledbackVersionsSize() {
++        return cache.metrics0().getTxDhtRolledbackVersionsSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public boolean isWriteBehindEnabled() {
++        return cache.metrics0().isWriteBehindEnabled();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindFlushSize() {
++        return cache.metrics0().getWriteBehindFlushSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindFlushThreadCount() {
++        return cache.metrics0().getWriteBehindFlushThreadCount();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getWriteBehindFlushFrequency() {
++        return cache.metrics0().getWriteBehindFlushFrequency();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindStoreBatchSize() {
++        return cache.metrics0().getWriteBehindStoreBatchSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindTotalCriticalOverflowCount() {
++        return cache.metrics0().getWriteBehindTotalCriticalOverflowCount();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindCriticalOverflowCount() {
++        return cache.metrics0().getWriteBehindCriticalOverflowCount();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindErrorRetryCount() {
++        return cache.metrics0().getWriteBehindErrorRetryCount();
++    }
++
++    /** {@inheritDoc} */
++    @Override public int getWriteBehindBufferSize() {
++        return cache.metrics0().getWriteBehindBufferSize();
++    }
++
++    /** {@inheritDoc} */
++    @Override public void clear() {
++        cache.metrics0().clear();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheHits() {
++        return cache.metrics0().getCacheHits();
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getCacheHitPercentage() {
++        return cache.metrics0().getCacheHitPercentage();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheMisses() {
++        return cache.metrics0().getCacheMisses();
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getCacheMissPercentage() {
++        return cache.metrics0().getCacheMissPercentage();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheGets() {
++        return cache.metrics0().getCacheGets();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCachePuts() {
++        return cache.metrics0().getCachePuts();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheRemovals() {
++        return cache.metrics0().getCacheRemovals();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheEvictions() {
++        return cache.metrics0().getCacheEvictions();
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getAverageGetTime() {
++        return cache.metrics0().getAverageGetTime();
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getAveragePutTime() {
++        return cache.metrics0().getAveragePutTime();
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getAverageRemoveTime() {
++        return cache.metrics0().getAverageRemoveTime();
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getAverageTxCommitTime() {
++        return cache.metrics0().getAverageTxCommitTime();
++    }
++
++    /** {@inheritDoc} */
++    @Override public float getAverageTxRollbackTime() {
++        return cache.metrics0().getAverageTxRollbackTime();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheTxCommits() {
++        return cache.metrics0().getCacheTxCommits();
++    }
++
++    /** {@inheritDoc} */
++    @Override public long getCacheTxRollbacks() {
++        return cache.metrics0().getCacheTxRollbacks();
++    }
++}


Mime
View raw message