draft

Author: hx235

HISTORY.md

@@ -8,7 +8,7 @@
 
 ### New Features
 * Add statistics rocksdb.secondary.cache.filter.hits, rocksdb.secondary.cache.index.hits, and rocksdb.secondary.cache.filter.hits
-* Add new statistics rocksdb.table.prefetch.tail.read.bytes to report number of bytes read in prefetching contents from the end of SST table during table open
+* Add new statistics rocksdb.table.open.prefetch.tail.read.bytes, rocksdb.table.open.prefetch.tail.{miss|hit}
 
 ## 8.0.0 (02/19/2023)
 ### Behavior changes

file/file_prefetch_buffer.cc

@@ -162,6 +162,9 @@ Status FilePrefetchBuffer::Prefetch(const IOOptions& opts,
 
   Status s = Read(opts, reader, rate_limiter_priority, read_len, chunk_len,
                   rounddown_offset, curr_);
+  if (s.ok() && usage_ == FilePrefetchBufferUsage::kTableOpenPrefetchTail) {
+    RecordInHistogram(stats_, TABLE_OPEN_PREFETCH_TAIL_READ_BYTES, read_len);
+  }
   return s;
 }
 
@@ -612,7 +615,13 @@ bool FilePrefetchBuffer::TryReadFromCache(const IOOptions& opts,
   if (track_min_offset_ && offset < min_offset_read_) {
     min_offset_read_ = static_cast<size_t>(offset);
   }
-  if (!enable_ || (offset < bufs_[curr_].offset_)) {
+  if (!enable_) {
+    return false;
+  }
+  if (offset < bufs_[curr_].offset_) {
+    if (usage_ == FilePrefetchBufferUsage::kTableOpenPrefetchTail) {
+      RecordTick(stats_, TABLE_OPEN_PREFETCH_TAIL_MISS);
+    }
     return false;
   }
 
@@ -635,6 +644,9 @@ bool FilePrefetchBuffer::TryReadFromCache(const IOOptions& opts,
           if (!IsEligibleForPrefetch(offset, n)) {
             // Ignore status as Prefetch is not called.
             s.PermitUncheckedError();
+            if (usage_ == FilePrefetchBufferUsage::kTableOpenPrefetchTail) {
+              RecordTick(stats_, TABLE_OPEN_PREFETCH_TAIL_MISS);
+            }
             return false;
           }
         }
@@ -648,17 +660,26 @@ bool FilePrefetchBuffer::TryReadFromCache(const IOOptions& opts,
 #ifndef NDEBUG
         IGNORE_STATUS_IF_ERROR(s);
 #endif
+        if (usage_ == FilePrefetchBufferUsage::kTableOpenPrefetchTail) {
+          RecordTick(stats_, TABLE_OPEN_PREFETCH_TAIL_MISS);
+        }
         return false;
       }
       readahead_size_ = std::min(max_readahead_size_, readahead_size_ * 2);
     } else {
+      if (usage_ == FilePrefetchBufferUsage::kTableOpenPrefetchTail) {
+        RecordTick(stats_, TABLE_OPEN_PREFETCH_TAIL_MISS);
+      }
       return false;
     }
   }
   UpdateReadPattern(offset, n, false /*decrease_readaheadsize*/);
 
   uint64_t offset_in_buffer = offset - bufs_[curr_].offset_;
   *result = Slice(bufs_[curr_].buffer_.BufferStart() + offset_in_buffer, n);
+  if (usage_ == FilePrefetchBufferUsage::kTableOpenPrefetchTail) {
+    RecordTick(stats_, TABLE_OPEN_PREFETCH_TAIL_HIT);
+  }
   return true;
 }
 
@@ -684,11 +705,17 @@ bool FilePrefetchBuffer::TryReadFromCacheAsync(
       bufs_[curr_].buffer_.Clear();
       bufs_[curr_ ^ 1].buffer_.Clear();
       explicit_prefetch_submitted_ = false;
+      if (usage_ == FilePrefetchBufferUsage::kTableOpenPrefetchTail) {
+        RecordTick(stats_, TABLE_OPEN_PREFETCH_TAIL_MISS);
+      }
       return false;
     }
   }
 
   if (!explicit_prefetch_submitted_ && offset < bufs_[curr_].offset_) {
+    if (usage_ == FilePrefetchBufferUsage::kTableOpenPrefetchTail) {
+      RecordTick(stats_, TABLE_OPEN_PREFETCH_TAIL_MISS);
+    }
     return false;
   }
 
