@nxtedition/rocksdb 8.2.0 → 8.2.2

package/deps/rocksdb/rocksdb/table/block_based/partitioned_filter_block.cc

@@ -220,45 +220,43 @@ std::unique_ptr<FilterBlockReader> PartitionedFilterBlockReader::Create(
 bool PartitionedFilterBlockReader::KeyMayMatch(
     const Slice& key, const bool no_io, const Slice* const const_ikey_ptr,
     GetContext* get_context, BlockCacheLookupContext* lookup_context,
-    Env::IOPriority rate_limiter_priority) {
+    const ReadOptions& read_options) {
   assert(const_ikey_ptr != nullptr);
   if (!whole_key_filtering()) {
     return true;
   }
 
   return MayMatch(key, no_io, const_ikey_ptr, get_context, lookup_context,
-                  rate_limiter_priority, &FullFilterBlockReader::KeyMayMatch);
+                  read_options, &FullFilterBlockReader::KeyMayMatch);
 }
 
 void PartitionedFilterBlockReader::KeysMayMatch(
     MultiGetRange* range, const bool no_io,
-    BlockCacheLookupContext* lookup_context,
-    Env::IOPriority rate_limiter_priority) {
+    BlockCacheLookupContext* lookup_context, const ReadOptions& read_options) {
   if (!whole_key_filtering()) {
     return;  // Any/all may match
   }
 
-  MayMatch(range, nullptr, no_io, lookup_context, rate_limiter_priority,
+  MayMatch(range, nullptr, no_io, lookup_context, read_options,
            &FullFilterBlockReader::KeysMayMatch2);
 }
 
 bool PartitionedFilterBlockReader::PrefixMayMatch(
     const Slice& prefix, const bool no_io, const Slice* const const_ikey_ptr,
     GetContext* get_context, BlockCacheLookupContext* lookup_context,
-    Env::IOPriority rate_limiter_priority) {
+    const ReadOptions& read_options) {
   assert(const_ikey_ptr != nullptr);
   return MayMatch(prefix, no_io, const_ikey_ptr, get_context, lookup_context,
-                  rate_limiter_priority,
-                  &FullFilterBlockReader::PrefixMayMatch);
+                  read_options, &FullFilterBlockReader::PrefixMayMatch);
 }
 
 void PartitionedFilterBlockReader::PrefixesMayMatch(
     MultiGetRange* range, const SliceTransform* prefix_extractor,
     const bool no_io, BlockCacheLookupContext* lookup_context,
-    Env::IOPriority rate_limiter_priority) {
+    const ReadOptions& read_options) {
   assert(prefix_extractor);
-  MayMatch(range, prefix_extractor, no_io, lookup_context,
-           rate_limiter_priority, &FullFilterBlockReader::PrefixesMayMatch);
+  MayMatch(range, prefix_extractor, no_io, lookup_context, read_options,
+           &FullFilterBlockReader::PrefixesMayMatch);
 }
 
 BlockHandle PartitionedFilterBlockReader::GetFilterPartitionHandle(
@@ -290,8 +288,7 @@ BlockHandle PartitionedFilterBlockReader::GetFilterPartitionHandle(
 Status PartitionedFilterBlockReader::GetFilterPartitionBlock(
     FilePrefetchBuffer* prefetch_buffer, const BlockHandle& fltr_blk_handle,
     bool no_io, GetContext* get_context,
-    BlockCacheLookupContext* lookup_context,
-    Env::IOPriority rate_limiter_priority,
+    BlockCacheLookupContext* lookup_context, const ReadOptions& _read_options,
     CachableEntry<ParsedFullFilterBlock>* filter_block) const {
   assert(table());
   assert(filter_block);
@@ -307,8 +304,7 @@ Status PartitionedFilterBlockReader::GetFilterPartitionBlock(
     }
   }
 
-  ReadOptions read_options;
-  read_options.rate_limiter_priority = rate_limiter_priority;
+  ReadOptions read_options = _read_options;
   if (no_io) {
     read_options.read_tier = kBlockCacheTier;
   }
@@ -326,11 +322,10 @@ Status PartitionedFilterBlockReader::GetFilterPartitionBlock(
 bool PartitionedFilterBlockReader::MayMatch(
     const Slice& slice, bool no_io, const Slice* const_ikey_ptr,
     GetContext* get_context, BlockCacheLookupContext* lookup_context,
-    Env::IOPriority rate_limiter_priority,
-    FilterFunction filter_function) const {
+    const ReadOptions& read_options, FilterFunction filter_function) const {
   CachableEntry<Block_kFilterPartitionIndex> filter_block;
   Status s = GetOrReadFilterBlock(no_io, get_context, lookup_context,
-                                  &filter_block, rate_limiter_priority);
+                                  &filter_block, read_options);
   if (UNLIKELY(!s.ok())) {
     IGNORE_STATUS_IF_ERROR(s);
     return true;
@@ -347,8 +342,8 @@ bool PartitionedFilterBlockReader::MayMatch(
 
   CachableEntry<ParsedFullFilterBlock> filter_partition_block;
   s = GetFilterPartitionBlock(nullptr /* prefetch_buffer */, filter_handle,
-                              no_io, get_context, lookup_context,
-                              rate_limiter_priority, &filter_partition_block);
+                              no_io, get_context, lookup_context, read_options,
+                              &filter_partition_block);
   if (UNLIKELY(!s.ok())) {
     IGNORE_STATUS_IF_ERROR(s);
     return true;
@@ -356,20 +351,17 @@ bool PartitionedFilterBlockReader::MayMatch(
 
   FullFilterBlockReader filter_partition(table(),
                                          std::move(filter_partition_block));
-  return (filter_partition.*filter_function)(slice, no_io, const_ikey_ptr,
-                                             get_context, lookup_context,
-                                             rate_limiter_priority);
+  return (filter_partition.*filter_function)(
+      slice, no_io, const_ikey_ptr, get_context, lookup_context, read_options);
 }
 
 void PartitionedFilterBlockReader::MayMatch(
     MultiGetRange* range, const SliceTransform* prefix_extractor, bool no_io,
-    BlockCacheLookupContext* lookup_context,
-    Env::IOPriority rate_limiter_priority,
+    BlockCacheLookupContext* lookup_context, const ReadOptions& read_options,
     FilterManyFunction filter_function) const {
   CachableEntry<Block_kFilterPartitionIndex> filter_block;
-  Status s =
-      GetOrReadFilterBlock(no_io, range->begin()->get_context, lookup_context,
-                           &filter_block, rate_limiter_priority);
+  Status s = GetOrReadFilterBlock(no_io, range->begin()->get_context,
+                                  lookup_context, &filter_block, read_options);
   if (UNLIKELY(!s.ok())) {
     IGNORE_STATUS_IF_ERROR(s);
     return;  // Any/all may match
@@ -393,7 +385,7 @@ void PartitionedFilterBlockReader::MayMatch(
         this_filter_handle != prev_filter_handle) {
       MultiGetRange subrange(*range, start_iter_same_handle, iter);
       MayMatchPartition(&subrange, prefix_extractor, prev_filter_handle, no_io,
-                        lookup_context, rate_limiter_priority, filter_function);
+                        lookup_context, read_options, filter_function);
       range->AddSkipsFrom(subrange);
       start_iter_same_handle = iter;
     }
@@ -409,7 +401,7 @@ void PartitionedFilterBlockReader::MayMatch(
   if (!prev_filter_handle.IsNull()) {
     MultiGetRange subrange(*range, start_iter_same_handle, range->end());
     MayMatchPartition(&subrange, prefix_extractor, prev_filter_handle, no_io,
-                      lookup_context, rate_limiter_priority, filter_function);
+                      lookup_context, read_options, filter_function);
     range->AddSkipsFrom(subrange);
   }
 }
@@ -417,13 +409,12 @@ void PartitionedFilterBlockReader::MayMatch(
 void PartitionedFilterBlockReader::MayMatchPartition(
     MultiGetRange* range, const SliceTransform* prefix_extractor,
     BlockHandle filter_handle, bool no_io,
-    BlockCacheLookupContext* lookup_context,
-    Env::IOPriority rate_limiter_priority,
+    BlockCacheLookupContext* lookup_context, const ReadOptions& read_options,
     FilterManyFunction filter_function) const {
   CachableEntry<ParsedFullFilterBlock> filter_partition_block;
   Status s = GetFilterPartitionBlock(
       nullptr /* prefetch_buffer */, filter_handle, no_io,
-      range->begin()->get_context, lookup_context, rate_limiter_priority,
+      range->begin()->get_context, lookup_context, read_options,
       &filter_partition_block);
   if (UNLIKELY(!s.ok())) {
     IGNORE_STATUS_IF_ERROR(s);
@@ -433,7 +424,7 @@ void PartitionedFilterBlockReader::MayMatchPartition(
   FullFilterBlockReader filter_partition(table(),
                                          std::move(filter_partition_block));
   (filter_partition.*filter_function)(range, prefix_extractor, no_io,
-                                      lookup_context, rate_limiter_priority);
+                                      lookup_context, read_options);
 }
 
 size_t PartitionedFilterBlockReader::ApproximateMemoryUsage() const {
@@ -448,8 +439,8 @@ size_t PartitionedFilterBlockReader::ApproximateMemoryUsage() const {
 }
 
 // TODO(myabandeh): merge this with the same function in IndexReader
-Status PartitionedFilterBlockReader::CacheDependencies(const ReadOptions& ro,
-                                                       bool pin) {
+Status PartitionedFilterBlockReader::CacheDependencies(
+    const ReadOptions& ro, bool pin, FilePrefetchBuffer* tail_prefetch_buffer) {
   assert(table());
 
   const BlockBasedTable::Rep* const rep = table()->get_rep();
@@ -460,8 +451,7 @@ Status PartitionedFilterBlockReader::CacheDependencies(const ReadOptions& ro,
   CachableEntry<Block_kFilterPartitionIndex> filter_block;
 
   Status s = GetOrReadFilterBlock(false /* no_io */, nullptr /* get_context */,
-                                  &lookup_context, &filter_block,
-                                  ro.rate_limiter_priority);
+                                  &lookup_context, &filter_block, ro);
   if (!s.ok()) {
     ROCKS_LOG_ERROR(rep->ioptions.logger,
                     "Error retrieving top-level filter block while trying to "
@@ -494,21 +484,23 @@ Status PartitionedFilterBlockReader::CacheDependencies(const ReadOptions& ro,
       handle.offset() + handle.size() + BlockBasedTable::kBlockTrailerSize;
   uint64_t prefetch_len = last_off - prefetch_off;
   std::unique_ptr<FilePrefetchBuffer> prefetch_buffer;
-  rep->CreateFilePrefetchBuffer(
-      0, 0, &prefetch_buffer, false /* Implicit autoreadahead */,
-      0 /*num_reads_*/, 0 /*num_file_reads_for_auto_readahead*/);
-
-  IOOptions opts;
-  s = rep->file->PrepareIOOptions(ro, opts);
-  if (s.ok()) {
-    s = prefetch_buffer->Prefetch(opts, rep->file.get(), prefetch_off,
-                                  static_cast<size_t>(prefetch_len),
-                                  ro.rate_limiter_priority);
-  }
-  if (!s.ok()) {
-    return s;
+  if (tail_prefetch_buffer == nullptr || !tail_prefetch_buffer->Enabled() ||
+      tail_prefetch_buffer->GetPrefetchOffset() > prefetch_off) {
+    rep->CreateFilePrefetchBuffer(
+        0, 0, &prefetch_buffer, false /* Implicit autoreadahead */,
+        0 /*num_reads_*/, 0 /*num_file_reads_for_auto_readahead*/);
+
+    IOOptions opts;
+    s = rep->file->PrepareIOOptions(ro, opts);
+    if (s.ok()) {
+      s = prefetch_buffer->Prefetch(opts, rep->file.get(), prefetch_off,
+                                    static_cast<size_t>(prefetch_len),
+                                    ro.rate_limiter_priority);
+    }
+    if (!s.ok()) {
+      return s;
+    }
   }
-
   // After prefetch, read the partitions one by one
   for (biter.SeekToFirst(); biter.Valid(); biter.Next()) {
     handle = biter.value().handle;
@@ -517,7 +509,8 @@ Status PartitionedFilterBlockReader::CacheDependencies(const ReadOptions& ro,
     // TODO: Support counter batch update for partitioned index and
     // filter blocks
     s = table()->MaybeReadBlockAndLoadToCache(
-        prefetch_buffer.get(), ro, handle, UncompressionDict::GetEmptyDict(),
+        prefetch_buffer ? prefetch_buffer.get() : tail_prefetch_buffer, ro,
+        handle, UncompressionDict::GetEmptyDict(),
         /* for_compaction */ false, &block, nullptr /* get_context */,
         &lookup_context, nullptr /* contents */, false);
     if (!s.ok()) {

package/deps/rocksdb/rocksdb/table/block_based/partitioned_filter_block.h

@@ -115,21 +115,21 @@ class PartitionedFilterBlockReader
   bool KeyMayMatch(const Slice& key, const bool no_io,
                    const Slice* const const_ikey_ptr, GetContext* get_context,
                    BlockCacheLookupContext* lookup_context,
-                   Env::IOPriority rate_limiter_priority) override;
+                   const ReadOptions& read_options) override;
   void KeysMayMatch(MultiGetRange* range, const bool no_io,
                     BlockCacheLookupContext* lookup_context,
-                    Env::IOPriority rate_limiter_priority) override;
+                    const ReadOptions& read_options) override;
 
   bool PrefixMayMatch(const Slice& prefix, const bool no_io,
                       const Slice* const const_ikey_ptr,
                       GetContext* get_context,
                       BlockCacheLookupContext* lookup_context,
-                      Env::IOPriority rate_limiter_priority) override;
+                      const ReadOptions& read_options) override;
   void PrefixesMayMatch(MultiGetRange* range,
                         const SliceTransform* prefix_extractor,
                         const bool no_io,
                         BlockCacheLookupContext* lookup_context,
-                        Env::IOPriority rate_limiter_priority) override;
+                        const ReadOptions& read_options) override;
 
   size_t ApproximateMemoryUsage() const override;
 
@@ -140,34 +140,34 @@ class PartitionedFilterBlockReader
   Status GetFilterPartitionBlock(
       FilePrefetchBuffer* prefetch_buffer, const BlockHandle& handle,
       bool no_io, GetContext* get_context,
-      BlockCacheLookupContext* lookup_context,
-      Env::IOPriority rate_limiter_priority,
+      BlockCacheLookupContext* lookup_context, const ReadOptions& read_options,
       CachableEntry<ParsedFullFilterBlock>* filter_block) const;
 
   using FilterFunction = bool (FullFilterBlockReader::*)(
       const Slice& slice, const bool no_io, const Slice* const const_ikey_ptr,
       GetContext* get_context, BlockCacheLookupContext* lookup_context,
-      Env::IOPriority rate_limiter_priority);
+      const ReadOptions& read_options);
   bool MayMatch(const Slice& slice, bool no_io, const Slice* const_ikey_ptr,
                 GetContext* get_context,
                 BlockCacheLookupContext* lookup_context,
-                Env::IOPriority rate_limiter_priority,
+                const ReadOptions& read_options,
                 FilterFunction filter_function) const;
   using FilterManyFunction = void (FullFilterBlockReader::*)(
       MultiGetRange* range, const SliceTransform* prefix_extractor,
       const bool no_io, BlockCacheLookupContext* lookup_context,
-      Env::IOPriority rate_limiter_priority);
+      const ReadOptions& read_options);
   void MayMatch(MultiGetRange* range, const SliceTransform* prefix_extractor,
                 bool no_io, BlockCacheLookupContext* lookup_context,
-                Env::IOPriority rate_limiter_priority,
+                const ReadOptions& read_options,
                 FilterManyFunction filter_function) const;
   void MayMatchPartition(MultiGetRange* range,
                          const SliceTransform* prefix_extractor,
                          BlockHandle filter_handle, bool no_io,
                          BlockCacheLookupContext* lookup_context,
-                         Env::IOPriority rate_limiter_priority,
+                         const ReadOptions& read_options,
                          FilterManyFunction filter_function) const;
-  Status CacheDependencies(const ReadOptions& ro, bool pin) override;
+  Status CacheDependencies(const ReadOptions& ro, bool pin,
+                           FilePrefetchBuffer* tail_prefetch_buffer) override;
 
   const InternalKeyComparator* internal_comparator() const;
   bool index_key_includes_seq() const;

package/deps/rocksdb/rocksdb/table/block_based/partitioned_filter_block_test.cc

@@ -167,7 +167,6 @@ class PartitionedFilterBlockTest
                     PartitionedIndexBuilder* pib, bool empty = false) {
     std::unique_ptr<PartitionedFilterBlockReader> reader(
         NewReader(builder, pib));
-    Env::IOPriority rate_limiter_priority = Env::IO_TOTAL;
     // Querying added keys
     const bool no_io = true;
     for (auto key : keys) {
@@ -176,7 +175,7 @@ class PartitionedFilterBlockTest
       ASSERT_TRUE(reader->KeyMayMatch(key, !no_io, &ikey_slice,
                                       /*get_context=*/nullptr,
                                       /*lookup_context=*/nullptr,
-                                      rate_limiter_priority));
+                                      ReadOptions()));
     }
     {
       // querying a key twice
@@ -185,7 +184,7 @@ class PartitionedFilterBlockTest
       ASSERT_TRUE(reader->KeyMayMatch(keys[0], !no_io, &ikey_slice,
                                       /*get_context=*/nullptr,
                                       /*lookup_context=*/nullptr,
-                                      rate_limiter_priority));
+                                      ReadOptions()));
     }
     // querying missing keys
     for (auto key : missing_keys) {
@@ -195,13 +194,13 @@ class PartitionedFilterBlockTest
         ASSERT_TRUE(reader->KeyMayMatch(key, !no_io, &ikey_slice,
                                         /*get_context=*/nullptr,
                                         /*lookup_context=*/nullptr,
-                                        rate_limiter_priority));
+                                        ReadOptions()));
       } else {
         // assuming a good hash function
         ASSERT_FALSE(reader->KeyMayMatch(key, !no_io, &ikey_slice,
                                          /*get_context=*/nullptr,
                                          /*lookup_context=*/nullptr,
-                                         rate_limiter_priority));
+                                         ReadOptions()));
       }
     }
   }
@@ -354,7 +353,7 @@ TEST_P(PartitionedFilterBlockTest, SamePrefixInMultipleBlocks) {
                                        /*no_io=*/false, &ikey_slice,
                                        /*get_context=*/nullptr,
                                        /*lookup_context=*/nullptr,
-                                       Env::IO_TOTAL));
+                                       ReadOptions()));
   }
   // Non-existent keys but with the same prefix
   const std::string pnonkeys[4] = {"p-key9", "p-key11", "p-key21", "p-key31"};
