rocksdb-native 2.2.0 → 2.3.0

package/vendor/librocksdb/vendor/rocksdb/table/block_based/partitioned_filter_block.cc

@@ -30,6 +30,7 @@ PartitionedFilterBlockBuilder::PartitionedFilterBlockBuilder(
     const bool persist_user_defined_timestamps)
     : FullFilterBlockBuilder(_prefix_extractor, whole_key_filtering,
                              filter_bits_builder),
+      p_index_builder_(p_index_builder),
       index_on_filter_block_builder_(
           index_block_restart_interval, true /*use_delta_encoding*/,
           use_value_delta_encoding,
@@ -41,10 +42,10 @@ PartitionedFilterBlockBuilder::PartitionedFilterBlockBuilder(
           use_value_delta_encoding,
           BlockBasedTableOptions::kDataBlockBinarySearch /* index_type */,
           0.75 /* data_block_hash_table_util_ratio */, ts_sz,
-          persist_user_defined_timestamps, true /* is_user_key */),
-      p_index_builder_(p_index_builder),
-      keys_added_to_partition_(0),
-      total_added_in_built_(0) {
+          persist_user_defined_timestamps, true /* is_user_key */) {
+  // See FullFilterBlockBuilder::AddPrefix
+  need_last_prefix_ = prefix_extractor() != nullptr;
+  // Compute keys_per_partition_
   keys_per_partition_ = static_cast<uint32_t>(
       filter_bits_builder_->ApproximateNumEntries(partition_size));
   if (keys_per_partition_ < 1) {
@@ -75,8 +76,9 @@ PartitionedFilterBlockBuilder::~PartitionedFilterBlockBuilder() {
 
 void PartitionedFilterBlockBuilder::MaybeCutAFilterBlock(
     const Slice* next_key) {
-  // Use == to send the request only once
-  if (keys_added_to_partition_ == keys_per_partition_) {
+  // (NOTE: Can't just use ==, because keys_added_to_partition_ might be
+  // incremented by more than one.)
+  if (keys_added_to_partition_ >= keys_per_partition_) {
     // Currently only index builder is in charge of cutting a partition. We keep
     // requesting until it is granted.
     p_index_builder_->RequestPartitionCut();
@@ -86,7 +88,7 @@ void PartitionedFilterBlockBuilder::MaybeCutAFilterBlock(
   }
 
   // Add the prefix of the next key before finishing the partition without
-  // updating last_prefix_str_. This hack, fixes a bug with format_verison=3
+  // updating last_prefix_str_. This hack fixes a bug with format_verison=3
   // where seeking for the prefix would lead us to the previous partition.
   const bool maybe_add_prefix =
       next_key && prefix_extractor() && prefix_extractor()->InDomain(*next_key);
@@ -105,19 +107,17 @@ void PartitionedFilterBlockBuilder::MaybeCutAFilterBlock(
   if (filter_construction_status.ok()) {
     filter_construction_status = filter_bits_builder_->MaybePostVerify(filter);
   }
-  std::string& index_key = p_index_builder_->GetPartitionKey();
-  filters.push_back({index_key, std::move(filter_data), filter});
-  if (!filter_construction_status.ok() &&
-      partitioned_filters_construction_status_.ok()) {
-    partitioned_filters_construction_status_ = filter_construction_status;
-  }
+  filters_.push_back(
+      {p_index_builder_->GetPartitionKey(), std::move(filter_data), filter});
+  partitioned_filters_construction_status_.UpdateIfOk(
+      filter_construction_status);
   keys_added_to_partition_ = 0;
   Reset();
 }
 
-void PartitionedFilterBlockBuilder::Add(const Slice& key) {
-  MaybeCutAFilterBlock(&key);
-  FullFilterBlockBuilder::Add(key);
+void PartitionedFilterBlockBuilder::Add(const Slice& key_without_ts) {
+  MaybeCutAFilterBlock(&key_without_ts);
+  FullFilterBlockBuilder::Add(key_without_ts);
 }
 
 void PartitionedFilterBlockBuilder::AddKey(const Slice& key) {
@@ -129,10 +129,14 @@ size_t PartitionedFilterBlockBuilder::EstimateEntriesAdded() {
   return total_added_in_built_ + filter_bits_builder_->EstimateEntriesAdded();
 }
 
-Slice PartitionedFilterBlockBuilder::Finish(
-    const BlockHandle& last_partition_block_handle, Status* status,
-    std::unique_ptr<const char[]>* filter_data) {
-  if (finishing_filters == true) {
+Status PartitionedFilterBlockBuilder::Finish(
+    const BlockHandle& last_partition_block_handle, Slice* filter,
+    std::unique_ptr<const char[]>* filter_owner) {
+  if (finishing_front_filter_) {
+    assert(!filters_.empty());
+    auto& e = filters_.front();
+
+    assert(last_partition_block_handle != BlockHandle{});
     // Record the handle of the last written filter block in the index
     std::string handle_encoding;
     last_partition_block_handle.EncodeTo(&handle_encoding);
@@ -142,54 +146,53 @@ Slice PartitionedFilterBlockBuilder::Finish(
         last_partition_block_handle.size() - last_encoded_handle_.size());
     last_encoded_handle_ = last_partition_block_handle;
     const Slice handle_delta_encoding_slice(handle_delta_encoding);
-    index_on_filter_block_builder_.Add(last_filter_entry_key, handle_encoding,
+
+    index_on_filter_block_builder_.Add(e.ikey, handle_encoding,
                                        &handle_delta_encoding_slice);
     if (!p_index_builder_->seperator_is_key_plus_seq()) {
       index_on_filter_block_builder_without_seq_.Add(
-          ExtractUserKey(last_filter_entry_key), handle_encoding,
+          ExtractUserKey(e.ikey), handle_encoding,
           &handle_delta_encoding_slice);
     }
+
+    filters_.pop_front();
   } else {
+    assert(last_partition_block_handle == BlockHandle{});
     MaybeCutAFilterBlock(nullptr);
   }
 
-  if (!partitioned_filters_construction_status_.ok()) {
-    *status = partitioned_filters_construction_status_;
-    return Slice();
-  }
-
-  // If there is no filter partition left, then return the index on filter
-  // partitions
-  if (UNLIKELY(filters.empty())) {
-    *status = Status::OK();
-    last_filter_data.reset();
-    if (finishing_filters) {
-      // Simplest to just add them all at the end
-      total_added_in_built_ = 0;
-      if (p_index_builder_->seperator_is_key_plus_seq()) {
-        return index_on_filter_block_builder_.Finish();
+  Status s = partitioned_filters_construction_status_;
+  assert(!s.IsIncomplete());
+
+  if (s.ok()) {
+    // If there is no filter partition left, then return the index on filter
+    // partitions
+    if (UNLIKELY(filters_.empty())) {
+      if (!index_on_filter_block_builder_.empty()) {
+        // Simplest to just add them all at the end
+        if (p_index_builder_->seperator_is_key_plus_seq()) {
+          *filter = index_on_filter_block_builder_.Finish();
+        } else {
+          *filter = index_on_filter_block_builder_without_seq_.Finish();
+        }
       } else {
-        return index_on_filter_block_builder_without_seq_.Finish();
+        // This is the rare case where no key was added to the filter
+        *filter = Slice{};
       }
     } else {
-      // This is the rare case where no key was added to the filter
-      return Slice();
-    }
-  } else {
-    // Return the next filter partition in line and set Incomplete() status to
-    // indicate we expect more calls to Finish
-    *status = Status::Incomplete();
-    finishing_filters = true;
-
-    last_filter_entry_key = filters.front().key;
-    Slice filter = filters.front().filter;
-    last_filter_data = std::move(filters.front().filter_data);
-    if (filter_data != nullptr) {
-      *filter_data = std::move(last_filter_data);
+      // Return the next filter partition in line and set Incomplete() status to
+      // indicate we expect more calls to Finish
+      s = Status::Incomplete();
+      finishing_front_filter_ = true;
+
+      auto& e = filters_.front();
+      if (filter_owner != nullptr) {
+        *filter_owner = std::move(e.filter_owner);
+      }
+      *filter = e.filter;
     }
-    filters.pop_front();
-    return filter;
   }
+  return s;
 }
 
 PartitionedFilterBlockReader::PartitionedFilterBlockReader(
@@ -225,7 +228,7 @@ std::unique_ptr<FilterBlockReader> PartitionedFilterBlockReader::Create(
 }
 
 bool PartitionedFilterBlockReader::KeyMayMatch(
-    const Slice& key, const bool no_io, const Slice* const const_ikey_ptr,
+    const Slice& key, const Slice* const const_ikey_ptr,
     GetContext* get_context, BlockCacheLookupContext* lookup_context,
     const ReadOptions& read_options) {
   assert(const_ikey_ptr != nullptr);
@@ -233,36 +236,35 @@ bool PartitionedFilterBlockReader::KeyMayMatch(
     return true;
   }
 
-  return MayMatch(key, no_io, const_ikey_ptr, get_context, lookup_context,
+  return MayMatch(key, const_ikey_ptr, get_context, lookup_context,
                   read_options, &FullFilterBlockReader::KeyMayMatch);
 }
 
 void PartitionedFilterBlockReader::KeysMayMatch(
-    MultiGetRange* range, const bool no_io,
-    BlockCacheLookupContext* lookup_context, const ReadOptions& read_options) {
+    MultiGetRange* range, BlockCacheLookupContext* lookup_context,
+    const ReadOptions& read_options) {
   if (!whole_key_filtering()) {
     return;  // Any/all may match
   }
 
-  MayMatch(range, nullptr, no_io, lookup_context, read_options,
+  MayMatch(range, nullptr, lookup_context, read_options,
            &FullFilterBlockReader::KeysMayMatch2);
 }
 
 bool PartitionedFilterBlockReader::PrefixMayMatch(
-    const Slice& prefix, const bool no_io, const Slice* const const_ikey_ptr,
+    const Slice& prefix, const Slice* const const_ikey_ptr,
     GetContext* get_context, BlockCacheLookupContext* lookup_context,
     const ReadOptions& read_options) {
   assert(const_ikey_ptr != nullptr);
-  return MayMatch(prefix, no_io, const_ikey_ptr, get_context, lookup_context,
+  return MayMatch(prefix, const_ikey_ptr, get_context, lookup_context,
                   read_options, &FullFilterBlockReader::PrefixMayMatch);
 }
 
 void PartitionedFilterBlockReader::PrefixesMayMatch(
     MultiGetRange* range, const SliceTransform* prefix_extractor,
-    const bool no_io, BlockCacheLookupContext* lookup_context,
-    const ReadOptions& read_options) {
+    BlockCacheLookupContext* lookup_context, const ReadOptions& read_options) {
   assert(prefix_extractor);
-  MayMatch(range, prefix_extractor, no_io, lookup_context, read_options,
+  MayMatch(range, prefix_extractor, lookup_context, read_options,
            &FullFilterBlockReader::PrefixesMayMatch);
 }
 
@@ -295,8 +297,8 @@ BlockHandle PartitionedFilterBlockReader::GetFilterPartitionHandle(
 
 Status PartitionedFilterBlockReader::GetFilterPartitionBlock(
     FilePrefetchBuffer* prefetch_buffer, const BlockHandle& fltr_blk_handle,
-    bool no_io, GetContext* get_context,
-    BlockCacheLookupContext* lookup_context, const ReadOptions& _read_options,
+    GetContext* get_context, BlockCacheLookupContext* lookup_context,
+    const ReadOptions& read_options,
     CachableEntry<ParsedFullFilterBlock>* filter_block) const {
   assert(table());
   assert(filter_block);
@@ -312,11 +314,6 @@ Status PartitionedFilterBlockReader::GetFilterPartitionBlock(
     }
   }
 
-  ReadOptions read_options = _read_options;
-  if (no_io) {
-    read_options.read_tier = kBlockCacheTier;
-  }
-
   const Status s = table()->RetrieveBlock(
       prefetch_buffer, read_options, fltr_blk_handle,
       UncompressionDict::GetEmptyDict(), filter_block, get_context,
@@ -328,12 +325,12 @@ Status PartitionedFilterBlockReader::GetFilterPartitionBlock(
 }
 
 bool PartitionedFilterBlockReader::MayMatch(
-    const Slice& slice, bool no_io, const Slice* const_ikey_ptr,
-    GetContext* get_context, BlockCacheLookupContext* lookup_context,
-    const ReadOptions& read_options, FilterFunction filter_function) const {
+    const Slice& slice, const Slice* const_ikey_ptr, GetContext* get_context,
+    BlockCacheLookupContext* lookup_context, const ReadOptions& read_options,
+    FilterFunction filter_function) const {
   CachableEntry<Block_kFilterPartitionIndex> filter_block;
-  Status s = GetOrReadFilterBlock(no_io, get_context, lookup_context,
-                                  &filter_block, read_options);
+  Status s = GetOrReadFilterBlock(get_context, lookup_context, &filter_block,
+                                  read_options);
   if (UNLIKELY(!s.ok())) {
     IGNORE_STATUS_IF_ERROR(s);
     return true;
@@ -350,7 +347,7 @@ bool PartitionedFilterBlockReader::MayMatch(
 
   CachableEntry<ParsedFullFilterBlock> filter_partition_block;
   s = GetFilterPartitionBlock(nullptr /* prefetch_buffer */, filter_handle,
-                              no_io, get_context, lookup_context, read_options,
+                              get_context, lookup_context, read_options,
                               &filter_partition_block);
   if (UNLIKELY(!s.ok())) {
     IGNORE_STATUS_IF_ERROR(s);
@@ -359,17 +356,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, read_options);
+  return (filter_partition.*filter_function)(slice, const_ikey_ptr, get_context,
+                                             lookup_context, read_options);
 }
 
 void PartitionedFilterBlockReader::MayMatch(
-    MultiGetRange* range, const SliceTransform* prefix_extractor, bool no_io,
+    MultiGetRange* range, const SliceTransform* prefix_extractor,
     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, read_options);
+  Status s = GetOrReadFilterBlock(range->begin()->get_context, lookup_context,
+                                  &filter_block, read_options);
   if (UNLIKELY(!s.ok())) {
     IGNORE_STATUS_IF_ERROR(s);
     return;  // Any/all may match
@@ -392,7 +389,7 @@ void PartitionedFilterBlockReader::MayMatch(
     if (!prev_filter_handle.IsNull() &&
         this_filter_handle != prev_filter_handle) {
       MultiGetRange subrange(*range, start_iter_same_handle, iter);
-      MayMatchPartition(&subrange, prefix_extractor, prev_filter_handle, no_io,
+      MayMatchPartition(&subrange, prefix_extractor, prev_filter_handle,
                         lookup_context, read_options, filter_function);
       range->AddSkipsFrom(subrange);
       start_iter_same_handle = iter;
@@ -408,7 +405,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,
+    MayMatchPartition(&subrange, prefix_extractor, prev_filter_handle,
                       lookup_context, read_options, filter_function);
     range->AddSkipsFrom(subrange);
   }
@@ -416,14 +413,12 @@ void PartitionedFilterBlockReader::MayMatch(
 
 void PartitionedFilterBlockReader::MayMatchPartition(
     MultiGetRange* range, const SliceTransform* prefix_extractor,
-    BlockHandle filter_handle, bool no_io,
-    BlockCacheLookupContext* lookup_context, const ReadOptions& read_options,
-    FilterManyFunction filter_function) const {
+    BlockHandle filter_handle, 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, read_options,
-      &filter_partition_block);
+      nullptr /* prefetch_buffer */, filter_handle, range->begin()->get_context,
+      lookup_context, read_options, &filter_partition_block);
   if (UNLIKELY(!s.ok())) {
     IGNORE_STATUS_IF_ERROR(s);
     return;  // Any/all may match
@@ -431,8 +426,8 @@ void PartitionedFilterBlockReader::MayMatchPartition(
 
   FullFilterBlockReader filter_partition(table(),
                                          std::move(filter_partition_block));
-  (filter_partition.*filter_function)(range, prefix_extractor, no_io,
-                                      lookup_context, read_options);
+  (filter_partition.*filter_function)(range, prefix_extractor, lookup_context,
+                                      read_options);
 }
 
 size_t PartitionedFilterBlockReader::ApproximateMemoryUsage() const {
@@ -458,8 +453,8 @@ Status PartitionedFilterBlockReader::CacheDependencies(
 
   CachableEntry<Block_kFilterPartitionIndex> filter_block;
 
-  Status s = GetOrReadFilterBlock(false /* no_io */, nullptr /* get_context */,
-                                  &lookup_context, &filter_block, ro);
+  Status s = GetOrReadFilterBlock(nullptr /* get_context */, &lookup_context,
+                                  &filter_block, ro);
   if (!s.ok()) {
     ROCKS_LOG_ERROR(rep->ioptions.logger,
                     "Error retrieving top-level filter block while trying to "
@@ -538,6 +533,52 @@ Status PartitionedFilterBlockReader::CacheDependencies(
   return biter.status();
 }
 
+void PartitionedFilterBlockReader::EraseFromCacheBeforeDestruction(
+    uint32_t uncache_aggressiveness) {
+  // NOTE: essentially a copy of
+  // PartitionIndexReader::EraseFromCacheBeforeDestruction
+  if (uncache_aggressiveness > 0) {
+    CachableEntry<Block_kFilterPartitionIndex> top_level_block;
+
+    ReadOptions ro;
+    ro.read_tier = ReadTier::kBlockCacheTier;
+    GetOrReadFilterBlock(/*get_context=*/nullptr,
+                         /*lookup_context=*/nullptr, &top_level_block, ro)
+        .PermitUncheckedError();
+
+    if (!filter_map_.empty()) {
+      // All partitions present if any
+      for (auto& e : filter_map_) {
+        e.second.ResetEraseIfLastRef();
+      }
+    } else if (!top_level_block.IsEmpty()) {
+      IndexBlockIter biter;
+      const InternalKeyComparator* const comparator = internal_comparator();
+      Statistics* kNullStats = nullptr;
+      top_level_block.GetValue()->NewIndexIterator(
+          comparator->user_comparator(),
+          table()->get_rep()->get_global_seqno(
+              BlockType::kFilterPartitionIndex),
+          &biter, kNullStats, true /* total_order_seek */,
+          false /* have_first_key */, index_key_includes_seq(),
+          index_value_is_full(), false /* block_contents_pinned */,
+          user_defined_timestamps_persisted());
+
+      UncacheAggressivenessAdvisor advisor(uncache_aggressiveness);
+      for (biter.SeekToFirst(); biter.Valid() && advisor.ShouldContinue();
+           biter.Next()) {
+        bool erased = table()->EraseFromCache(biter.value().handle);
+        advisor.Report(erased);
+      }
+      biter.status().PermitUncheckedError();
+    }
+    top_level_block.ResetEraseIfLastRef();
+  }
+  // Might be needed to un-cache a pinned top-level block
+  FilterBlockReaderCommon<Block_kFilterPartitionIndex>::
+      EraseFromCacheBeforeDestruction(uncache_aggressiveness);
+}
+
 const InternalKeyComparator* PartitionedFilterBlockReader::internal_comparator()
     const {
   assert(table());

package/vendor/librocksdb/vendor/rocksdb/table/block_based/partitioned_filter_block.h

@@ -37,17 +37,17 @@ class PartitionedFilterBlockBuilder : public FullFilterBlockBuilder {
   virtual ~PartitionedFilterBlockBuilder();
 
   void AddKey(const Slice& key) override;
-  void Add(const Slice& key) override;
+  void Add(const Slice& key_without_ts) override;
   size_t EstimateEntriesAdded() override;
 
-  Slice Finish(const BlockHandle& last_partition_block_handle, Status* status,
-               std::unique_ptr<const char[]>* filter_data = nullptr) override;
+  Status Finish(const BlockHandle& last_partition_block_handle, Slice* filter,
+                std::unique_ptr<const char[]>* filter_owner = nullptr) override;
 
   void ResetFilterBitsBuilder() override {
-    // Previously constructed partitioned filters by
-    // this to-be-reset FiterBitsBuilder can also be
-    // cleared
-    filters.clear();
+    filters_.clear();
+    total_added_in_built_ = 0;
+    index_on_filter_block_builder_.Reset();
+    index_on_filter_block_builder_without_seq_.Reset();
     FullFilterBlockBuilder::ResetFilterBitsBuilder();
   }
 
@@ -59,44 +59,51 @@ class PartitionedFilterBlockBuilder : public FullFilterBlockBuilder {
     return Status::OK();
   }
 
- private:
-  // Filter data
-  BlockBuilder index_on_filter_block_builder_;  // top-level index builder
-  BlockBuilder
-      index_on_filter_block_builder_without_seq_;  // same for user keys
-  struct FilterEntry {
-    std::string key;
-    std::unique_ptr<const char[]> filter_data;
-    Slice filter;
-  };
-  std::deque<FilterEntry> filters;  // list of partitioned filters and keys used
-                                    // in building the index
-
-  // Set to the first non-okay status if any of the filter
-  // partitions experiences construction error.
-  // If partitioned_filters_construction_status_ is non-okay,
-  // then the whole partitioned filters should not be used.
-  Status partitioned_filters_construction_status_;
-  std::string last_filter_entry_key;
-  std::unique_ptr<const char[]> last_filter_data;
-  std::unique_ptr<IndexBuilder> value;
-  bool finishing_filters =
-      false;  // true if Finish is called once but not complete yet.
+ private:  // fns
   // The policy of when cut a filter block and Finish it
   void MaybeCutAFilterBlock(const Slice* next_key);
+
+ private:  // data
   // Currently we keep the same number of partitions for filters and indexes.
   // This would allow for some potentioal optimizations in future. If such
   // optimizations did not realize we can use different number of partitions and
   // eliminate p_index_builder_
   PartitionedIndexBuilder* const p_index_builder_;
+
+  // Filter data
+  struct FilterEntry {
+    std::string ikey;  // internal key or separator *after* this filter
+    std::unique_ptr<const char[]> filter_owner;
+    Slice filter;
+  };
+  std::deque<FilterEntry> filters_;  // list of partitioned filters and keys
+                                     // used in building the index
   // The desired number of keys per partition
   uint32_t keys_per_partition_;
   // The number of keys added to the last partition so far
-  uint32_t keys_added_to_partition_;
+  uint32_t keys_added_to_partition_ = 0;
   // According to the bits builders, how many keys/prefixes added
   // in all the filters we have fully built
-  uint64_t total_added_in_built_;
+  uint64_t total_added_in_built_ = 0;
+
+  // Set to the first non-okay status if any of the filter
+  // partitions experiences construction error.
+  // If partitioned_filters_construction_status_ is non-okay,
+  // then the whole partitioned filters should not be used.
+  Status partitioned_filters_construction_status_;
+
+  // ===== State for Finish() =====
+
+  // top-level index builder on internal keys
+  BlockBuilder index_on_filter_block_builder_;
+  // same for user keys
+  BlockBuilder index_on_filter_block_builder_without_seq_;
+  // For delta-encoding handles
   BlockHandle last_encoded_handle_;
+  // True if we are between two calls to Finish(), because we have returned
+  // the filter at the front of filters_ but haven't yet added it to the
+  // partition index.
+  bool finishing_front_filter_ = false;
 };
 
 class PartitionedFilterBlockReader
@@ -111,22 +118,20 @@ class PartitionedFilterBlockReader
       FilePrefetchBuffer* prefetch_buffer, bool use_cache, bool prefetch,
       bool pin, BlockCacheLookupContext* lookup_context);
 
-  bool KeyMayMatch(const Slice& key, const bool no_io,
-                   const Slice* const const_ikey_ptr, GetContext* get_context,
+  bool KeyMayMatch(const Slice& key, const Slice* const const_ikey_ptr,
+                   GetContext* get_context,
                    BlockCacheLookupContext* lookup_context,
                    const ReadOptions& read_options) override;
-  void KeysMayMatch(MultiGetRange* range, const bool no_io,
+  void KeysMayMatch(MultiGetRange* range,
                     BlockCacheLookupContext* lookup_context,
                     const ReadOptions& read_options) override;
 
-  bool PrefixMayMatch(const Slice& prefix, const bool no_io,
-                      const Slice* const const_ikey_ptr,
+  bool PrefixMayMatch(const Slice& prefix, const Slice* const const_ikey_ptr,
                       GetContext* get_context,
                       BlockCacheLookupContext* lookup_context,
                       const ReadOptions& read_options) override;
   void PrefixesMayMatch(MultiGetRange* range,
                         const SliceTransform* prefix_extractor,
-                        const bool no_io,
                         BlockCacheLookupContext* lookup_context,
                         const ReadOptions& read_options) override;
 
@@ -138,35 +143,36 @@ class PartitionedFilterBlockReader
       const Slice& entry) const;
   Status GetFilterPartitionBlock(
       FilePrefetchBuffer* prefetch_buffer, const BlockHandle& handle,
-      bool no_io, GetContext* get_context,
-      BlockCacheLookupContext* lookup_context, const ReadOptions& read_options,
+      GetContext* get_context, 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,
+      const Slice& slice, const Slice* const const_ikey_ptr,
       GetContext* get_context, BlockCacheLookupContext* lookup_context,
       const ReadOptions& read_options);
-  bool MayMatch(const Slice& slice, bool no_io, const Slice* const_ikey_ptr,
+  bool MayMatch(const Slice& slice, const Slice* const_ikey_ptr,
                 GetContext* get_context,
                 BlockCacheLookupContext* lookup_context,
                 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,
-      const ReadOptions& read_options);
+      BlockCacheLookupContext* lookup_context, const ReadOptions& read_options);
   void MayMatch(MultiGetRange* range, const SliceTransform* prefix_extractor,
-                bool no_io, BlockCacheLookupContext* lookup_context,
+                BlockCacheLookupContext* lookup_context,
                 const ReadOptions& read_options,
                 FilterManyFunction filter_function) const;
   void MayMatchPartition(MultiGetRange* range,
                          const SliceTransform* prefix_extractor,
-                         BlockHandle filter_handle, bool no_io,
+                         BlockHandle filter_handle,
                          BlockCacheLookupContext* lookup_context,
                          const ReadOptions& read_options,
                          FilterManyFunction filter_function) const;
   Status CacheDependencies(const ReadOptions& ro, bool pin,
                            FilePrefetchBuffer* tail_prefetch_buffer) override;
+  void EraseFromCacheBeforeDestruction(
+      uint32_t /*uncache_aggressiveness*/) override;
 
   const InternalKeyComparator* internal_comparator() const;
   bool index_key_includes_seq() const;