@@ -714,6 +741,9 @@ bool FilePrefetchBuffer::TryReadFromCacheAsync(
         if (!IsEligibleForPrefetch(offset, n)) {
           // Ignore status as Prefetch is not called.
           s.PermitUncheckedError();
+          if (usage_ == FilePrefetchBufferUsage::kTableOpenPrefetchTail) {
+            RecordTick(stats_, TABLE_OPEN_PREFETCH_TAIL_MISS);
+          }
           return false;
         }
       }
@@ -729,10 +759,16 @@ bool FilePrefetchBuffer::TryReadFromCacheAsync(
 #ifndef NDEBUG
         IGNORE_STATUS_IF_ERROR(s);
 #endif
+        if (usage_ == FilePrefetchBufferUsage::kTableOpenPrefetchTail) {
+          RecordTick(stats_, TABLE_OPEN_PREFETCH_TAIL_MISS);
+        }
         return false;
       }
       prefetched = explicit_prefetch_submitted_ ? false : true;
     } else {
+      if (usage_ == FilePrefetchBufferUsage::kTableOpenPrefetchTail) {
+        RecordTick(stats_, TABLE_OPEN_PREFETCH_TAIL_MISS);
+      }
       return false;
     }
   }
@@ -748,6 +784,9 @@ bool FilePrefetchBuffer::TryReadFromCacheAsync(
   if (prefetched) {
     readahead_size_ = std::min(max_readahead_size_, readahead_size_ * 2);
   }
+  if (usage_ == FilePrefetchBufferUsage::kTableOpenPrefetchTail) {
+    RecordTick(stats_, TABLE_OPEN_PREFETCH_TAIL_HIT);
+  }
   return true;
 }
 

file/file_prefetch_buffer.h

@@ -54,6 +54,11 @@ struct BufferInfo {
   uint32_t pos_ = 0;
 };
 