@@ -365,7 +364,7 @@ TEST_P(PartitionedFilterBlockTest, SamePrefixInMultipleBlocks) {
                                        /*no_io=*/false, &ikey_slice,
                                        /*get_context=*/nullptr,
                                        /*lookup_context=*/nullptr,
-                                       Env::IO_TOTAL));
+                                       ReadOptions()));
   }
 }
 
@@ -396,7 +395,6 @@ TEST_P(PartitionedFilterBlockTest, PrefixInWrongPartitionBug) {
   CutABlock(pib.get(), pkeys[4]);
   std::unique_ptr<PartitionedFilterBlockReader> reader(
       NewReader(builder.get(), pib.get()));
-  Env::IOPriority rate_limiter_priority = Env::IO_TOTAL;
   for (auto key : pkeys) {
     auto prefix = prefix_extractor->Transform(key);
     auto ikey = InternalKey(prefix, 0, ValueType::kTypeValue);
@@ -405,7 +403,7 @@ TEST_P(PartitionedFilterBlockTest, PrefixInWrongPartitionBug) {
                                        /*no_io=*/false, &ikey_slice,
                                        /*get_context=*/nullptr,
                                        /*lookup_context=*/nullptr,
-                                       rate_limiter_priority));
+                                       ReadOptions()));
   }
 }
 

