com.gemstone.gemfire.internal.cache.persistence.soplog.SortedOplogStatistics Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of gemfire-core Show documentation
Show all versions of gemfire-core Show documentation
TIBCO ComputeDB store based off Pivotal GemFireXD
/*
* Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
*
* Licensed 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. See accompanying
* LICENSE file.
*/
package com.gemstone.gemfire.internal.cache.persistence.soplog;
import static com.gemstone.gemfire.distributed.internal.DistributionStats.getStatTime;
import com.gemstone.gemfire.StatisticDescriptor;
import com.gemstone.gemfire.Statistics;
import com.gemstone.gemfire.StatisticsFactory;
import com.gemstone.gemfire.StatisticsType;
import com.gemstone.gemfire.StatisticsTypeFactory;
import com.gemstone.gemfire.internal.DummyStatisticsFactory;
import com.gemstone.gemfire.internal.StatisticsTypeFactoryImpl;
public class SortedOplogStatistics {
private final Statistics stats;
private final IOOperation read;
private final ScanOperation scan;
private final IOOperation write;
private final IOOperation put;
private final IOOperation flush;
private final IOOperation minorCompaction;
private final IOOperation majorCompaction;
private final BloomOperation bloom;
private final TimedOperation clear;
private final TimedOperation destroy;
private final IOOperation blockRead;
private final CacheOperation blockCache;
private final int activeFilesId;
private final int inactiveFilesId;
private final int activeReadersId;
private final int storeUsageBytesId;
public SortedOplogStatistics(String typeName, String name) {
this(new DummyStatisticsFactory(), typeName, name);
}
public SortedOplogStatistics(StatisticsFactory factory, String typeName, String name) {
StatisticsTypeFactory tf = StatisticsTypeFactoryImpl.singleton();
StatisticDescriptor readCount = tf.createLongCounter("reads", "The total number of read operations", "ops");
StatisticDescriptor readInProgress = tf.createLongGauge("readsInProgress", "The number of read operations in progress", "ops");
StatisticDescriptor readTime = tf.createLongCounter("readTime", "The total time spent reading from disk", "nanoseconds");
StatisticDescriptor readBytes = tf.createLongCounter("readBytes", "The total number of bytes read from disk", "bytes");
StatisticDescriptor readErrors = tf.createLongCounter("readErrors", "The total number of read errors", "errors");
StatisticDescriptor scanCount = tf.createLongCounter("scans", "The total number of scan operations", "ops");
StatisticDescriptor scanInProgress = tf.createLongGauge("scansInProgress", "The number of scan operations in progress", "ops");
StatisticDescriptor scanTime = tf.createLongCounter("scanTime", "The total time scanner was operational", "nanoseconds");
StatisticDescriptor scanBytes = tf.createLongCounter("scanBytes", "The total number of bytes scanned from disk", "bytes");
StatisticDescriptor scanErrors = tf.createLongCounter("scanErrors", "The total number of scan errors", "errors");
StatisticDescriptor scanIterations = tf.createLongCounter("scanIterations", "The total number of scan iterations", "ops");
StatisticDescriptor scanIterationTime = tf.createLongCounter("scanIterationTime", "The total time spent scanning from persistence layer", "nanoseconds");
StatisticDescriptor writeCount = tf.createLongCounter("writes", "The total number of write operations", "ops");
StatisticDescriptor writeInProgress = tf.createLongGauge("writesInProgress", "The number of write operations in progress", "ops");
StatisticDescriptor writeTime = tf.createLongCounter("writeTime", "The total time spent writing to disk", "nanoseconds");
StatisticDescriptor writeBytes = tf.createLongCounter("writeBytes", "The total number of bytes written to disk", "bytes");
StatisticDescriptor writeErrors = tf.createLongCounter("writeErrors", "The total number of write errors", "errors");
StatisticDescriptor putCount = tf.createLongCounter("puts", "The total number of put operations", "ops");
StatisticDescriptor putInProgress = tf.createLongGauge("putsInProgress", "The number of put operations in progress", "ops");
StatisticDescriptor putTime = tf.createLongCounter("putTime", "The total time spent in put calls", "nanoseconds");
StatisticDescriptor putBytes = tf.createLongCounter("putBytes", "The total number of bytes put", "bytes");
StatisticDescriptor putErrors = tf.createLongCounter("putErrors", "The total number of put errors", "errors");
StatisticDescriptor flushCount = tf.createLongCounter("flushes", "The total number of flush operations", "ops");
StatisticDescriptor flushInProgress = tf.createLongGauge("flushesInProgress", "The number of flush operations in progress", "ops");
StatisticDescriptor flushTime = tf.createLongCounter("flushTime", "The total time spent flushing to disk", "nanoseconds");
StatisticDescriptor flushBytes = tf.createLongCounter("flushBytes", "The total number of bytes flushed to disk", "bytes");
StatisticDescriptor flushErrors = tf.createLongCounter("flushErrors", "The total number of flush errors", "errors");
StatisticDescriptor minorCompactionCount = tf.createLongCounter("minorCompactions", "The total number of minor compaction operations", "ops");
StatisticDescriptor minorCompactionInProgress = tf.createLongGauge("minorCompactionsInProgress", "The number of minor compaction operations in progress", "ops");
StatisticDescriptor minorCompactionTime = tf.createLongCounter("minorCompactionTime", "The total time spent in minor compactions", "nanoseconds");
StatisticDescriptor minorCompactionBytes = tf.createLongCounter("minorCompactionBytes", "The total number of bytes collected during minor compactions", "bytes");
StatisticDescriptor minorCompactionErrors = tf.createLongCounter("minorCompactionErrors", "The total number of minor compaction errors", "errors");
StatisticDescriptor majorCompactionCount = tf.createLongCounter("majorCompactions", "The total number of major compaction operations", "ops");
StatisticDescriptor majorCompactionInProgress = tf.createLongGauge("majorCompactionsInProgress", "The number of major compaction operations in progress", "ops");
StatisticDescriptor majorCompactionTime = tf.createLongCounter("majorCompactionTime", "The total time spent in major compactions", "nanoseconds");
StatisticDescriptor majorCompactionBytes = tf.createLongCounter("majorCompactionBytes", "The total number of bytes collected during major compactions", "bytes");
StatisticDescriptor majorCompactionErrors = tf.createLongCounter("majorCompactionErrors", "The total number of major compaction errors", "errors");
StatisticDescriptor bloomCount = tf.createLongCounter("bloomFilterCheck", "The total number of Bloom Filter checks", "ops");
StatisticDescriptor bloomInProgress = tf.createLongGauge("bloomFilterChecksInProgress", "The number of Bloom Filter checks in progress", "ops");
StatisticDescriptor bloomTime = tf.createLongCounter("bloomFilterCheckTime", "The total time spent checking the Bloom Filter", "nanoseconds");
StatisticDescriptor bloomErrors = tf.createLongCounter("bloomFilterErrors", "The total number of Bloom Filter errors", "errors");
StatisticDescriptor bloomFalsePositive = tf.createLongCounter("bloomFilterFalsePositives", "The total number of Bloom Filter false positives", "false positives");
StatisticDescriptor clearCount = tf.createLongCounter("clears", "The total number of clear operations", "ops");
StatisticDescriptor clearInProgress = tf.createLongGauge("clearsInProgress", "The number of clear operations in progress", "ops");
StatisticDescriptor clearTime = tf.createLongCounter("clearTime", "The total time spent in clear operations", "nanoseconds");
StatisticDescriptor clearErrors = tf.createLongGauge("clearErrors", "The total number of clear errors", "errors");
StatisticDescriptor destroyCount = tf.createLongCounter("destroys", "The total number of destroy operations", "ops");
StatisticDescriptor destroyInProgress = tf.createLongGauge("destroysInProgress", "The number of destroy operations in progress", "ops");
StatisticDescriptor destroyTime = tf.createLongCounter("destroyTime", "The total time spent in destroy operations", "nanoseconds");
StatisticDescriptor destroyErrors = tf.createLongGauge("destroyErrors", "The total number of destroy errors", "errors");
StatisticDescriptor brCount = tf.createLongCounter("blockReads", "The total number of block read operations", "ops");
StatisticDescriptor brInProgress = tf.createLongGauge("blockReadsInProgress", "The number of block read operations in progress", "ops");
StatisticDescriptor brTime = tf.createLongCounter("blockReadTime", "The total time spent reading blocks from disk", "nanoseconds");
StatisticDescriptor brBytes = tf.createLongCounter("blockReadBytes", "The total number of block bytes read from disk", "bytes");
StatisticDescriptor brErrors = tf.createLongCounter("blockReadErrors", "The total number of block read errors", "errors");
StatisticDescriptor bcMisses = tf.createLongCounter("blockCacheMisses", "The total number of block cache misses", "misses");
StatisticDescriptor bcHits = tf.createLongCounter("blockCacheHits", "The total number of block cache hits", "hits");
StatisticDescriptor bcCached = tf.createLongGauge("blocksCached", "The current number of cached blocks", "blocks");
StatisticDescriptor bcBytesCached = tf.createLongGauge("blockBytesCached", "The current number of bytes cached", "bytes");
StatisticDescriptor bcBytesEvicted = tf.createLongCounter("blockBytesEvicted", "The total number of bytes cached", "bytes");
StatisticDescriptor activeFileCount = tf.createLongGauge("activeFileCount", "The total number of active files", "files");
StatisticDescriptor inactiveFileCount = tf.createLongGauge("inactiveFileCount", "The total number of inactive files", "files");
StatisticDescriptor activeReaderCount = tf.createLongGauge("activeReaderCount", "The total number of active file readers", "files");
StatisticDescriptor storeUsageBytes = tf.createLongGauge("storeUsageBytes", "The total volume occupied on persistent store", "bytes");
StatisticsType type = tf.createType(typeName,
"Statistics about structured I/O operations for a region", new StatisticDescriptor[] {
readCount, readInProgress, readTime, readBytes, readErrors,
scanCount, scanInProgress, scanTime, scanBytes, scanErrors, scanIterations, scanIterationTime,
writeCount, writeInProgress, writeTime, writeBytes, writeErrors,
putCount, putInProgress, putTime, putBytes, putErrors,
flushCount, flushInProgress, flushTime, flushBytes, flushErrors,
minorCompactionCount, minorCompactionInProgress, minorCompactionTime, minorCompactionBytes, minorCompactionErrors,
majorCompactionCount, majorCompactionInProgress, majorCompactionTime, majorCompactionBytes, majorCompactionErrors,
bloomCount, bloomInProgress, bloomTime, bloomErrors, bloomFalsePositive,
clearCount, clearInProgress, clearTime, clearErrors,
destroyCount, destroyInProgress, destroyTime, destroyErrors,
brCount, brInProgress, brTime, brBytes, brErrors,
bcMisses, bcHits, bcCached, bcBytesCached, bcBytesEvicted,
activeFileCount, inactiveFileCount, activeReaderCount, storeUsageBytes
});
read = new IOOperation(readCount.getId(), readInProgress.getId(), readTime.getId(), readBytes.getId(), readErrors.getId());
scan = new ScanOperation(scanCount.getId(), scanInProgress.getId(), scanTime.getId(), scanBytes.getId(), scanErrors.getId(), scanIterations.getId(), scanIterationTime.getId());
write = new IOOperation(writeCount.getId(), writeInProgress.getId(), writeTime.getId(), writeBytes.getId(), writeErrors.getId());
put = new IOOperation(putCount.getId(), putInProgress.getId(), putTime.getId(), putBytes.getId(), putErrors.getId());
flush = new IOOperation(flushCount.getId(), flushInProgress.getId(), flushTime.getId(), flushBytes.getId(), flushErrors.getId());
minorCompaction = new IOOperation(minorCompactionCount.getId(), minorCompactionInProgress.getId(), minorCompactionTime.getId(), minorCompactionBytes.getId(), minorCompactionErrors.getId());
majorCompaction = new IOOperation(majorCompactionCount.getId(), majorCompactionInProgress.getId(), majorCompactionTime.getId(), majorCompactionBytes.getId(), majorCompactionErrors.getId());
bloom = new BloomOperation(bloomCount.getId(), bloomInProgress.getId(), bloomTime.getId(), bloomErrors.getId(), bloomFalsePositive.getId());
clear = new TimedOperation(clearCount.getId(), clearInProgress.getId(), clearTime.getId(), clearErrors.getId());
destroy = new TimedOperation(destroyCount.getId(), destroyInProgress.getId(), destroyTime.getId(), destroyErrors.getId());
blockRead = new IOOperation(brCount.getId(), brInProgress.getId(), brTime.getId(), brBytes.getId(), brErrors.getId());
blockCache = new CacheOperation(bcMisses.getId(), bcHits.getId(), bcCached.getId(), bcBytesCached.getId(), bcBytesEvicted.getId());
activeFilesId = activeFileCount.getId();
inactiveFilesId = inactiveFileCount.getId();
activeReadersId = activeReaderCount.getId();
storeUsageBytesId = storeUsageBytes.getId();
stats = factory.createAtomicStatistics(type, name);
}
public void close() {
stats.close();
}
public Statistics getStats() {
return stats;
}
public IOOperation getRead() {
return read;
}
public ScanOperation getScan() {
return scan;
}
public IOOperation getWrite() {
return write;
}
public IOOperation getPut() {
return put;
}
public IOOperation getFlush() {
return flush;
}
public IOOperation getMinorCompaction() {
return minorCompaction;
}
public IOOperation getMajorCompaction() {
return majorCompaction;
}
public BloomOperation getBloom() {
return bloom;
}
public TimedOperation getClear() {
return clear;
}
public TimedOperation getDestroy() {
return destroy;
}
public IOOperation getBlockRead() {
return blockRead;
}
public CacheOperation getBlockCache() {
return blockCache;
}
public long getActiveFileCount() {
return stats.getLong(activeFilesId);
}
public long getInactiveFileCount() {
return stats.getLong(inactiveFilesId);
}
public long getActiveReaderCount() {
return stats.getLong(activeReadersId);
}
public void incActiveFiles(int amt) {
stats.incLong(activeFilesId, amt);
assert stats.getLong(activeFilesId) >= 0;
}
public void incInactiveFiles(int amt) {
stats.incLong(inactiveFilesId, amt);
assert stats.getLong(inactiveFilesId) >= 0;
}
public void incActiveReaders(int amt) {
stats.incLong(activeReadersId, amt);
assert stats.getLong(activeReadersId) >= 0;
}
public long getStoreUsageBytes() {
return stats.getLong(storeUsageBytesId);
}
public void incStoreUsageBytes(long amt) {
stats.incLong(storeUsageBytesId, amt);
assert stats.getLong(storeUsageBytesId) >= 0;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("read = {").append(read).append("}\n");
sb.append("scan = {").append(scan).append("}\n");
sb.append("write = {").append(write).append("}\n");
sb.append("put = {").append(put).append("}\n");
sb.append("flush = {").append(flush).append("}\n");
sb.append("minorCompaction = {").append(minorCompaction).append("}\n");
sb.append("majorCompaction = {").append(majorCompaction).append("}\n");
sb.append("bloom = {").append(bloom).append("}\n");
sb.append("clear = {").append(clear).append("}\n");
sb.append("destroy = {").append(destroy).append("}\n");
sb.append("blockRead = {").append(blockRead).append("}\n");
sb.append("blockCache = {").append(blockCache).append("}\n");
sb.append("activeFiles = ").append(stats.getLong(activeFilesId)).append("\n");
sb.append("inactiveFiles = ").append(stats.getLong(inactiveFilesId)).append("\n");
sb.append("activeReaders = ").append(stats.getLong(activeReadersId)).append("\n");
sb.append("storeUsageBytes = ").append(stats.getLong(storeUsageBytesId)).append("\n");
return sb.toString();
}
public class TimedOperation {
protected final int countId;
protected final int inProgressId;
protected final int timeId;
private final int errorsId;
public TimedOperation(int count, int inProgress, int time, int errors) {
this.countId = count;
this.inProgressId = inProgress;
this.timeId = time;
this.errorsId = errors;
}
public long begin() {
stats.incLong(inProgressId, 1);
return getStatTime();
}
public long end(long start) {
stats.incLong(inProgressId, -1);
stats.incLong(countId, 1);
stats.incLong(timeId, getStatTime() - start);
return getStatTime();
}
public void error(long start) {
end(start);
stats.incLong(errorsId, 1);
}
public long getCount() {
return stats.getLong(countId);
}
public long getInProgress() {
return stats.getLong(inProgressId);
}
public long getTime() {
return stats.getLong(timeId);
}
public long getErrors() {
return stats.getLong(errorsId);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("count=").append(getCount());
sb.append(";inProgress=").append(getInProgress());
sb.append(";errors=").append(getErrors());
sb.append(";time=").append(getTime());
return sb.toString();
}
}
public class IOOperation extends TimedOperation {
protected final int bytesId;
public IOOperation(int count, int inProgress, int time, int bytes, int errors) {
super(count, inProgress, time, errors);
this.bytesId = bytes;
}
public long end(long bytes, long start) {
stats.incLong(bytesId, bytes);
return super.end(start);
}
public long getBytes() {
return stats.getLong(bytesId);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder(super.toString());
sb.append(";bytes=").append(getBytes());
return sb.toString();
}
}
public class ScanOperation extends IOOperation {
private final int iterationsId;
private final int iterationTimeId;
public ScanOperation(int count, int inProgress, int time, int bytes, int errors, int iterCount, int iterTime) {
super(count, inProgress, time, bytes, errors);
iterationsId = iterCount;
iterationTimeId = iterTime;
}
public long beginIteration() {
return getStatTime();
}
public void endIteration(long bytes, long start){
stats.incLong(iterationsId, 1);
stats.incLong(bytesId, bytes);
stats.incLong(iterationTimeId, getStatTime() - start);
}
public long getIterations() {
return stats.getLong(iterationsId);
}
public long getIterationTime() {
return stats.getLong(iterationTimeId);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder(super.toString());
sb.append(";iterations=").append(getIterations());
sb.append(";iterationTime=").append(getIterationTime());
return sb.toString();
}
}
public class BloomOperation extends TimedOperation {
private final int falsePositiveId;
public BloomOperation(int count, int inProgress, int time, int errors, int falsePositive) {
super(count, inProgress, time, errors);
this.falsePositiveId = falsePositive;
}
public void falsePositive() {
stats.incLong(falsePositiveId, 1);
}
public long getFalsePositives() {
return stats.getLong(falsePositiveId);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder(super.toString());
sb.append(";falsePositives=").append(getFalsePositives());
return sb.toString();
}
}
public class CacheOperation {
private final int missesId;
private final int hitsId;
private final int cachedId;
private final int bytesCachedId;
private final int bytesEvictedId;
public CacheOperation(int missesId, int hitsId, int cachedId,
int bytesCachedId, int bytesEvictedId) {
this.missesId = missesId;
this.hitsId = hitsId;
this.cachedId = cachedId;
this.bytesCachedId = bytesCachedId;
this.bytesEvictedId = bytesEvictedId;
}
public void store(long bytes) {
stats.incLong(cachedId, 1);
stats.incLong(bytesCachedId, bytes);
}
public void evict(long bytes) {
stats.incLong(cachedId, -1);
stats.incLong(bytesCachedId, -bytes);
stats.incLong(bytesEvictedId, bytes);
}
public void hit() {
stats.incLong(hitsId, 1);
}
public void miss() {
stats.incLong(missesId, 1);
}
public long getMisses() {
return stats.getLong(missesId);
}
public long getHits() {
return stats.getLong(hitsId);
}
public long getCached() {
return stats.getLong(cachedId);
}
public long getBytesCached() {
return stats.getLong(bytesCachedId);
}
public long getBytesEvicted() {
return stats.getLong(bytesEvictedId);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("misses=").append(getMisses());
sb.append(";hits=").append(getHits());
sb.append(";cached=").append(getCached());
sb.append(";bytesCached=").append(getBytesCached());
sb.append(";bytesEvicted=").append(getBytesEvicted());
return sb.toString();
}
}
}