@nxtedition/rocksdb 8.2.0-alpha.1 → 8.2.0

package/deps/rocksdb/rocksdb/include/rocksdb/version.h

@@ -12,8 +12,8 @@
 // NOTE: in 'main' development branch, this should be the *next*
 // minor or major version number planned for release.
 #define ROCKSDB_MAJOR 8
-#define ROCKSDB_MINOR 0
-#define ROCKSDB_PATCH 0
+#define ROCKSDB_MINOR 1
+#define ROCKSDB_PATCH 1
 
 // Do not use these. We made the mistake of declaring macros starting with
 // double underscore. Now we have to live with our choice. We'll deprecate these

package/deps/rocksdb/rocksdb/include/rocksdb/wide_columns.h

@@ -97,15 +97,22 @@ class PinnableWideColumns {
 
   void SetPlainValue(const Slice& value);
   void SetPlainValue(const Slice& value, Cleanable* cleanable);
+  void SetPlainValue(PinnableSlice&& value);
+  void SetPlainValue(std::string&& value);
 
   Status SetWideColumnValue(const Slice& value);
   Status SetWideColumnValue(const Slice& value, Cleanable* cleanable);
+  Status SetWideColumnValue(PinnableSlice&& value);
+  Status SetWideColumnValue(std::string&& value);
 
   void Reset();
 
  private:
   void CopyValue(const Slice& value);
   void PinOrCopyValue(const Slice& value, Cleanable* cleanable);
+  void MoveValue(PinnableSlice&& value);
+  void MoveValue(std::string&& value);
+
   void CreateIndexForPlainValue();
   Status CreateIndexForWideColumns();
 
@@ -127,6 +134,18 @@ inline void PinnableWideColumns::PinOrCopyValue(const Slice& value,
   value_.PinSlice(value, cleanable);
 }
 
+inline void PinnableWideColumns::MoveValue(PinnableSlice&& value) {
+  value_ = std::move(value);
+}
+
+inline void PinnableWideColumns::MoveValue(std::string&& value) {
+  std::string* const buf = value_.GetSelf();
+  assert(buf);
+
+  *buf = std::move(value);
+  value_.PinSelf();
+}
+
 inline void PinnableWideColumns::CreateIndexForPlainValue() {
   columns_ = WideColumns{{kDefaultWideColumnName, value_}};
 }
@@ -142,6 +161,16 @@ inline void PinnableWideColumns::SetPlainValue(const Slice& value,
   CreateIndexForPlainValue();
 }
 
+inline void PinnableWideColumns::SetPlainValue(PinnableSlice&& value) {
+  MoveValue(std::move(value));
+  CreateIndexForPlainValue();
+}
+
+inline void PinnableWideColumns::SetPlainValue(std::string&& value) {
+  MoveValue(std::move(value));
+  CreateIndexForPlainValue();
+}
+
 inline Status PinnableWideColumns::SetWideColumnValue(const Slice& value) {
   CopyValue(value);
   return CreateIndexForWideColumns();
@@ -153,6 +182,16 @@ inline Status PinnableWideColumns::SetWideColumnValue(const Slice& value,
   return CreateIndexForWideColumns();
 }
 
+inline Status PinnableWideColumns::SetWideColumnValue(PinnableSlice&& value) {
+  MoveValue(std::move(value));
+  return CreateIndexForWideColumns();
+}
+
+inline Status PinnableWideColumns::SetWideColumnValue(std::string&& value) {
+  MoveValue(std::move(value));
+  return CreateIndexForWideColumns();
+}
+
 inline void PinnableWideColumns::Reset() {
   value_.Reset();
   columns_.clear();

package/deps/rocksdb/rocksdb/monitoring/perf_context.cc

@@ -69,6 +69,7 @@ PerfContext::PerfContext(const PerfContext& other) {
   internal_delete_skipped_count = other.internal_delete_skipped_count;
   internal_recent_skipped_count = other.internal_recent_skipped_count;
   internal_merge_count = other.internal_merge_count;
+  internal_merge_point_lookup_count = other.internal_merge_point_lookup_count;
   internal_range_del_reseek_count = other.internal_range_del_reseek_count;
   write_wal_time = other.write_wal_time;
   get_snapshot_time = other.get_snapshot_time;
@@ -188,6 +189,7 @@ PerfContext::PerfContext(PerfContext&& other) noexcept {
   internal_delete_skipped_count = other.internal_delete_skipped_count;
   internal_recent_skipped_count = other.internal_recent_skipped_count;
   internal_merge_count = other.internal_merge_count;
+  internal_merge_point_lookup_count = other.internal_merge_point_lookup_count;
   internal_range_del_reseek_count = other.internal_range_del_reseek_count;
   write_wal_time = other.write_wal_time;
   get_snapshot_time = other.get_snapshot_time;
@@ -309,6 +311,7 @@ PerfContext& PerfContext::operator=(const PerfContext& other) {
   internal_delete_skipped_count = other.internal_delete_skipped_count;
   internal_recent_skipped_count = other.internal_recent_skipped_count;
   internal_merge_count = other.internal_merge_count;
+  internal_merge_point_lookup_count = other.internal_merge_point_lookup_count;
   internal_range_del_reseek_count = other.internal_range_del_reseek_count;
   write_wal_time = other.write_wal_time;
   get_snapshot_time = other.get_snapshot_time;
@@ -422,6 +425,7 @@ void PerfContext::Reset() {
   internal_delete_skipped_count = 0;
   internal_recent_skipped_count = 0;
   internal_merge_count = 0;
+  internal_merge_point_lookup_count = 0;
   internal_range_del_reseek_count = 0;
   write_wal_time = 0;
 
@@ -556,6 +560,7 @@ std::string PerfContext::ToString(bool exclude_zero_counters) const {
   PERF_CONTEXT_OUTPUT(internal_delete_skipped_count);
   PERF_CONTEXT_OUTPUT(internal_recent_skipped_count);
   PERF_CONTEXT_OUTPUT(internal_merge_count);
+  PERF_CONTEXT_OUTPUT(internal_merge_point_lookup_count);
   PERF_CONTEXT_OUTPUT(internal_range_del_reseek_count);
   PERF_CONTEXT_OUTPUT(write_wal_time);
   PERF_CONTEXT_OUTPUT(get_snapshot_time);

package/deps/rocksdb/rocksdb/monitoring/statistics.cc

@@ -213,7 +213,13 @@ const std::vector<std::pair<Tickers, std::string>> TickersNameMap = {
     {BLOB_DB_CACHE_BYTES_READ, "rocksdb.blobdb.cache.bytes.read"},
     {BLOB_DB_CACHE_BYTES_WRITE, "rocksdb.blobdb.cache.bytes.write"},
     {READ_ASYNC_MICROS, "rocksdb.read.async.micros"},
-    {ASYNC_READ_ERROR_COUNT, "rocksdb.async.read.error.count"}};
+    {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"},
+    {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"},
@@ -269,6 +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_OPEN_PREFETCH_TAIL_READ_BYTES,
+     "rocksdb.table.open.prefetch.tail.read.bytes"},
 };
 
 std::shared_ptr<Statistics> CreateDBStatistics() {

package/deps/rocksdb/rocksdb/options/customizable_test.cc

@@ -1236,8 +1236,8 @@ class TestSecondaryCache : public SecondaryCache {
   std::unique_ptr<SecondaryCacheResultHandle> Lookup(
       const Slice& /*key*/, const Cache::CacheItemHelper* /*helper*/,
       Cache::CreateContext* /*create_context*/, bool /*wait*/,
-      bool /*advise_erase*/, bool& is_in_sec_cache) override {
-    is_in_sec_cache = true;
+      bool /*advise_erase*/, bool& kept_in_sec_cache) override {
+    kept_in_sec_cache = true;
     return nullptr;
   }
 

package/deps/rocksdb/rocksdb/port/stack_trace.cc

@@ -141,20 +141,30 @@ void PrintStack(void* frames[], int num_frames) {
 }
 
 void PrintStack(int first_frames_to_skip) {
-#if defined(ROCKSDB_DLL) && defined(OS_LINUX)
-  // LIB_MODE=shared build produces mediocre information from the above
-  // backtrace+addr2line stack trace method. Try to use GDB in that case, but
-  // only on Linux where we know how to attach to a particular thread.
-  bool linux_dll = true;
+  // Default to getting stack traces with GDB, at least on Linux where we
+  // know how to attach to a particular thread.
+  //
+  // * Address space layout randomization (ASLR) interferes with getting good
+  //   stack information from backtrace+addr2line. This is more likely to show
+  //   up with LIB_MODE=shared builds (when kernel.randomize_va_space >= 1)
+  //   but can also show up with LIB_MODE=static builds ((when
+  //   kernel.randomize_va_space == 2).
+  // * It doesn't appear easy to detect when ASLR is in use.
+  // * With DEBUG_LEVEL < 2, backtrace() can skip frames that are not skipped
+  //   in GDB.
+#if defined(OS_LINUX)
+  // Default true, override with ROCKSDB_BACKTRACE_STACK=1
+  bool gdb_stack_trace = getenv("ROCKSDB_BACKTRACE_STACK") == nullptr;
 #else
-  bool linux_dll = false;
+  // Default false, override with ROCKSDB_GDB_STACK=1
+  bool gdb_stack_trace = getenv("ROCKSDB_GDB_STACK") != nullptr;
 #endif
   // Also support invoking interactive debugger on stack trace, with this
   // envvar set to non-empty
   char* debug_env = getenv("ROCKSDB_DEBUG");
   bool debug = debug_env != nullptr && strlen(debug_env) > 0;
 
-  if (linux_dll || debug) {
+  if (gdb_stack_trace || debug) {
     // Allow ouside debugger to attach, even with Yama security restrictions
 #ifdef PR_SET_PTRACER_ANY
     (void)prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0);

package/deps/rocksdb/rocksdb/port/win/env_win.h

@@ -227,6 +227,7 @@ class WinFileSystem : public FileSystem {
       const FileOptions& file_options) const override;
   FileOptions OptimizeForManifestWrite(
       const FileOptions& file_options) const override;
+  bool use_async_io() override { return false; }
 
  protected:
   static uint64_t FileTimeToUnixTime(const FILETIME& ftTime);

package/deps/rocksdb/rocksdb/src.mk

@@ -10,6 +10,7 @@ LIB_SOURCES =                                                   \
   cache/lru_cache.cc                                            \
   cache/compressed_secondary_cache.cc                           \
   cache/secondary_cache.cc                                      \
+  cache/secondary_cache_adapter.cc                              \
   cache/sharded_cache.cc                                        \
   db/arena_wrapped_db_iter.cc                                   \
   db/blob/blob_contents.cc                                      \
@@ -96,6 +97,7 @@ LIB_SOURCES =                                                   \
   db/write_batch.cc                                             \
   db/write_batch_base.cc                                        \
   db/write_controller.cc                                        \
+  db/write_stall_stats.cc                                       \
   db/write_thread.cc                                            \
   env/composite_env.cc                                          \
   env/env.cc                                                    \
@@ -198,6 +200,7 @@ LIB_SOURCES =                                                   \
   table/get_context.cc                                          \
   table/iterator.cc                                             \
   table/merging_iterator.cc                                     \
+  table/compaction_merging_iterator.cc                          \
   table/meta_blocks.cc                                          \
   table/persistent_cache_helper.cc                              \
   table/plain/plain_table_bloom.cc                              \
@@ -381,6 +384,7 @@ TEST_LIB_SOURCES =                                              \
   db/db_test_util.cc                                            \
   db/db_with_timestamp_test_util.cc                             \
   test_util/mock_time_env.cc                                    \
+  test_util/secondary_cache_test_util.cc                        \
   test_util/testharness.cc                                      \
   test_util/testutil.cc                                         \
   utilities/agg_merge/test_agg_merge.cc                                 \

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

@@ -94,7 +94,7 @@ CacheAllocationPtr CopyBufferToHeap(MemoryAllocator* allocator, Slice& buf) {
       const BlockHandle& handle, const UncompressionDict& uncompression_dict, \
       CachableEntry<T>* out_parsed_block, GetContext* get_context,            \
       BlockCacheLookupContext* lookup_context, bool for_compaction,           \
-      bool use_cache, bool wait_for_cache, bool async_read) const;
+      bool use_cache, bool async_read) const;
 
 INSTANTIATE_RETRIEVE_BLOCK(ParsedFullFilterBlock);
 INSTANTIATE_RETRIEVE_BLOCK(UncompressionDict);
@@ -591,7 +591,7 @@ Status BlockBasedTable::Open(
   if (!ioptions.allow_mmap_reads) {
     s = PrefetchTail(ro, file.get(), file_size, force_direct_prefetch,
                      tail_prefetch_stats, prefetch_all, preload_all,
-                     &prefetch_buffer);
+                     &prefetch_buffer, ioptions.stats);
     // Return error in prefetch path to users.
     if (!s.ok()) {
       return s;
@@ -802,7 +802,7 @@ Status BlockBasedTable::PrefetchTail(
     const ReadOptions& ro, RandomAccessFileReader* file, uint64_t file_size,
     bool force_direct_prefetch, TailPrefetchStats* tail_prefetch_stats,
     const bool prefetch_all, const bool preload_all,
-    std::unique_ptr<FilePrefetchBuffer>* prefetch_buffer) {
+    std::unique_ptr<FilePrefetchBuffer>* prefetch_buffer, Statistics* stats) {
   size_t tail_prefetch_size = 0;
   if (tail_prefetch_stats != nullptr) {
     // Multiple threads may get a 0 (no history) when running in parallel,
@@ -842,9 +842,12 @@ 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);
@@ -1251,24 +1254,31 @@ Status BlockBasedTable::ReadMetaIndexBlock(
 }
 
 template <typename TBlocklike>
-WithBlocklikeCheck<Status, TBlocklike> BlockBasedTable::GetDataBlockFromCache(
-    const Slice& cache_key, BlockCacheInterface<TBlocklike> block_cache,
-    CachableEntry<TBlocklike>* out_parsed_block, const bool wait,
-    GetContext* get_context) const {
-  assert(out_parsed_block);
-  assert(out_parsed_block->IsEmpty());
+Cache::Priority BlockBasedTable::GetCachePriority() const {
   // Here we treat the legacy name "...index_and_filter_blocks..." to mean all
   // metadata blocks that might go into block cache, EXCEPT only those needed
   // for the read path (Get, etc.). TableProperties should not be needed on the
   // read path (prefix extractor setting is an O(1) size special case that we
   // are working not to require from TableProperties), so it is not given
   // high-priority treatment if it should go into BlockCache.
-  const Cache::Priority priority =
-      rep_->table_options.cache_index_and_filter_blocks_with_high_priority &&
-              TBlocklike::kBlockType != BlockType::kData &&
-              TBlocklike::kBlockType != BlockType::kProperties
-          ? Cache::Priority::HIGH
-          : Cache::Priority::LOW;
+  if constexpr (TBlocklike::kBlockType == BlockType::kData ||
+                TBlocklike::kBlockType == BlockType::kProperties) {
+    return Cache::Priority::LOW;
+  } else if (rep_->table_options
+                 .cache_index_and_filter_blocks_with_high_priority) {
+    return Cache::Priority::HIGH;
+  } else {
+    return Cache::Priority::LOW;
+  }
+}
+
+template <typename TBlocklike>
+WithBlocklikeCheck<Status, TBlocklike> BlockBasedTable::GetDataBlockFromCache(
+    const Slice& cache_key, BlockCacheInterface<TBlocklike> block_cache,
+    CachableEntry<TBlocklike>* out_parsed_block,
+    GetContext* get_context) const {
+  assert(out_parsed_block);
+  assert(out_parsed_block->IsEmpty());
 
   Status s;
   Statistics* statistics = rep_->ioptions.statistics.get();
@@ -1277,8 +1287,8 @@ WithBlocklikeCheck<Status, TBlocklike> BlockBasedTable::GetDataBlockFromCache(
   if (block_cache) {
     assert(!cache_key.empty());
     auto cache_handle = block_cache.LookupFull(
-        cache_key, &rep_->create_context, priority, wait, statistics,
-        rep_->ioptions.lowest_used_cache_tier);
+        cache_key, &rep_->create_context, GetCachePriority<TBlocklike>(),
+        statistics, rep_->ioptions.lowest_used_cache_tier);
 
     // Avoid updating metrics here if the handle is not complete yet. This
     // happens with MultiGet and secondary cache. So update the metrics only
@@ -1311,11 +1321,6 @@ WithBlocklikeCheck<Status, TBlocklike> BlockBasedTable::PutDataBlockToCache(
     MemoryAllocator* memory_allocator, GetContext* get_context) const {
   const ImmutableOptions& ioptions = rep_->ioptions;
   const uint32_t format_version = rep_->table_options.format_version;
-  const Cache::Priority priority =
-      rep_->table_options.cache_index_and_filter_blocks_with_high_priority &&
-              TBlocklike::kBlockType != BlockType::kData
-          ? Cache::Priority::HIGH
-          : Cache::Priority::LOW;
   assert(out_parsed_block);
   assert(out_parsed_block->IsEmpty());
 
@@ -1346,7 +1351,7 @@ WithBlocklikeCheck<Status, TBlocklike> BlockBasedTable::PutDataBlockToCache(
     size_t charge = block_holder->ApproximateMemoryUsage();
     BlockCacheTypedHandle<TBlocklike>* cache_handle = nullptr;
     s = block_cache.InsertFull(cache_key, block_holder.get(), charge,
-                               &cache_handle, priority,
+                               &cache_handle, GetCachePriority<TBlocklike>(),
                                rep_->ioptions.lowest_used_cache_tier);
 
     if (s.ok()) {
@@ -1443,10 +1448,9 @@ WithBlocklikeCheck<Status, TBlocklike>
 BlockBasedTable::MaybeReadBlockAndLoadToCache(
     FilePrefetchBuffer* prefetch_buffer, const ReadOptions& ro,
     const BlockHandle& handle, const UncompressionDict& uncompression_dict,
-    const bool wait, const bool for_compaction,
-    CachableEntry<TBlocklike>* out_parsed_block, GetContext* get_context,
-    BlockCacheLookupContext* lookup_context, BlockContents* contents,
-    bool async_read) const {
+    bool for_compaction, CachableEntry<TBlocklike>* out_parsed_block,
+    GetContext* get_context, BlockCacheLookupContext* lookup_context,
+    BlockContents* contents, bool async_read) const {
   assert(out_parsed_block != nullptr);
   const bool no_io = (ro.read_tier == kBlockCacheTier);
   BlockCacheInterface<TBlocklike> block_cache{
@@ -1465,7 +1469,7 @@ BlockBasedTable::MaybeReadBlockAndLoadToCache(
     key = key_data.AsSlice();
 
     if (!contents) {
-      s = GetDataBlockFromCache(key, block_cache, out_parsed_block, wait,
+      s = GetDataBlockFromCache(key, block_cache, out_parsed_block,
                                 get_context);
       // Value could still be null at this point, so check the cache handle
       // and update the read pattern for prefetching
@@ -1626,15 +1630,15 @@ WithBlocklikeCheck<Status, TBlocklike> BlockBasedTable::RetrieveBlock(
     const BlockHandle& handle, const UncompressionDict& uncompression_dict,
     CachableEntry<TBlocklike>* out_parsed_block, GetContext* get_context,
     BlockCacheLookupContext* lookup_context, bool for_compaction,
-    bool use_cache, bool wait_for_cache, bool async_read) const {
+    bool use_cache, bool async_read) const {
   assert(out_parsed_block);
   assert(out_parsed_block->IsEmpty());
 
   Status s;
   if (use_cache) {
     s = MaybeReadBlockAndLoadToCache(
-        prefetch_buffer, ro, handle, uncompression_dict, wait_for_cache,
-        for_compaction, out_parsed_block, get_context, lookup_context,
+        prefetch_buffer, ro, handle, uncompression_dict, for_compaction,
+        out_parsed_block, get_context, lookup_context,
         /*contents=*/nullptr, async_read);
 
     if (!s.ok()) {

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

@@ -336,10 +336,9 @@ class BlockBasedTable : public TableReader {
   WithBlocklikeCheck<Status, TBlocklike> MaybeReadBlockAndLoadToCache(
       FilePrefetchBuffer* prefetch_buffer, const ReadOptions& ro,
       const BlockHandle& handle, const UncompressionDict& uncompression_dict,
-      const bool wait, const bool for_compaction,
-      CachableEntry<TBlocklike>* block_entry, GetContext* get_context,
-      BlockCacheLookupContext* lookup_context, BlockContents* contents,
-      bool async_read) const;
+      bool for_compaction, CachableEntry<TBlocklike>* block_entry,
+      GetContext* get_context, BlockCacheLookupContext* lookup_context,
+      BlockContents* contents, bool async_read) const;
 
   // Similar to the above, with one crucial difference: it will retrieve the
   // block from the file even if there are no caches configured (assuming the
@@ -350,16 +349,14 @@ class BlockBasedTable : public TableReader {
       const BlockHandle& handle, const UncompressionDict& uncompression_dict,
       CachableEntry<TBlocklike>* block_entry, GetContext* get_context,
       BlockCacheLookupContext* lookup_context, bool for_compaction,
-      bool use_cache, bool wait_for_cache, bool async_read) const;
+      bool use_cache, bool async_read) const;
 
   DECLARE_SYNC_AND_ASYNC_CONST(
       void, RetrieveMultipleBlocks, const ReadOptions& options,
       const MultiGetRange* batch,
       const autovector<BlockHandle, MultiGetContext::MAX_BATCH_SIZE>* handles,
-      autovector<Status, MultiGetContext::MAX_BATCH_SIZE>* statuses,
-      autovector<CachableEntry<Block>, MultiGetContext::MAX_BATCH_SIZE>*
-          results,
-      char* scratch, const UncompressionDict& uncompression_dict);
+      Status* statuses, CachableEntry<Block>* results, char* scratch,
+      const UncompressionDict& uncompression_dict);
 
   // Get the iterator from the index reader.
   //
@@ -379,6 +376,9 @@ class BlockBasedTable : public TableReader {
       IndexBlockIter* input_iter, GetContext* get_context,
       BlockCacheLookupContext* lookup_context) const;
 
+  template <typename TBlocklike>
+  Cache::Priority GetCachePriority() const;
+
   // Read block cache from block caches (if set): block_cache.
   // On success, Status::OK with be returned and @block will be populated with
   // pointer to the block as well as its block handle.
@@ -387,8 +387,7 @@ class BlockBasedTable : public TableReader {
   template <typename TBlocklike>
   WithBlocklikeCheck<Status, TBlocklike> GetDataBlockFromCache(
       const Slice& cache_key, BlockCacheInterface<TBlocklike> block_cache,
-      CachableEntry<TBlocklike>* block, const bool wait,
-      GetContext* get_context) const;
+      CachableEntry<TBlocklike>* block, GetContext* get_context) const;
 
   // Put a maybe compressed block to the corresponding block caches.
   // This method will perform decompression against block_contents if needed
@@ -444,7 +443,7 @@ class BlockBasedTable : public TableReader {
       const ReadOptions& ro, RandomAccessFileReader* file, uint64_t file_size,
       bool force_direct_prefetch, TailPrefetchStats* tail_prefetch_stats,
       const bool prefetch_all, const bool preload_all,
-      std::unique_ptr<FilePrefetchBuffer>* prefetch_buffer);
+      std::unique_ptr<FilePrefetchBuffer>* prefetch_buffer, Statistics* stats);
   Status ReadMetaIndexBlock(const ReadOptions& ro,
                             FilePrefetchBuffer* prefetch_buffer,
                             std::unique_ptr<Block>* metaindex_block,

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

@@ -77,15 +77,15 @@ TBlockIter* BlockBasedTable::NewDataBlockIterator(
     const UncompressionDict& dict = uncompression_dict.GetValue()
                                         ? *uncompression_dict.GetValue()
                                         : UncompressionDict::GetEmptyDict();
-    s = RetrieveBlock(
-        prefetch_buffer, ro, handle, dict, &block.As<IterBlocklike>(),
-        get_context, lookup_context, for_compaction,
-        /* use_cache */ true, /* wait_for_cache */ true, async_read);
+    s = RetrieveBlock(prefetch_buffer, ro, handle, dict,
+                      &block.As<IterBlocklike>(), get_context, lookup_context,
+                      for_compaction,
+                      /* use_cache */ true, async_read);
   } else {
     s = RetrieveBlock(
         prefetch_buffer, ro, handle, UncompressionDict::GetEmptyDict(),
         &block.As<IterBlocklike>(), get_context, lookup_context, for_compaction,
-        /* use_cache */ true, /* wait_for_cache */ true, async_read);
+        /* use_cache */ true, async_read);
   }
 
   if (s.IsTryAgain() && async_read) {