Add tickers BLOCK_CACHE_ERASE & BLOCK_CACHE_ERASE_FAILURES

Author: mm304321141

include/rocksdb/statistics.h

@@ -254,6 +254,12 @@ enum Tickers : uint32_t {
   GC_TOUCH_FILES,
   GC_SKIP_GET_BY_SEQ,
   GC_SKIP_GET_BY_FILE,
+
+  // # of blocks erased from block cache.
+  BLOCK_CACHE_ERASE,
+  // # of failures when erasing blocks from block cache.
+  BLOCK_CACHE_ERASE_FAILURES,
+
   TICKER_ENUM_MAX
 };
 

java/rocksjni/portal.h

@@ -3476,8 +3476,12 @@ class TickerTypeJni {
         return 0x63;
       case TERARKDB_NAMESPACE::Tickers::GC_SKIP_GET_BY_FILE:
         return 0x64;
-      case TERARKDB_NAMESPACE::Tickers::TICKER_ENUM_MAX:
+      case TERARKDB_NAMESPACE::Tickers::BLOCK_CACHE_ERASE:
         return 0x65;
+      case TERARKDB_NAMESPACE::Tickers::BLOCK_CACHE_ERASE_FAILURES:
+        return 0x66;
+      case TERARKDB_NAMESPACE::Tickers::TICKER_ENUM_MAX:
+        return 0x67;
 
       default:
         // undefined/default
@@ -3692,6 +3696,10 @@ class TickerTypeJni {
       case 0x64:
         return TERARKDB_NAMESPACE::Tickers::GC_SKIP_GET_BY_FILE;
       case 0x65:
+        return TERARKDB_NAMESPACE::Tickers::BLOCK_CACHE_ERASE;
+      case 0x66:
+        return TERARKDB_NAMESPACE::Tickers::BLOCK_CACHE_ERASE_FAILURES;
+      case 0x67:
         return TERARKDB_NAMESPACE::Tickers::TICKER_ENUM_MAX;
 
       default:

monitoring/statistics.cc

@@ -27,6 +27,8 @@ const std::vector<std::pair<Tickers, std::string>> TickersNameMap = {
     {BLOCK_CACHE_HIT, "rocksdb.block.cache.hit"},
     {BLOCK_CACHE_ADD, "rocksdb.block.cache.add"},
     {BLOCK_CACHE_ADD_FAILURES, "rocksdb.block.cache.add.failures"},
+    {BLOCK_CACHE_ERASE, "rocksdb.block.cache.erase"},
+    {BLOCK_CACHE_ERASE_FAILURES, "rocksdb.block.cache.erase.failures"},
     {BLOCK_CACHE_INDEX_MISS, "rocksdb.block.cache.index.miss"},
     {BLOCK_CACHE_INDEX_HIT, "rocksdb.block.cache.index.hit"},
     {BLOCK_CACHE_INDEX_ADD, "rocksdb.block.cache.index.add"},

table/block_based_table_reader.cc

@@ -2578,18 +2578,27 @@ Status BlockBasedTable::ForceEvict() {
   auto compressed_cache_key_prefix_size =
       rep_->compressed_cache_key_prefix_size;
 
-  auto do_evict = [=, &cache_key, &compressed_cache_key](uint64_t offset) {
+  uint64_t block_cache_erase_count = 0;
+  uint64_t block_cache_erase_failures_count = 0;
+
+  auto do_evict = [=, &cache_key, &compressed_cache_key,
+                   &block_cache_erase_count,
+                   &block_cache_erase_failures_count](uint64_t offset) {
     if (block_cache) {
       char* end = EncodeVarint64(cache_key + cache_key_prefix_size, offset);
-      block_cache->Erase(
+      bool erased = block_cache->Erase(
           Slice(cache_key, static_cast<size_t>(end - cache_key)));
+      ++block_cache_erase_count;
+      block_cache_erase_failures_count += !erased;
     }
     if (block_cache_compressed) {
       char* end = EncodeVarint64(
           compressed_cache_key + compressed_cache_key_prefix_size, offset);
-      block_cache_compressed->Erase(
+      bool erased = block_cache_compressed->Erase(
           Slice(compressed_cache_key,
                 static_cast<size_t>(end - compressed_cache_key)));
+      ++block_cache_erase_count;
+      block_cache_erase_failures_count += !erased;
     }
   };
 
@@ -2613,6 +2622,11 @@ Status BlockBasedTable::ForceEvict() {
   // IndexBlock
   do_evict(rep_->dummy_index_reader_offset);
 
+  RecordTick(rep_->ioptions.statistics, BLOCK_CACHE_ERASE,
+             block_cache_erase_count);
+  RecordTick(rep_->ioptions.statistics, BLOCK_CACHE_ERASE_FAILURES,
+             block_cache_erase_failures_count);
+
   return Status::OK();
 }
 
@@ -3127,15 +3141,21 @@ void BlockBasedTable::Close() {
   // cleanup index and filter blocks to avoid accessing dangling pointer
   if (!rep_->table_options.no_block_cache) {
     char cache_key[kMaxCacheKeyPrefixSize + kMaxVarint64Length];
+    uint64_t erased_count = 0;
+
     // Get the filter block key
     auto key = GetCacheKey(rep_->cache_key_prefix, rep_->cache_key_prefix_size,
                            rep_->filter_handle, cache_key);
-    rep_->table_options.block_cache.get()->Erase(key);
+    erased_count += rep_->table_options.block_cache.get()->Erase(key);
     // Get the index block key
     key = GetCacheKeyFromOffset(rep_->cache_key_prefix,
                                 rep_->cache_key_prefix_size,
                                 rep_->dummy_index_reader_offset, cache_key);
-    rep_->table_options.block_cache.get()->Erase(key);
+    erased_count += rep_->table_options.block_cache.get()->Erase(key);
+
+    RecordTick(rep_->ioptions.statistics, BLOCK_CACHE_ERASE, 2);
+    RecordTick(rep_->ioptions.statistics, BLOCK_CACHE_ERASE_FAILURES,
+               2 - erased_count);
   }
   rep_->closed = true;
 }

table/partitioned_filter_block.cc

@@ -148,6 +148,10 @@ PartitionedFilterBlockReader::~PartitionedFilterBlockReader() {
   IndexBlockIter biter;
   BlockHandle handle;
   Statistics* kNullStats = nullptr;
+
+  uint64_t block_cache_erase_count = 0;
+  uint64_t block_cache_erase_failures_count = 0;
+
   idx_on_fltr_blk_->NewIterator<IndexBlockIter>(
       &comparator_, comparator_.user_comparator(), &biter, kNullStats, true,
       index_key_includes_seq_, index_value_is_full_);
@@ -157,8 +161,13 @@ PartitionedFilterBlockReader::~PartitionedFilterBlockReader() {
     auto key = BlockBasedTable::GetCacheKey(table_->rep_->cache_key_prefix,
                                             table_->rep_->cache_key_prefix_size,
                                             handle, cache_key);
-    block_cache->Erase(key);
+    bool erased = block_cache->Erase(key);
+    ++block_cache_erase_count;
+    block_cache_erase_failures_count += !erased;
   }
+  RecordTick(statistics(), BLOCK_CACHE_ERASE, block_cache_erase_count);
+  RecordTick(statistics(), BLOCK_CACHE_ERASE_FAILURES,
+             block_cache_erase_failures_count);
 }
 
 bool PartitionedFilterBlockReader::KeyMayMatch(

table/table_reader.h

@@ -99,9 +99,7 @@ class TableReader {
                          bool (*callback_func)(void* arg, const Slice& key,
                                                LazyBuffer&& value));
 
-  virtual Status ForceEvict() {
-    return Status::NotSupported();
-  }
+  virtual Status ForceEvict() { return Status::NotSupported(); }
 
   // Prefetch data corresponding to a give range of keys
   // Typically this functionality is required for table implementations that