@nxtedition/rocksdb 9.0.0 → 9.0.1

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

@@ -5,6 +5,8 @@
 
 #include "table/block_based/block_cache.h"
 
+#include "table/block_based/block_based_table_reader.h"
+
 namespace ROCKSDB_NAMESPACE {
 
 void BlockCreateContext::Create(std::unique_ptr<Block_kData>* parsed_out,
@@ -96,7 +98,7 @@ const std::array<const Cache::CacheItemHelper*,
 
 const Cache::CacheItemHelper* GetCacheItemHelper(
     BlockType block_type, CacheTier lowest_used_cache_tier) {
-  if (lowest_used_cache_tier == CacheTier::kNonVolatileBlockTier) {
+  if (lowest_used_cache_tier > CacheTier::kVolatileTier) {
     return kCacheItemFullHelperForBlockType[static_cast<unsigned>(block_type)];
   } else {
     return kCacheItemBasicHelperForBlockType[static_cast<unsigned>(block_type)];

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

@@ -70,24 +70,28 @@ class Block_kMetaIndex : public Block {
 struct BlockCreateContext : public Cache::CreateContext {
   BlockCreateContext() {}
   BlockCreateContext(const BlockBasedTableOptions* _table_options,
-                     Statistics* _statistics, bool _using_zstd,
-                     uint8_t _protection_bytes_per_key,
+                     const ImmutableOptions* _ioptions, Statistics* _statistics,
+                     bool _using_zstd, uint8_t _protection_bytes_per_key,
                      const Comparator* _raw_ucmp,
                      bool _index_value_is_full = false,
                      bool _index_has_first_key = false)
       : table_options(_table_options),
+        ioptions(_ioptions),
         statistics(_statistics),
+        raw_ucmp(_raw_ucmp),
         using_zstd(_using_zstd),
         protection_bytes_per_key(_protection_bytes_per_key),
-        raw_ucmp(_raw_ucmp),
         index_value_is_full(_index_value_is_full),
         index_has_first_key(_index_has_first_key) {}
 
   const BlockBasedTableOptions* table_options = nullptr;
+  const ImmutableOptions* ioptions = nullptr;
   Statistics* statistics = nullptr;
+  const Comparator* raw_ucmp = nullptr;
+  const UncompressionDict* dict = nullptr;
+  uint32_t format_version;
   bool using_zstd = false;
   uint8_t protection_bytes_per_key = 0;
-  const Comparator* raw_ucmp = nullptr;
   bool index_value_is_full;
   bool index_has_first_key;
 
@@ -95,9 +99,24 @@ struct BlockCreateContext : public Cache::CreateContext {
   template <typename TBlocklike>
   inline void Create(std::unique_ptr<TBlocklike>* parsed_out,
                      size_t* charge_out, const Slice& data,
-                     MemoryAllocator* alloc) {
-    Create(parsed_out,
-           BlockContents(AllocateAndCopyBlock(data, alloc), data.size()));
+                     CompressionType type, MemoryAllocator* alloc) {
+    BlockContents uncompressed_block_contents;
+    if (type != CompressionType::kNoCompression) {
+      assert(dict != nullptr);
+      UncompressionContext context(type);
+      UncompressionInfo info(context, *dict, type);
+      Status s = UncompressBlockData(
+          info, data.data(), data.size(), &uncompressed_block_contents,
+          table_options->format_version, *ioptions, alloc);
+      if (!s.ok()) {
+        parsed_out->reset();
+        return;
+      }
+    } else {
+      uncompressed_block_contents =
+          BlockContents(AllocateAndCopyBlock(data, alloc), data.size());
+    }
+    Create(parsed_out, std::move(uncompressed_block_contents));
     *charge_out = parsed_out->get()->ApproximateMemoryUsage();
   }
 

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

@@ -12,15 +12,13 @@
 #include "table/block_based/block_based_table_reader.h"
 
 namespace ROCKSDB_NAMESPACE {
-void BlockPrefetcher::PrefetchIfNeeded(const BlockBasedTable::Rep* rep,
-                                       const BlockHandle& handle,
-                                       const size_t readahead_size,
-                                       bool is_for_compaction,
-                                       const bool no_sequential_checking,
-                                       const ReadOptions& read_options) {
+void BlockPrefetcher::PrefetchIfNeeded(
+    const BlockBasedTable::Rep* rep, const BlockHandle& handle,
+    const size_t readahead_size, bool is_for_compaction,
+    const bool no_sequential_checking, const ReadOptions& read_options,
+    const std::function<void(uint64_t, size_t, size_t&)>& readaheadsize_cb) {
   const size_t len = BlockBasedTable::BlockSizeWithTrailer(handle);
   const size_t offset = handle.offset();
-
   if (is_for_compaction) {
     if (!rep->file->use_direct_io() && compaction_readahead_size_ > 0) {
       // If FS supports prefetching (readahead_limit_ will be non zero in that
@@ -50,7 +48,7 @@ void BlockPrefetcher::PrefetchIfNeeded(const BlockBasedTable::Rep* rep,
         compaction_readahead_size_, compaction_readahead_size_,
         &prefetch_buffer_, /*implicit_auto_readahead=*/false,
         /*num_file_reads=*/0, /*num_file_reads_for_auto_readahead=*/0,
-        /*upper_bound_offset=*/0);
+        /*upper_bound_offset=*/0, /*readaheadsize_cb=*/nullptr);
     return;
   }
 
@@ -59,7 +57,9 @@ void BlockPrefetcher::PrefetchIfNeeded(const BlockBasedTable::Rep* rep,
     rep->CreateFilePrefetchBufferIfNotExists(
         readahead_size, readahead_size, &prefetch_buffer_,
         /*implicit_auto_readahead=*/false, /*num_file_reads=*/0,
-        /*num_file_reads_for_auto_readahead=*/0, upper_bound_offset_);
+        /*num_file_reads_for_auto_readahead=*/0, upper_bound_offset_,
+        readaheadsize_cb,
+        /*usage=*/FilePrefetchBufferUsage::kUserScanPrefetch);
     return;
   }
 
@@ -84,7 +84,8 @@ void BlockPrefetcher::PrefetchIfNeeded(const BlockBasedTable::Rep* rep,
         &prefetch_buffer_, /*implicit_auto_readahead=*/true,
         /*num_file_reads=*/0,
         rep->table_options.num_file_reads_for_auto_readahead,
-        upper_bound_offset_);
+        upper_bound_offset_, readaheadsize_cb,
+        /*usage=*/FilePrefetchBufferUsage::kUserScanPrefetch);
     return;
   }
 
@@ -115,7 +116,8 @@ void BlockPrefetcher::PrefetchIfNeeded(const BlockBasedTable::Rep* rep,
         initial_auto_readahead_size_, max_auto_readahead_size,
         &prefetch_buffer_, /*implicit_auto_readahead=*/true, num_file_reads_,
         rep->table_options.num_file_reads_for_auto_readahead,
-        upper_bound_offset_);
+        upper_bound_offset_, readaheadsize_cb,
+        /*usage=*/FilePrefetchBufferUsage::kUserScanPrefetch);
     return;
   }
 
@@ -137,7 +139,8 @@ void BlockPrefetcher::PrefetchIfNeeded(const BlockBasedTable::Rep* rep,
         initial_auto_readahead_size_, max_auto_readahead_size,
         &prefetch_buffer_, /*implicit_auto_readahead=*/true, num_file_reads_,
         rep->table_options.num_file_reads_for_auto_readahead,
-        upper_bound_offset_);
+        upper_bound_offset_, readaheadsize_cb,
+        /*usage=*/FilePrefetchBufferUsage::kUserScanPrefetch);
     return;
   }
 

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

@@ -18,11 +18,11 @@ class BlockPrefetcher {
         readahead_size_(initial_auto_readahead_size),
         initial_auto_readahead_size_(initial_auto_readahead_size) {}
 
-  void PrefetchIfNeeded(const BlockBasedTable::Rep* rep,
-                        const BlockHandle& handle, size_t readahead_size,
-                        bool is_for_compaction,
-                        const bool no_sequential_checking,
-                        const ReadOptions& read_options);
+  void PrefetchIfNeeded(
+      const BlockBasedTable::Rep* rep, const BlockHandle& handle,
+      size_t readahead_size, bool is_for_compaction,
+      const bool no_sequential_checking, const ReadOptions& read_options,
+      const std::function<void(uint64_t, size_t, size_t&)>& readaheadsize_cb);
   FilePrefetchBuffer* prefetch_buffer() { return prefetch_buffer_.get(); }
 
   void UpdateReadPattern(const uint64_t& offset, const size_t& len) {
@@ -55,6 +55,11 @@ class BlockPrefetcher {
 
   void SetUpperBoundOffset(uint64_t upper_bound_offset) {
     upper_bound_offset_ = upper_bound_offset;
+    if (prefetch_buffer() != nullptr) {
+      // Upper bound can be changed on reseek. So update that in
+      // FilePrefetchBuffer.
+      prefetch_buffer()->ResetUpperBoundOffset(upper_bound_offset);
+    }
   }
 
  private:

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

@@ -848,9 +848,12 @@ TEST_F(BlockPerKVChecksumTest, EmptyBlock) {
   Options options = Options();
   BlockBasedTableOptions tbo;
   uint8_t protection_bytes_per_key = 8;
-  BlockCreateContext create_context{
-      &tbo, nullptr /* statistics */, false /* using_zstd */,
-      protection_bytes_per_key, options.comparator};
+  BlockCreateContext create_context{&tbo,
+                                    nullptr,
+                                    nullptr /* statistics */,
+                                    false /* using_zstd */,
+                                    protection_bytes_per_key,
+                                    options.comparator};
   create_context.Create(&data_block, std::move(contents));
   std::unique_ptr<DataBlockIter> biter{data_block->NewDataIterator(
       options.comparator, kDisableGlobalSequenceNumber)};
@@ -885,9 +888,12 @@ TEST_F(BlockPerKVChecksumTest, InitializeProtectionInfo) {
   Options options = Options();
   BlockBasedTableOptions tbo;
   uint8_t protection_bytes_per_key = 8;
-  BlockCreateContext create_context{
-      &tbo, nullptr /* statistics */, false /* using_zstd */,
-      protection_bytes_per_key, options.comparator};
+  BlockCreateContext create_context{&tbo,
+                                    nullptr /* ioptions */,
+                                    nullptr /* statistics */,
+                                    false /* using_zstd */,
+                                    protection_bytes_per_key,
+                                    options.comparator};
 
   {
     std::string invalid_content = "1";
@@ -949,14 +955,19 @@ TEST_F(BlockPerKVChecksumTest, ApproximateMemory) {
   uint8_t protection_bytes_per_key = 8;
   BlockCreateContext with_checksum_create_context{
       &tbo,
+      nullptr /* ioptions */,
       nullptr /* statistics */,
       false /* using_zstd */,
       protection_bytes_per_key,
       options.comparator,
       true /* index_value_is_full */};
-  BlockCreateContext create_context{
-      &tbo, nullptr /* statistics */, false /* using_zstd */,
-      0,    options.comparator,       true /* index_value_is_full */};
+  BlockCreateContext create_context{&tbo,
+                                    nullptr /* ioptions */,
+                                    nullptr /* statistics */,
+                                    false /* using_zstd */,
+                                    0,
+                                    options.comparator,
+                                    true /* index_value_is_full */};
 
   {
     std::unique_ptr<Block_kData> data_block;
@@ -1045,8 +1056,11 @@ class DataBlockKVChecksumTest
       std::vector<std::string> &keys, std::vector<std::string> &values,
       int num_record) {
     BlockBasedTableOptions tbo;
-    BlockCreateContext create_context{&tbo, nullptr /* statistics */,
-                                      false /* using_zstd */, GetChecksumLen(),
+    BlockCreateContext create_context{&tbo,
+                                      nullptr /* statistics */,
+                                      nullptr /* ioptions */,
+                                      false /* using_zstd */,
+                                      GetChecksumLen(),
                                       Options().comparator};
     builder_ = std::make_unique<BlockBuilder>(
         static_cast<int>(GetRestartInterval()),
@@ -1172,6 +1186,7 @@ class IndexBlockKVChecksumTest
     uint8_t protection_bytes_per_key = GetChecksumLen();
     BlockCreateContext create_context{
         &tbo,
+        nullptr /* ioptions */,
         nullptr /* statistics */,
         false /* _using_zstd */,
         protection_bytes_per_key,
@@ -1312,9 +1327,12 @@ class MetaIndexBlockKVChecksumTest
     Options options = Options();
     BlockBasedTableOptions tbo;
     uint8_t protection_bytes_per_key = GetChecksumLen();
-    BlockCreateContext create_context{
-        &tbo, nullptr /* statistics */, false /* using_zstd */,
-        protection_bytes_per_key, options.comparator};
+    BlockCreateContext create_context{&tbo,
+                                      nullptr /* ioptions */,
+                                      nullptr /* statistics */,
+                                      false /* using_zstd */,
+                                      protection_bytes_per_key,
+                                      options.comparator};
     builder_ =
         std::make_unique<BlockBuilder>(static_cast<int>(GetRestartInterval()));
     // add a bunch of records to a block
@@ -1344,9 +1362,12 @@ TEST_P(MetaIndexBlockKVChecksumTest, ChecksumConstructionAndVerification) {
   Options options = Options();
   BlockBasedTableOptions tbo;
   uint8_t protection_bytes_per_key = GetChecksumLen();
-  BlockCreateContext create_context{
-      &tbo, nullptr /* statistics */, false /* using_zstd */,
-      protection_bytes_per_key, options.comparator};
+  BlockCreateContext create_context{&tbo,
+                                    nullptr /* ioptions */,
+                                    nullptr /* statistics */,
+                                    false /* using_zstd */,
+                                    protection_bytes_per_key,
+                                    options.comparator};
   std::vector<int> num_restart_intervals = {1, 16};
   for (const auto num_restart_interval : num_restart_intervals) {
     const int kNumRecords = num_restart_interval * GetRestartInterval();
@@ -1680,4 +1701,4 @@ int main(int argc, char **argv) {
   ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
-}
+}

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

@@ -28,12 +28,12 @@ Status FilterBlockReaderCommon<TBlocklike>::ReadFilterBlock(
   const BlockBasedTable::Rep* const rep = table->get_rep();
   assert(rep);
 
-  const Status s =
-      table->RetrieveBlock(prefetch_buffer, read_options, rep->filter_handle,
-                           UncompressionDict::GetEmptyDict(), filter_block,
-                           get_context, lookup_context,
-                           /* for_compaction */ false, use_cache,
-                           /* async_read */ false);
+  const Status s = table->RetrieveBlock(
+      prefetch_buffer, read_options, rep->filter_handle,
+      UncompressionDict::GetEmptyDict(), filter_block, get_context,
+      lookup_context,
+      /* for_compaction */ false, use_cache,
+      /* async_read */ false, /* use_block_cache_for_lookup */ true);
 
   return s;
 }

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

@@ -10,6 +10,7 @@
 #include "rocksdb/filter_policy.h"
 
 #include <array>
+#include <atomic>
 #include <climits>
 #include <cstring>
 #include <deque>
@@ -24,6 +25,7 @@
 #include "rocksdb/rocksdb_namespace.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/utilities/object_registry.h"
+#include "rocksdb/utilities/options_type.h"
 #include "table/block_based/block_based_table_reader.h"
 #include "table/block_based/filter_policy_internal.h"
 #include "table/block_based/full_filter_block.h"
@@ -1730,7 +1732,15 @@ const FilterPolicy* NewBloomFilterPolicy(double bits_per_key,
 RibbonFilterPolicy::RibbonFilterPolicy(double bloom_equivalent_bits_per_key,
                                        int bloom_before_level)
     : BloomLikeFilterPolicy(bloom_equivalent_bits_per_key),
-      bloom_before_level_(bloom_before_level) {}
+      bloom_before_level_(bloom_before_level) {
+  static const std::unordered_map<std::string, OptionTypeInfo> type_info = {
+      {"bloom_before_level",
+       {offsetof(class RibbonFilterPolicy, bloom_before_level_),
+        OptionType::kAtomicInt, OptionVerificationType::kNormal,
+        OptionTypeFlags::kMutable}},
+  };
+  RegisterOptions(this, &type_info);
+}
 
 FilterBitsBuilder* RibbonFilterPolicy::GetBuilderWithContext(
     const FilterBuildingContext& context) const {
@@ -1738,31 +1748,38 @@ FilterBitsBuilder* RibbonFilterPolicy::GetBuilderWithContext(
     // "No filter" special case
     return nullptr;
   }
-  // Treat unknown same as bottommost
-  int levelish = INT_MAX;
-
-  switch (context.compaction_style) {
-    case kCompactionStyleLevel:
-    case kCompactionStyleUniversal: {
-      if (context.reason == TableFileCreationReason::kFlush) {
-        // Treat flush as level -1
-        assert(context.level_at_creation == 0);
-        levelish = -1;
-      } else if (context.level_at_creation == -1) {
-        // Unknown level
-        assert(levelish == INT_MAX);
-      } else {
-        levelish = context.level_at_creation;
+  // Treat unknown same as bottommost, INT_MAX - 1.
+  // INT_MAX is reserved for "always use Bloom".
+  int levelish = INT_MAX - 1;
+
+  int bloom_before_level = bloom_before_level_.load(std::memory_order_relaxed);
+  if (bloom_before_level < INT_MAX) {
+    switch (context.compaction_style) {
+      case kCompactionStyleLevel:
+      case kCompactionStyleUniversal: {
+        if (context.reason == TableFileCreationReason::kFlush) {
+          // Treat flush as level -1
+          assert(context.level_at_creation == 0);
+          levelish = -1;
+        } else if (context.level_at_creation == -1) {
+          // Unknown level
+          assert(levelish == INT_MAX - 1);
+        } else {
+          levelish = context.level_at_creation;
+        }
+        break;
       }
-      break;
+      case kCompactionStyleFIFO:
+      case kCompactionStyleNone:
+        // Treat as bottommost
+        assert(levelish == INT_MAX - 1);
+        break;
     }
-    case kCompactionStyleFIFO:
-    case kCompactionStyleNone:
-      // Treat as bottommost
-      assert(levelish == INT_MAX);
-      break;
+  } else {
+    // INT_MAX == always Bloom
+    assert(levelish < bloom_before_level);
   }
-  if (levelish < bloom_before_level_) {
+  if (levelish < bloom_before_level) {
     return GetFastLocalBloomBuilderWithContext(context);
   } else {
     return GetStandard128RibbonBuilderWithContext(context);
@@ -1771,14 +1788,15 @@ FilterBitsBuilder* RibbonFilterPolicy::GetBuilderWithContext(
 
 const char* RibbonFilterPolicy::kClassName() { return "ribbonfilter"; }
 const char* RibbonFilterPolicy::kNickName() { return "rocksdb.RibbonFilter"; }
+const char* RibbonFilterPolicy::kName() { return "RibbonFilterPolicy"; }
 
 std::string RibbonFilterPolicy::GetId() const {
   return BloomLikeFilterPolicy::GetId() + ":" +
-         std::to_string(bloom_before_level_);
+         std::to_string(bloom_before_level_.load(std::memory_order_acquire));
 }
 
-const FilterPolicy* NewRibbonFilterPolicy(double bloom_equivalent_bits_per_key,
-                                          int bloom_before_level) {
+FilterPolicy* NewRibbonFilterPolicy(double bloom_equivalent_bits_per_key,
+                                    int bloom_before_level) {
   return new RibbonFilterPolicy(bloom_equivalent_bits_per_key,
                                 bloom_before_level);
 }

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

@@ -290,10 +290,11 @@ class RibbonFilterPolicy : public BloomLikeFilterPolicy {
   const char* Name() const override { return kClassName(); }
   static const char* kNickName();
   const char* NickName() const override { return kNickName(); }
+  static const char* kName();
   std::string GetId() const override;
 
  private:
-  const int bloom_before_level_;
+  std::atomic<int> bloom_before_level_;
 };
 
 // For testing only, but always constructable with internal names

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

@@ -29,7 +29,7 @@ Status BlockBasedTable::IndexReaderCommon::ReadIndexBlock(
       prefetch_buffer, read_options, rep->index_handle,
       UncompressionDict::GetEmptyDict(), &index_block->As<Block_kIndex>(),
       get_context, lookup_context, /* for_compaction */ false, use_cache,
-      /* async_read */ false);
+      /* async_read */ false, /* use_block_cache_for_lookup */ true);
 
   return s;
 }

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

@@ -317,12 +317,12 @@ Status PartitionedFilterBlockReader::GetFilterPartitionBlock(
     read_options.read_tier = kBlockCacheTier;
   }
 
-  const Status s =
-      table()->RetrieveBlock(prefetch_buffer, read_options, fltr_blk_handle,
-                             UncompressionDict::GetEmptyDict(), filter_block,
-                             get_context, lookup_context,
-                             /* for_compaction */ false, /* use_cache */ true,
-                             /* async_read */ false);
+  const Status s = table()->RetrieveBlock(
+      prefetch_buffer, read_options, fltr_blk_handle,
+      UncompressionDict::GetEmptyDict(), filter_block, get_context,
+      lookup_context,
+      /* for_compaction */ false, /* use_cache */ true,
+      /* async_read */ false, /* use_block_cache_for_lookup */ true);
 
   return s;
 }
@@ -498,7 +498,8 @@ Status PartitionedFilterBlockReader::CacheDependencies(
     rep->CreateFilePrefetchBuffer(
         0, 0, &prefetch_buffer, false /* Implicit autoreadahead */,
         0 /*num_reads_*/, 0 /*num_file_reads_for_auto_readahead*/,
-        /*upper_bound_offset*/ 0);
+        /*upper_bound_offset*/ 0, /*readaheadsize_cb*/ nullptr,
+        /*usage=*/FilePrefetchBufferUsage::kUnknown);
 
     IOOptions opts;
     s = rep->file->PrepareIOOptions(ro, opts);
@@ -521,7 +522,8 @@ Status PartitionedFilterBlockReader::CacheDependencies(
         prefetch_buffer ? prefetch_buffer.get() : tail_prefetch_buffer, ro,
         handle, UncompressionDict::GetEmptyDict(),
         /* for_compaction */ false, &block, nullptr /* get_context */,
-        &lookup_context, nullptr /* contents */, false);
+        &lookup_context, nullptr /* contents */, false,
+        /* use_block_cache_for_lookup */ true);
     if (!s.ok()) {
       return s;
     }

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

@@ -91,14 +91,16 @@ void PartitionedIndexIterator::InitPartitionedIndexBlock() {
     //   Enabled from the very first IO when ReadOptions.readahead_size is set.
     block_prefetcher_.PrefetchIfNeeded(
         rep, partitioned_index_handle, read_options_.readahead_size,
-        is_for_compaction, /*no_sequential_checking=*/false, read_options_);
+        is_for_compaction, /*no_sequential_checking=*/false, read_options_,
+        /*readaheadsize_cb=*/nullptr);
     Status s;
     table_->NewDataBlockIterator<IndexBlockIter>(
         read_options_, partitioned_index_handle, &block_iter_,
         BlockType::kIndex,
         /*get_context=*/nullptr, &lookup_context_,
         block_prefetcher_.prefetch_buffer(),
-        /*for_compaction=*/is_for_compaction, /*async_read=*/false, s);
+        /*for_compaction=*/is_for_compaction, /*async_read=*/false, s,
+        /*use_block_cache_for_lookup=*/true);
     block_iter_points_to_real_block_ = true;
     // We could check upper bound here but it is complicated to reason about
     // upper bound in index iterator. On the other than, in large scans, index

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

@@ -170,7 +170,8 @@ Status PartitionIndexReader::CacheDependencies(
     rep->CreateFilePrefetchBuffer(
         0, 0, &prefetch_buffer, false /*Implicit auto readahead*/,
         0 /*num_reads_*/, 0 /*num_file_reads_for_auto_readahead*/,
-        /*upper_bound_offset*/ 0);
+        /*upper_bound_offset*/ 0, /*readaheadsize_cb*/ nullptr,
+        /*usage=*/FilePrefetchBufferUsage::kUnknown);
     IOOptions opts;
     {
       Status s = rep->file->PrepareIOOptions(ro, opts);
@@ -200,7 +201,7 @@ Status PartitionIndexReader::CacheDependencies(
         handle, UncompressionDict::GetEmptyDict(),
         /*for_compaction=*/false, &block.As<Block_kIndex>(),
         /*get_context=*/nullptr, &lookup_context, /*contents=*/nullptr,
-        /*async_read=*/false);
+        /*async_read=*/false, /*use_block_cache_for_lookup=*/true);
 
     if (!s.ok()) {
       return s;

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

@@ -63,7 +63,7 @@ Status UncompressionDictReader::ReadUncompressionDictionary(
       UncompressionDict::GetEmptyDict(), uncompression_dict, get_context,
       lookup_context,
       /* for_compaction */ false, use_cache,
-      /* async_read */ false);
+      /* async_read */ false, /* use_block_cache_for_lookup */ true);
 
   if (!s.ok()) {
     ROCKS_LOG_WARN(

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

@@ -336,9 +336,11 @@ IOStatus BlockFetcher::ReadBlockContents() {
 #ifndef NDEBUG
     num_heap_buf_memcpy_++;
 #endif
-    compression_type_ = kNoCompression;
+    // Save the compressed block without trailer
+    slice_ = Slice(slice_.data(), block_size_);
   } else {
     GetBlockContents();
+    slice_ = Slice();
   }
 
   InsertUncompressedBlockToPersistentCacheIfNeeded();
@@ -387,7 +389,6 @@ IOStatus BlockFetcher::ReadAsyncBlockContents() {
 #ifndef NDEBUG
           num_heap_buf_memcpy_++;
 #endif
-          compression_type_ = kNoCompression;
         } else {
           GetBlockContents();
         }

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

@@ -79,6 +79,10 @@ class BlockFetcher {
   inline size_t GetBlockSizeWithTrailer() const {
     return block_size_with_trailer_;
   }
+  inline Slice& GetCompressedBlock() {
+    assert(compression_type_ != kNoCompression);
+    return slice_;
+  }
 
 #ifndef NDEBUG
   int TEST_GetNumStackBufMemcpy() const { return num_stack_buf_memcpy_; }

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

@@ -299,7 +299,7 @@ class BlockFetcherTest : public testing::Test {
                   MemoryAllocator* heap_buf_allocator,
                   MemoryAllocator* compressed_buf_allocator,
                   BlockContents* contents, MemcpyStats* stats,
-                  CompressionType* compresstion_type) {
+                  CompressionType* compression_type) {
     ImmutableOptions ioptions(options_);
     ReadOptions roptions;
     PersistentCacheOptions persistent_cache_options;
@@ -318,7 +318,11 @@ class BlockFetcherTest : public testing::Test {
     stats->num_compressed_buf_memcpy =
         fetcher->TEST_GetNumCompressedBufMemcpy();
 
-    *compresstion_type = fetcher->get_compression_type();
+    if (do_uncompress) {
+      *compression_type = kNoCompression;
+    } else {
+      *compression_type = fetcher->get_compression_type();
+    }
   }
 
   // NOTE: expected_compression_type is the expected compression