+enum FilePrefetchBufferUsage {
+  kTableOpenPrefetchTail,
+  kUnknown,
+};
+
 // FilePrefetchBuffer is a smart buffer to store and read data from a file.
 class FilePrefetchBuffer {
  public:
@@ -78,13 +83,13 @@ class FilePrefetchBuffer {
   // and max_readahead_size are passed in.
   // A user can construct a FilePrefetchBuffer without any arguments, but use
   // `Prefetch` to load data into the buffer.
-  FilePrefetchBuffer(size_t readahead_size = 0, size_t max_readahead_size = 0,
-                     bool enable = true, bool track_min_offset = false,
-                     bool implicit_auto_readahead = false,
-                     uint64_t num_file_reads = 0,
-                     uint64_t num_file_reads_for_auto_readahead = 0,
-                     FileSystem* fs = nullptr, SystemClock* clock = nullptr,
-                     Statistics* stats = nullptr)
+  FilePrefetchBuffer(
+      size_t readahead_size = 0, size_t max_readahead_size = 0,
+      bool enable = true, bool track_min_offset = false,
+      bool implicit_auto_readahead = false, uint64_t num_file_reads = 0,
+      uint64_t num_file_reads_for_auto_readahead = 0, FileSystem* fs = nullptr,
+      SystemClock* clock = nullptr, Statistics* stats = nullptr,
+      FilePrefetchBufferUsage usage = FilePrefetchBufferUsage::kUnknown)
       : curr_(0),
         readahead_size_(readahead_size),
         initial_auto_readahead_size_(readahead_size),
@@ -100,7 +105,8 @@ class FilePrefetchBuffer {
         explicit_prefetch_submitted_(false),
         fs_(fs),
         clock_(clock),
-        stats_(stats) {
+        stats_(stats),
+        usage_(usage) {
     assert((num_file_reads_ >= num_file_reads_for_auto_readahead_ + 1) ||
            (num_file_reads_ == 0));
     // If ReadOptions.async_io is enabled, data is asynchronously filled in
@@ -442,5 +448,7 @@ class FilePrefetchBuffer {
   FileSystem* fs_;
   SystemClock* clock_;
   Statistics* stats_;
+
+  FilePrefetchBufferUsage usage_;
 };
 }  // namespace ROCKSDB_NAMESPACE

file/prefetch_test.cc

@@ -125,6 +125,7 @@ TEST_P(PrefetchTest, Basic) {
   std::unique_ptr<Env> env(new CompositeEnvWrapper(env_, fs));
   Options options;
   SetGenericOptions(env.get(), use_direct_io, options);
+  options.statistics = CreateDBStatistics();
 
   const int kNumKeys = 1100;
   int buff_prefetch_count = 0;
@@ -167,9 +168,25 @@ TEST_P(PrefetchTest, Basic) {
   Slice least(start_key.data(), start_key.size());
   Slice greatest(end_key.data(), end_key.size());
 
+  HistogramData prev_table_open_prefetch_tail_read;
+  options.statistics->histogramData(TABLE_OPEN_PREFETCH_TAIL_READ_BYTES,
+                                    &prev_table_open_prefetch_tail_read);
+  const uint64_t prev_table_open_prefetch_tail_miss =
+      options.statistics->getTickerCount(TABLE_OPEN_PREFETCH_TAIL_MISS);
+  const uint64_t prev_table_open_prefetch_tail_hit =
+      options.statistics->getTickerCount(TABLE_OPEN_PREFETCH_TAIL_HIT);
+
   // commenting out the line below causes the example to work correctly
   ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &least, &greatest));
 
+  HistogramData cur_table_open_prefetch_tail_read;
+  options.statistics->histogramData(TABLE_OPEN_PREFETCH_TAIL_READ_BYTES,
+                                    &cur_table_open_prefetch_tail_read);
+  const uint64_t cur_table_open_prefetch_tail_miss =
+      options.statistics->getTickerCount(TABLE_OPEN_PREFETCH_TAIL_MISS);
+  const uint64_t cur_table_open_prefetch_tail_hit =
+      options.statistics->getTickerCount(TABLE_OPEN_PREFETCH_TAIL_HIT);
+
   if (support_prefetch && !use_direct_io) {
     // If underline file system supports prefetch, and directIO is not enabled
     // make sure prefetch() is called and FilePrefetchBuffer is not used.
@@ -182,6 +199,12 @@ TEST_P(PrefetchTest, Basic) {
     // used.
     ASSERT_FALSE(fs->IsPrefetchCalled());
     ASSERT_GT(buff_prefetch_count, 0);
+    ASSERT_GT(cur_table_open_prefetch_tail_read.count,
+              prev_table_open_prefetch_tail_read.count);
+    ASSERT_GT(cur_table_open_prefetch_tail_hit,
+              prev_table_open_prefetch_tail_hit);
+    ASSERT_GE(cur_table_open_prefetch_tail_miss,
+              prev_table_open_prefetch_tail_miss);
     buff_prefetch_count = 0;
   }
 

include/rocksdb/statistics.h

@@ -420,6 +420,15 @@ enum Tickers : uint32_t {
   SECONDARY_CACHE_INDEX_HITS,
   SECONDARY_CACHE_DATA_HITS,
 
+  // Number of read into the prefetched tail (see
+  // `TABLE_OPEN_PREFETCH_TAIL_READ_BYTES`)
+  // that can't find its data for table open
+  TABLE_OPEN_PREFETCH_TAIL_MISS,
+  // Number of read into the prefetched tail (see
+  // `TABLE_OPEN_PREFETCH_TAIL_READ_BYTES`)
+  // that finds its data for table open
+  TABLE_OPEN_PREFETCH_TAIL_HIT,
+
   TICKER_ENUM_MAX
 };
 
@@ -533,9 +542,9 @@ enum Histograms : uint32_t {
   // Wait time for aborting async read in FilePrefetchBuffer destructor
   ASYNC_PREFETCH_ABORT_MICROS,
 
-  // Number of bytes read in prefetching contents from the end of SST table
-  // during table open
-  TABLE_PREFETCH_TAIL_READ_BYTES,
+  // Number of bytes read in RocksDB's prefetching contents (as opposed to file
+  // system's prefetch) from the end of SST table during block based table open
+  TABLE_OPEN_PREFETCH_TAIL_READ_BYTES,
 
   HISTOGRAM_ENUM_MAX
 };

java/rocksjni/portal.h

@@ -5125,6 +5125,10 @@ class TickerTypeJni {
         return -0x38;
       case ROCKSDB_NAMESPACE::Tickers::SECONDARY_CACHE_DATA_HITS:
         return -0x39;
+      case ROCKSDB_NAMESPACE::Tickers::TABLE_OPEN_PREFETCH_TAIL_MISS:
+        return -0x3A;
+      case ROCKSDB_NAMESPACE::Tickers::TABLE_OPEN_PREFETCH_TAIL_HIT:
+        return -0x3B;
       case ROCKSDB_NAMESPACE::Tickers::TICKER_ENUM_MAX:
         // 0x5F was the max value in the initial copy of tickers to Java.
         // Since these values are exposed directly to Java clients, we keep
@@ -5482,6 +5486,10 @@ class TickerTypeJni {
         return ROCKSDB_NAMESPACE::Tickers::SECONDARY_CACHE_INDEX_HITS;
       case -0x39:
         return ROCKSDB_NAMESPACE::Tickers::SECONDARY_CACHE_DATA_HITS;
+      case -0x3A:
+        return ROCKSDB_NAMESPACE::Tickers::TABLE_OPEN_PREFETCH_TAIL_MISS;
+      case -0x3B:
+        return ROCKSDB_NAMESPACE::Tickers::TABLE_OPEN_PREFETCH_TAIL_HIT;
       case 0x5F:
         // 0x5F was the max value in the initial copy of tickers to Java.
         // Since these values are exposed directly to Java clients, we keep
@@ -5609,7 +5617,7 @@ class HistogramTypeJni {
         return 0x37;
       case ASYNC_PREFETCH_ABORT_MICROS:
         return 0x38;
-      case ROCKSDB_NAMESPACE::Histograms::TABLE_PREFETCH_TAIL_READ_BYTES:
+      case ROCKSDB_NAMESPACE::Histograms::TABLE_OPEN_PREFETCH_TAIL_READ_BYTES:
         return 0x39;
       case ROCKSDB_NAMESPACE::Histograms::HISTOGRAM_ENUM_MAX:
         // 0x1F for backwards compatibility on current minor version.
@@ -5728,7 +5736,8 @@ class HistogramTypeJni {
       case 0x38:
         return ROCKSDB_NAMESPACE::Histograms::ASYNC_PREFETCH_ABORT_MICROS;
       case 0x39:
-        return ROCKSDB_NAMESPACE::Histograms::TABLE_PREFETCH_TAIL_READ_BYTES;
+        return ROCKSDB_NAMESPACE::Histograms::
+            TABLE_OPEN_PREFETCH_TAIL_READ_BYTES;
       case 0x1F:
         // 0x1F for backwards compatibility on current minor version.
         return ROCKSDB_NAMESPACE::Histograms::HISTOGRAM_ENUM_MAX;

java/src/main/java/org/rocksdb/HistogramType.java

@@ -163,10 +163,11 @@ public enum HistogramType {
   ASYNC_READ_BYTES((byte) 0x33),
 
   /**
-   * Number of bytes read in prefetching contents from the end of SST table
-   * during table open
+   * Number of bytes read in RocksDB's prefetching contents
+   * (as opposed to file system's prefetch)
+   * from the end of SST table during block based table open
    */
-  TABLE_PREFETCH_TAIL_READ_BYTES((byte) 0x39),
+  TABLE_OPEN_PREFETCH_TAIL_READ_BYTES((byte) 0x39),
 
   // 0x1F for backwards compatibility on current minor version.
   HISTOGRAM_ENUM_MAX((byte) 0x1F);

java/src/main/java/org/rocksdb/TickerType.java

@@ -740,6 +740,20 @@ public enum TickerType {
      */
     BLOB_DB_CACHE_BYTES_WRITE((byte) -0x34),
 
+    /**
+     * Number of read into the prefetched tail (see
+     * `TABLE_OPEN_PREFETCH_TAIL_READ_BYTES`)
+     * that can't find its data for table open
+     */
+    TABLE_OPEN_PREFETCH_TAIL_MISS((byte) -0x3A),
+
+    /**
+     * Number of read into the prefetched tail (see
+     * `TABLE_OPEN_PREFETCH_TAIL_READ_BYTES`)
+     * that finds its data for table open
+     */
+    TABLE_OPEN_PREFETCH_TAIL_HIT((byte) -0x3B),
+
     TICKER_ENUM_MAX((byte) 0x5F);
 
     private final byte value;

monitoring/statistics.cc

@@ -216,7 +216,10 @@ const std::vector<std::pair<Tickers, std::string>> TickersNameMap = {
     {ASYNC_READ_ERROR_COUNT, "rocksdb.async.read.error.count"},
     {SECONDARY_CACHE_FILTER_HITS, "rocksdb.secondary.cache.filter.hits"},
     {SECONDARY_CACHE_INDEX_HITS, "rocksdb.secondary.cache.index.hits"},
-    {SECONDARY_CACHE_DATA_HITS, "rocksdb.secondary.cache.data.hits"}};
+    {SECONDARY_CACHE_DATA_HITS, "rocksdb.secondary.cache.data.hits"},
+    {TABLE_OPEN_PREFETCH_TAIL_MISS, "rocksdb.table.open.prefetch.tail.miss"},
+    {TABLE_OPEN_PREFETCH_TAIL_HIT, "rocksdb.table.open.prefetch.tail.hit"},
+};
 
 const std::vector<std::pair<Histograms, std::string>> HistogramsNameMap = {
     {DB_GET, "rocksdb.db.get.micros"},
@@ -272,7 +275,8 @@ const std::vector<std::pair<Histograms, std::string>> HistogramsNameMap = {
     {MULTIGET_IO_BATCH_SIZE, "rocksdb.multiget.io.batch.size"},
     {NUM_LEVEL_READ_PER_MULTIGET, "rocksdb.num.level.read.per.multiget"},
     {ASYNC_PREFETCH_ABORT_MICROS, "rocksdb.async.prefetch.abort.micros"},
-    {TABLE_PREFETCH_TAIL_READ_BYTES, "rocksdb.table.prefetch.tail.read.bytes"},
+    {TABLE_OPEN_PREFETCH_TAIL_READ_BYTES,
+     "rocksdb.table.open.prefetch.tail.read.bytes"},
 };
 
 std::shared_ptr<Statistics> CreateDBStatistics() {

table/block_based/block_based_table_reader.cc

@@ -834,7 +834,6 @@ Status BlockBasedTable::PrefetchTail(
   if (!file->use_direct_io() && !force_direct_prefetch) {
     if (!file->Prefetch(prefetch_off, prefetch_len, ro.rate_limiter_priority)
              .IsNotSupported()) {
-      RecordInHistogram(stats, TABLE_PREFETCH_TAIL_READ_BYTES, prefetch_len);
       prefetch_buffer->reset(new FilePrefetchBuffer(
           0 /* readahead_size */, 0 /* max_readahead_size */,
           false /* enable */, true /* track_min_offset */));
@@ -843,17 +842,19 @@ Status BlockBasedTable::PrefetchTail(
   }
 
   // Use `FilePrefetchBuffer`
-  prefetch_buffer->reset(
-      new FilePrefetchBuffer(0 /* readahead_size */, 0 /* max_readahead_size */,
-                             true /* enable */, true /* track_min_offset */));
+  prefetch_buffer->reset(new FilePrefetchBuffer(
+      0 /* readahead_size */, 0 /* max_readahead_size */, true /* enable */,
+      true /* track_min_offset */, false /* implicit_auto_readahead */,
+      0 /* num_file_reads */, 0 /* num_file_reads_for_auto_readahead */,
+      nullptr /* fs */, nullptr /* clock */, stats,
+      FilePrefetchBufferUsage::kTableOpenPrefetchTail));
 
   IOOptions opts;
   Status s = file->PrepareIOOptions(ro, opts);
   if (s.ok()) {
     s = (*prefetch_buffer)
             ->Prefetch(opts, file, prefetch_off, prefetch_len,
                        ro.rate_limiter_priority);
-    RecordInHistogram(stats, TABLE_PREFETCH_TAIL_READ_BYTES, prefetch_len);
   }
   return s;
 }

table/block_based/block_based_table_reader_test.cc

@@ -232,18 +232,12 @@ TEST_P(BlockBasedTableReaderTest, MultiGet) {
 
   std::unique_ptr<BlockBasedTable> table;
   Options options;
-  options.statistics = CreateDBStatistics();
   ImmutableOptions ioptions(options);
   FileOptions foptions;
   foptions.use_direct_reads = use_direct_reads_;
   InternalKeyComparator comparator(options.comparator);
   NewBlockBasedTableReader(foptions, ioptions, comparator, table_name, &table);
 
-  HistogramData table_prefetch_tail_read_bytes;
-  options.statistics->histogramData(TABLE_PREFETCH_TAIL_READ_BYTES,
-                                    &table_prefetch_tail_read_bytes);
-  ASSERT_EQ(table_prefetch_tail_read_bytes.count, 1);
-
   // Ensure that keys are not in cache before MultiGet.
   for (auto& key : keys) {
     ASSERT_FALSE(table->TEST_KeyInCache(ReadOptions(), key));