From f5d632fa7ad94021bde4f4f6401a1bfcc2759c2a Mon Sep 17 00:00:00 2001 From: Yuki Morishita Date: Fri, 9 Aug 2013 14:10:36 -0500 Subject: [PATCH] Add KeyCacheHitRate metric to CF metrics patch by yukim; reviewed by jbellis for CASSANDRA-5868 --- CHANGES.txt | 1 + .../db/compaction/CompactionController.java | 2 +- .../cassandra/io/sstable/SSTableReader.java | 36 +++++++++++++++++-- .../metrics/ColumnFamilyMetrics.java | 21 +++++++++++ .../cassandra/service/CacheService.java | 4 +-- 5 files changed, 59 insertions(+), 5 deletions(-) diff --git a/CHANGES.txt b/CHANGES.txt index 30ce976ef7..f8c472c3ef 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -13,6 +13,7 @@ * Future-proof inter-major-version schema migrations (CASSANDRA-5845) * (Hadoop) add CqlPagingRecordReader support for ReversedType in Thrift table (CASSANDRA-5718) + * Add KeyCacheHitRate metric to CF metrics (CASSANDRA-5868) Merged from 1.1: * Correctly validate sparse composite cells in scrub (CASSANDRA-5855) diff --git a/src/java/org/apache/cassandra/db/compaction/CompactionController.java b/src/java/org/apache/cassandra/db/compaction/CompactionController.java index f91c7a5d70..14c96251f7 100644 --- a/src/java/org/apache/cassandra/db/compaction/CompactionController.java +++ b/src/java/org/apache/cassandra/db/compaction/CompactionController.java @@ -109,7 +109,7 @@ public class CompactionController { // if we don't have bloom filter(bf_fp_chance=1.0 or filter file is missing), // we check index file instead. - if (sstable.getBloomFilter() instanceof AlwaysPresentFilter && sstable.getPosition(key, SSTableReader.Operator.EQ) != null) + if (sstable.getBloomFilter() instanceof AlwaysPresentFilter && sstable.getPosition(key, SSTableReader.Operator.EQ, false) != null) return false; else if (sstable.getBloomFilter().isPresent(key.key)) return false; diff --git a/src/java/org/apache/cassandra/io/sstable/SSTableReader.java b/src/java/org/apache/cassandra/io/sstable/SSTableReader.java index 412e4c190f..8efa4f1337 100644 --- a/src/java/org/apache/cassandra/io/sstable/SSTableReader.java +++ b/src/java/org/apache/cassandra/io/sstable/SSTableReader.java @@ -23,6 +23,7 @@ import java.util.*; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.*; +import java.util.concurrent.atomic.AtomicLong; import com.google.common.util.concurrent.RateLimiter; import org.slf4j.Logger; @@ -102,6 +103,9 @@ public class SSTableReader extends SSTable private final SSTableMetadata sstableMetadata; + private final AtomicLong keyCacheHit = new AtomicLong(0); + private final AtomicLong keyCacheRequest = new AtomicLong(0); + public static long getApproximateKeyCount(Iterable sstables) { long count = 0; @@ -764,8 +768,20 @@ public class SSTableReader extends SSTable private RowIndexEntry getCachedPosition(KeyCacheKey unifiedKey, boolean updateStats) { - if (keyCache != null && keyCache.getCapacity() > 0) - return updateStats ? keyCache.get(unifiedKey) : keyCache.getInternal(unifiedKey); + if (keyCache != null && keyCache.getCapacity() > 0) { + if (updateStats) + { + RowIndexEntry cachedEntry = keyCache.get(unifiedKey); + keyCacheRequest.incrementAndGet(); + if (cachedEntry != null) + keyCacheHit.incrementAndGet(); + return cachedEntry; + } + else + { + return keyCache.getInternal(unifiedKey); + } + } return null; } @@ -1217,6 +1233,22 @@ public class SSTableReader extends SSTable return new File(descriptor.filenameFor(component)).lastModified(); } + /** + * @return Number of key cache hit + */ + public long getKeyCacheHit() + { + return keyCacheHit.get(); + } + + /** + * @return Number of key cache request + */ + public long getKeyCacheRequest() + { + return keyCacheRequest.get(); + } + /** * @param sstables * @return true if all desired references were acquired. Otherwise, it will unreference any partial acquisition, and return false. diff --git a/src/java/org/apache/cassandra/metrics/ColumnFamilyMetrics.java b/src/java/org/apache/cassandra/metrics/ColumnFamilyMetrics.java index d7ae74561a..d59cd50b73 100644 --- a/src/java/org/apache/cassandra/metrics/ColumnFamilyMetrics.java +++ b/src/java/org/apache/cassandra/metrics/ColumnFamilyMetrics.java @@ -22,6 +22,7 @@ import com.yammer.metrics.core.Counter; import com.yammer.metrics.core.Gauge; import com.yammer.metrics.core.Histogram; import com.yammer.metrics.core.MetricName; +import com.yammer.metrics.util.RatioGauge; import org.apache.cassandra.db.ColumnFamilyStore; import org.apache.cassandra.db.Table; @@ -76,6 +77,8 @@ public class ColumnFamilyMetrics public final Gauge recentBloomFilterFalseRatio; /** Disk space used by bloom filter */ public final Gauge bloomFilterDiskSpaceUsed; + /** Key cache hit rate for this CF */ + public final Gauge keyCacheHitRate; private final MetricNameFactory factory; @@ -274,6 +277,24 @@ public class ColumnFamilyMetrics return total; } }); + keyCacheHitRate = Metrics.newGauge(factory.createMetricName("KeyCacheHitRate"), new RatioGauge() + { + protected double getNumerator() + { + long hits = 0L; + for (SSTableReader sstable : cfs.getSSTables()) + hits += sstable.getKeyCacheHit(); + return hits; + } + + protected double getDenominator() + { + long requests = 0L; + for (SSTableReader sstable : cfs.getSSTables()) + requests += sstable.getKeyCacheRequest(); + return Math.max(requests, 1); // to avoid NaN. + } + }); } public void updateSSTableIterated(int count) diff --git a/src/java/org/apache/cassandra/service/CacheService.java b/src/java/org/apache/cassandra/service/CacheService.java index f77110c2be..34864f2f46 100644 --- a/src/java/org/apache/cassandra/service/CacheService.java +++ b/src/java/org/apache/cassandra/service/CacheService.java @@ -388,7 +388,7 @@ public class CacheService implements CacheServiceMBean } RowIndexEntry entry = promotedIndexes ? RowIndexEntry.serializer.deserialize(input, reader.descriptor.version) - : reader.getPosition(reader.partitioner.decorateKey(key), Operator.EQ); + : reader.getPosition(reader.partitioner.decorateKey(key), Operator.EQ, false); return Futures.immediateFuture(Pair.create(new KeyCacheKey(reader.descriptor, key), entry)); } @@ -410,7 +410,7 @@ public class CacheService implements CacheServiceMBean for (SSTableReader sstable : cfs.getSSTables()) { - RowIndexEntry entry = sstable.getPosition(dk, Operator.EQ); + RowIndexEntry entry = sstable.getPosition(dk, Operator.EQ, false); if (entry != null) keyCache.put(new KeyCacheKey(sstable.descriptor, key), entry); }