package/deps/rocksdb/rocksdb/table/block_based/partitioned_index_reader.cc

@@ -49,9 +49,8 @@ InternalIteratorBase<IndexValue>* PartitionIndexReader::NewIterator(
     BlockCacheLookupContext* lookup_context) {
   const bool no_io = (read_options.read_tier == kBlockCacheTier);
   CachableEntry<Block> index_block;
-  const Status s =
-      GetOrReadIndexBlock(no_io, read_options.rate_limiter_priority,
-                          get_context, lookup_context, &index_block);
+  const Status s = GetOrReadIndexBlock(no_io, get_context, lookup_context,
+                                       &index_block, read_options);
   if (!s.ok()) {
     if (iter != nullptr) {
       iter->Invalidate(s);
@@ -85,6 +84,8 @@ InternalIteratorBase<IndexValue>* PartitionIndexReader::NewIterator(
     ro.adaptive_readahead = read_options.adaptive_readahead;
     ro.async_io = read_options.async_io;
     ro.rate_limiter_priority = read_options.rate_limiter_priority;
+    ro.verify_checksums = read_options.verify_checksums;
+    ro.io_activity = read_options.io_activity;
 
     // We don't return pinned data from index blocks, so no need
     // to set `block_contents_pinned`.
@@ -111,8 +112,8 @@ InternalIteratorBase<IndexValue>* PartitionIndexReader::NewIterator(
   // the first level iter is always on heap and will attempt to delete it
   // in its destructor.
 }
-Status PartitionIndexReader::CacheDependencies(const ReadOptions& ro,
-                                               bool pin) {
+Status PartitionIndexReader::CacheDependencies(
+    const ReadOptions& ro, bool pin, FilePrefetchBuffer* tail_prefetch_buffer) {
   if (!partition_map_.empty()) {
     // The dependencies are already cached since `partition_map_` is filled in
     // an all-or-nothing manner.
@@ -127,9 +128,8 @@ Status PartitionIndexReader::CacheDependencies(const ReadOptions& ro,
 
   CachableEntry<Block> index_block;
   {
-    Status s = GetOrReadIndexBlock(false /* no_io */, ro.rate_limiter_priority,
-                                   nullptr /* get_context */, &lookup_context,
-                                   &index_block);
+    Status s = GetOrReadIndexBlock(false /* no_io */, nullptr /* get_context */,
+                                   &lookup_context, &index_block, ro);
     if (!s.ok()) {
       return s;
     }
@@ -162,22 +162,24 @@ Status PartitionIndexReader::CacheDependencies(const ReadOptions& ro,
       handle.offset() + BlockBasedTable::BlockSizeWithTrailer(handle);
   uint64_t prefetch_len = last_off - prefetch_off;
   std::unique_ptr<FilePrefetchBuffer> prefetch_buffer;
-  rep->CreateFilePrefetchBuffer(
-      0, 0, &prefetch_buffer, false /*Implicit auto readahead*/,
-      0 /*num_reads_*/, 0 /*num_file_reads_for_auto_readahead*/);
-  IOOptions opts;
-  {
-    Status s = rep->file->PrepareIOOptions(ro, opts);
-    if (s.ok()) {
-      s = prefetch_buffer->Prefetch(opts, rep->file.get(), prefetch_off,
-                                    static_cast<size_t>(prefetch_len),
-                                    ro.rate_limiter_priority);
-    }
-    if (!s.ok()) {
-      return s;
+  if (tail_prefetch_buffer == nullptr || !tail_prefetch_buffer->Enabled() ||
+      tail_prefetch_buffer->GetPrefetchOffset() > prefetch_off) {
+    rep->CreateFilePrefetchBuffer(
+        0, 0, &prefetch_buffer, false /*Implicit auto readahead*/,
+        0 /*num_reads_*/, 0 /*num_file_reads_for_auto_readahead*/);
+    IOOptions opts;
+    {
+      Status s = rep->file->PrepareIOOptions(ro, opts);
+      if (s.ok()) {
+        s = prefetch_buffer->Prefetch(opts, rep->file.get(), prefetch_off,
+                                      static_cast<size_t>(prefetch_len),
+                                      ro.rate_limiter_priority);
+      }
+      if (!s.ok()) {
+        return s;
+      }
     }
   }
-
   // For saving "all or nothing" to partition_map_
   UnorderedMap<uint64_t, CachableEntry<Block>> map_in_progress;
 
@@ -191,7 +193,8 @@ Status PartitionIndexReader::CacheDependencies(const ReadOptions& ro,
     // TODO: Support counter batch update for partitioned index and
     // filter blocks
     Status s = table()->MaybeReadBlockAndLoadToCache(
-        prefetch_buffer.get(), ro, handle, UncompressionDict::GetEmptyDict(),
+        prefetch_buffer ? prefetch_buffer.get() : tail_prefetch_buffer, ro,
+        handle, UncompressionDict::GetEmptyDict(),
         /*for_compaction=*/false, &block.As<Block_kIndex>(),
         /*get_context=*/nullptr, &lookup_context, /*contents=*/nullptr,
         /*async_read=*/false);

package/deps/rocksdb/rocksdb/table/block_based/partitioned_index_reader.h

@@ -30,7 +30,8 @@ class PartitionIndexReader : public BlockBasedTable::IndexReaderCommon {
       IndexBlockIter* iter, GetContext* get_context,
       BlockCacheLookupContext* lookup_context) override;
 
-  Status CacheDependencies(const ReadOptions& ro, bool pin) override;
+  Status CacheDependencies(const ReadOptions& ro, bool pin,
+                           FilePrefetchBuffer* tail_prefetch_buffer) override;
   size_t ApproximateMemoryUsage() const override {
     size_t usage = ApproximateIndexBlockMemoryUsage();
 #ifdef ROCKSDB_MALLOC_USABLE_SIZE

package/deps/rocksdb/rocksdb/table/block_based/reader_common.h

@@ -24,6 +24,9 @@ inline MemoryAllocator* GetMemoryAllocator(
 
 // Assumes block has a trailer as in format.h. file_name and offset provided
 // for generating a diagnostic message in returned status.
+//
+// Returns Status::OK() on checksum match, or Status::Corruption() on checksum
+// mismatch.
 extern Status VerifyBlockChecksum(ChecksumType type, const char* data,
                                   size_t block_size,
                                   const std::string& file_name,

package/deps/rocksdb/rocksdb/table/block_based/uncompression_dict_reader.cc

@@ -77,8 +77,9 @@ Status UncompressionDictReader::ReadUncompressionDictionary(
 }
 
 Status UncompressionDictReader::GetOrReadUncompressionDictionary(
-    FilePrefetchBuffer* prefetch_buffer, bool no_io, bool verify_checksums,
-    GetContext* get_context, BlockCacheLookupContext* lookup_context,
+    FilePrefetchBuffer* prefetch_buffer, const ReadOptions& ro, bool no_io,
+    bool verify_checksums, GetContext* get_context,
+    BlockCacheLookupContext* lookup_context,
     CachableEntry<UncompressionDict>* uncompression_dict) const {
   assert(uncompression_dict);
 
@@ -92,6 +93,7 @@ Status UncompressionDictReader::GetOrReadUncompressionDictionary(
     read_options.read_tier = kBlockCacheTier;
   }
   read_options.verify_checksums = verify_checksums;
+  read_options.io_activity = ro.io_activity;
 
   return ReadUncompressionDictionary(table_, prefetch_buffer, read_options,
                                      cache_dictionary_blocks(), get_context,

package/deps/rocksdb/rocksdb/table/block_based/uncompression_dict_reader.h

@@ -32,8 +32,9 @@ class UncompressionDictReader {
       std::unique_ptr<UncompressionDictReader>* uncompression_dict_reader);
 
   Status GetOrReadUncompressionDictionary(
-      FilePrefetchBuffer* prefetch_buffer, bool no_io, bool verify_checksums,
-      GetContext* get_context, BlockCacheLookupContext* lookup_context,
+      FilePrefetchBuffer* prefetch_buffer, const ReadOptions& ro, bool no_io,
+      bool verify_checksums, GetContext* get_context,
+      BlockCacheLookupContext* lookup_context,
       CachableEntry<UncompressionDict>* uncompression_dict) const;
 
   size_t ApproximateMemoryUsage() const;

package/deps/rocksdb/rocksdb/table/block_fetcher.cc

@@ -14,7 +14,7 @@
 #include <string>
 
 #include "logging/logging.h"
-#include "memory/memory_allocator.h"
+#include "memory/memory_allocator_impl.h"
 #include "monitoring/perf_context_imp.h"
 #include "rocksdb/compression_type.h"
 #include "rocksdb/env.h"
@@ -37,6 +37,10 @@ inline void BlockFetcher::ProcessTrailerIfPresent() {
           footer_.checksum_type(), slice_.data(), block_size_,
           file_->file_name(), handle_.offset()));
       RecordTick(ioptions_.stats, BLOCK_CHECKSUM_COMPUTE_COUNT);
+      if (!io_status_.ok()) {
+        assert(io_status_.IsCorruption());
+        RecordTick(ioptions_.stats, BLOCK_CHECKSUM_MISMATCH_COUNT);
+      }
     }
     compression_type_ =
         BlockBasedTable::GetBlockCompressionType(slice_.data(), block_size_);
@@ -254,6 +258,7 @@ IOStatus BlockFetcher::ReadBlockContents() {
     if (io_status_.ok()) {
       if (file_->use_direct_io()) {
         PERF_TIMER_GUARD(block_read_time);
+        PERF_CPU_TIMER_GUARD(block_read_cpu_time, nullptr);
         io_status_ = file_->Read(
             opts, handle_.offset(), block_size_with_trailer_, &slice_, nullptr,
             &direct_io_buf_, read_options_.rate_limiter_priority);
@@ -262,6 +267,7 @@ IOStatus BlockFetcher::ReadBlockContents() {
       } else {
         PrepareBufferForBlockFromFile();
         PERF_TIMER_GUARD(block_read_time);
+        PERF_CPU_TIMER_GUARD(block_read_cpu_time, nullptr);
         io_status_ = file_->Read(opts, handle_.offset(),
                                  block_size_with_trailer_, &slice_, used_buf_,
                                  nullptr, read_options_.rate_limiter_priority);

package/deps/rocksdb/rocksdb/table/block_fetcher.h

@@ -8,7 +8,7 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #pragma once
-#include "memory/memory_allocator.h"
+#include "memory/memory_allocator_impl.h"
 #include "table/block_based/block.h"
 #include "table/block_based/block_type.h"
 #include "table/format.h"

package/deps/rocksdb/rocksdb/table/block_fetcher_test.cc

@@ -268,7 +268,8 @@ class BlockFetcherTest : public testing::Test {
     ASSERT_NE(table_options, nullptr);
     ASSERT_OK(BlockBasedTable::Open(ro, ioptions, EnvOptions(), *table_options,
                                     comparator, std::move(file), file_size,
-                                    &table_reader));
+                                    0 /* block_protection_bytes_per_key */,
+                                    &table_reader, 0 /* tail_size */));
 
     table->reset(reinterpret_cast<BlockBasedTable*>(table_reader.release()));
   }

package/deps/rocksdb/rocksdb/table/cuckoo/cuckoo_table_builder_test.cc

@@ -70,8 +70,10 @@ class CuckooBuilderTest : public testing::Test {
 
     // Assert Table Properties.
     std::unique_ptr<TableProperties> props;
+    const ReadOptions read_options;
     ASSERT_OK(ReadTableProperties(file_reader.get(), read_file_size,
-                                  kCuckooTableMagicNumber, ioptions, &props));
+                                  kCuckooTableMagicNumber, ioptions,
+                                  read_options, &props));
     // Check unused bucket.
     std::string unused_key =
         props->user_collected_properties[CuckooTablePropertyNames::kEmptyKey];
@@ -627,4 +629,3 @@ int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
-

package/deps/rocksdb/rocksdb/table/cuckoo/cuckoo_table_reader.cc

@@ -59,8 +59,11 @@ CuckooTableReader::CuckooTableReader(
   }
   {
     std::unique_ptr<TableProperties> props;
-    status_ = ReadTableProperties(file_.get(), file_size,
-                                  kCuckooTableMagicNumber, ioptions, &props);
+    // TODO: plumb Env::IOActivity
+    const ReadOptions read_options;
+    status_ =
+        ReadTableProperties(file_.get(), file_size, kCuckooTableMagicNumber,
+                            ioptions, read_options, &props);
     if (!status_.ok()) {
       return;
     }

package/deps/rocksdb/rocksdb/table/cuckoo/cuckoo_table_reader.h

@@ -58,12 +58,14 @@ class CuckooTableReader : public TableReader {
   size_t ApproximateMemoryUsage() const override;
 
   // Following methods are not implemented for Cuckoo Table Reader
-  uint64_t ApproximateOffsetOf(const Slice& /*key*/,
+  uint64_t ApproximateOffsetOf(const ReadOptions& /*read_options*/,
+                               const Slice& /*key*/,
                                TableReaderCaller /*caller*/) override {
     return 0;
   }
 
-  uint64_t ApproximateSize(const Slice& /*start*/, const Slice& /*end*/,
+  uint64_t ApproximateSize(const ReadOptions& /* read_options */,
+                           const Slice& /*start*/, const Slice& /*end*/,
                            TableReaderCaller /*caller*/) override {
     return 0;
   }