rocksdb-native 2.2.0 → 2.3.0

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

@@ -156,4 +156,35 @@ template <typename TUse, typename TBlocklike>
 using WithBlocklikeCheck = std::enable_if_t<
     TBlocklike::kCacheEntryRole == CacheEntryRole::kMisc || true, TUse>;
 
+// Helper for the uncache_aggressiveness option
+class UncacheAggressivenessAdvisor {
+ public:
+  UncacheAggressivenessAdvisor(uint32_t uncache_aggressiveness) {
+    assert(uncache_aggressiveness > 0);
+    allowance_ = std::min(uncache_aggressiveness, uint32_t{3});
+    threshold_ = std::pow(0.99, uncache_aggressiveness - 1);
+  }
+  void Report(bool erased) { ++(erased ? useful_ : not_useful_); }
+  bool ShouldContinue() {
+    if (not_useful_ < allowance_) {
+      return true;
+    } else {
+      // See UncacheAggressivenessAdvisor unit test
+      return (useful_ + 1.0) / (useful_ + not_useful_ - allowance_ + 1.5) >=
+             threshold_;
+    }
+  }
+
+ private:
+  // Baseline minimum number of "not useful" to consider stopping, to allow
+  // sufficient evidence for checking the threshold. Actual minimum will be
+  // higher as threshold gets well below 1.0.
+  int allowance_;
+  // After allowance, stop if useful ratio is below this threshold
+  double threshold_;
+  // Counts
+  int useful_ = 0;
+  int not_useful_ = 0;
+};
+
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -18,6 +18,12 @@ void BlockPrefetcher::PrefetchIfNeeded(
     const bool no_sequential_checking, const ReadOptions& read_options,
     const std::function<void(bool, uint64_t&, uint64_t&)>& readaheadsize_cb,
     bool is_async_io_prefetch) {
+  if (read_options.read_tier == ReadTier::kBlockCacheTier) {
+    // Disable prefetching when IO disallowed. (Note that we haven't allocated
+    // any buffers yet despite the various tracked settings.)
+    return;
+  }
+
   ReadaheadParams readahead_params;
   readahead_params.initial_readahead_size = readahead_size;
   readahead_params.max_readahead_size = readahead_size;

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

@@ -78,7 +78,7 @@ class CachableEntry {
       return *this;
     }
 
-    ReleaseResource();
+    ReleaseResource(/*erase_if_last_ref=*/false);
 
     value_ = rhs.value_;
     cache_ = rhs.cache_;
@@ -95,7 +95,7 @@ class CachableEntry {
     return *this;
   }
 
-  ~CachableEntry() { ReleaseResource(); }
+  ~CachableEntry() { ReleaseResource(/*erase_if_last_ref=*/false); }
 
   bool IsEmpty() const {
     return value_ == nullptr && cache_ == nullptr && cache_handle_ == nullptr &&
@@ -114,7 +114,12 @@ class CachableEntry {
   bool GetOwnValue() const { return own_value_; }
 
   void Reset() {
-    ReleaseResource();
+    ReleaseResource(/*erase_if_last_ref=*/false);
+    ResetFields();
+  }
+
+  void ResetEraseIfLastRef() {
+    ReleaseResource(/*erase_if_last_ref=*/true);
     ResetFields();
   }
 
@@ -200,10 +205,10 @@ class CachableEntry {
   }
 
  private:
-  void ReleaseResource() noexcept {
+  void ReleaseResource(bool erase_if_last_ref) noexcept {
     if (LIKELY(cache_handle_ != nullptr)) {
       assert(cache_ != nullptr);
-      cache_->Release(cache_handle_);
+      cache_->Release(cache_handle_, erase_if_last_ref);
     } else if (own_value_) {
       delete value_;
     }

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

@@ -57,22 +57,22 @@ class FilterBlockBuilder {
   virtual bool IsEmpty() const = 0;      // Empty == none added
   // For reporting stats on how many entries the builder considered unique
   virtual size_t EstimateEntriesAdded() = 0;
-  Slice Finish() {  // Generate Filter
-    const BlockHandle empty_handle;
-    Status dont_care_status;
-    auto ret = Finish(empty_handle, &dont_care_status);
-    assert(dont_care_status.ok());
-    return ret;
-  }
-  // If filter_data is not nullptr, Finish() may transfer ownership of
+
+  // Generate a filter block. Returns OK if finished, or Incomplete if more
+  // filters are needed (partitioned filter). In the latter case, subsequent
+  // calls require the BlockHandle of the most recently generated and written
+  // filter, in last_partition_block_handle.
+  //
+  // If filter_owner is not nullptr, Finish() may transfer ownership of
   // underlying filter data to the caller,  so that it can be freed as soon as
   // possible. BlockBasedFilterBlock will ignore this parameter.
   //
-  virtual Slice Finish(
-      const BlockHandle& tmp /* only used in PartitionedFilterBlock as
-                                last_partition_block_handle */
-      ,
-      Status* status, std::unique_ptr<const char[]>* filter_data = nullptr) = 0;
+  // For either OK or Incomplete, *filter is set to point to the next filter
+  // bytes, which survive until either this is destroyed, *filter_owner is
+  // destroyed, or next call to Finish.
+  virtual Status Finish(
+      const BlockHandle& last_partition_block_handle, Slice* filter,
+      std::unique_ptr<const char[]>* filter_owner = nullptr) = 0;
 
   // This is called when finishes using the FilterBitsBuilder
   // in order to release memory usage and cache charge
@@ -85,6 +85,16 @@ class FilterBlockBuilder {
   virtual Status MaybePostVerifyFilter(const Slice& /* filter_content */) {
     return Status::OK();
   }
+
+#ifndef NDEBUG
+  Slice TEST_Finish() {  // Generate Filter
+    const BlockHandle empty_handle;
+    Slice filter;
+    Status status = Finish(empty_handle, &filter);
+    assert(status.ok());
+    return filter;
+  }
+#endif  // NDEBUG
 };
 
 // A FilterBlockReader is used to parse filter from SST table.
@@ -100,39 +110,34 @@ class FilterBlockReader {
   FilterBlockReader& operator=(const FilterBlockReader&) = delete;
 
   /**
-   * If no_io is set, then it returns true if it cannot answer the query without
-   * reading data from disk. This is used in PartitionedFilterBlockReader to
-   * avoid reading partitions that are not in block cache already
-   *
    * Normally filters are built on only the user keys and the InternalKey is not
    * needed for a query. The index in PartitionedFilterBlockReader however is
    * built upon InternalKey and must be provided via const_ikey_ptr when running
    * queries.
    */
-  virtual bool KeyMayMatch(const Slice& key, const bool no_io,
-                           const Slice* const const_ikey_ptr,
+  virtual bool KeyMayMatch(const Slice& key, const Slice* const const_ikey_ptr,
                            GetContext* get_context,
                            BlockCacheLookupContext* lookup_context,
                            const ReadOptions& read_options) = 0;
 
-  virtual void KeysMayMatch(MultiGetRange* range, const bool no_io,
+  virtual void KeysMayMatch(MultiGetRange* range,
                             BlockCacheLookupContext* lookup_context,
                             const ReadOptions& read_options) {
     for (auto iter = range->begin(); iter != range->end(); ++iter) {
       const Slice ukey_without_ts = iter->ukey_without_ts;
       const Slice ikey = iter->ikey;
       GetContext* const get_context = iter->get_context;
-      if (!KeyMayMatch(ukey_without_ts, no_io, &ikey, get_context,
-                       lookup_context, read_options)) {
+      if (!KeyMayMatch(ukey_without_ts, &ikey, get_context, lookup_context,
+                       read_options)) {
         range->SkipKey(iter);
       }
     }
   }
 
   /**
-   * no_io and const_ikey_ptr here means the same as in KeyMayMatch
+   * Similar to KeyMayMatch
    */
-  virtual bool PrefixMayMatch(const Slice& prefix, const bool no_io,
+  virtual bool PrefixMayMatch(const Slice& prefix,
                               const Slice* const const_ikey_ptr,
                               GetContext* get_context,
                               BlockCacheLookupContext* lookup_context,
@@ -140,7 +145,6 @@ class FilterBlockReader {
 
   virtual void PrefixesMayMatch(MultiGetRange* range,
                                 const SliceTransform* prefix_extractor,
-                                const bool no_io,
                                 BlockCacheLookupContext* lookup_context,
                                 const ReadOptions& read_options) {
     for (auto iter = range->begin(); iter != range->end(); ++iter) {
@@ -148,8 +152,8 @@ class FilterBlockReader {
       const Slice ikey = iter->ikey;
       GetContext* const get_context = iter->get_context;
       if (prefix_extractor->InDomain(ukey_without_ts) &&
-          !PrefixMayMatch(prefix_extractor->Transform(ukey_without_ts), no_io,
-                          &ikey, get_context, lookup_context, read_options)) {
+          !PrefixMayMatch(prefix_extractor->Transform(ukey_without_ts), &ikey,
+                          get_context, lookup_context, read_options)) {
         range->SkipKey(iter);
       }
     }
@@ -169,13 +173,15 @@ class FilterBlockReader {
     return Status::OK();
   }
 
+  virtual void EraseFromCacheBeforeDestruction(
+      uint32_t /*uncache_aggressiveness*/) {}
+
   virtual bool RangeMayExist(const Slice* /*iterate_upper_bound*/,
                              const Slice& user_key_without_ts,
                              const SliceTransform* prefix_extractor,
                              const Comparator* /*comparator*/,
                              const Slice* const const_ikey_ptr,
                              bool* filter_checked, bool need_upper_bound_check,
-                             bool no_io,
                              BlockCacheLookupContext* lookup_context,
                              const ReadOptions& read_options) = 0;
 };

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

@@ -67,8 +67,7 @@ bool FilterBlockReaderCommon<TBlocklike>::cache_filter_blocks() const {
 
 template <typename TBlocklike>
 Status FilterBlockReaderCommon<TBlocklike>::GetOrReadFilterBlock(
-    bool no_io, GetContext* get_context,
-    BlockCacheLookupContext* lookup_context,
+    GetContext* get_context, BlockCacheLookupContext* lookup_context,
     CachableEntry<TBlocklike>* filter_block,
     const ReadOptions& read_options) const {
   assert(filter_block);
@@ -78,12 +77,7 @@ Status FilterBlockReaderCommon<TBlocklike>::GetOrReadFilterBlock(
     return Status::OK();
   }
 
-  ReadOptions ro = read_options;
-  if (no_io) {
-    ro.read_tier = kBlockCacheTier;
-  }
-
-  return ReadFilterBlock(table_, nullptr /* prefetch_buffer */, ro,
+  return ReadFilterBlock(table_, nullptr /* prefetch_buffer */, read_options,
                          cache_filter_blocks(), get_context, lookup_context,
                          filter_block);
 }
@@ -102,8 +96,8 @@ bool FilterBlockReaderCommon<TBlocklike>::RangeMayExist(
     const Slice* iterate_upper_bound, const Slice& user_key_without_ts,
     const SliceTransform* prefix_extractor, const Comparator* comparator,
     const Slice* const const_ikey_ptr, bool* filter_checked,
-    bool need_upper_bound_check, bool no_io,
-    BlockCacheLookupContext* lookup_context, const ReadOptions& read_options) {
+    bool need_upper_bound_check, BlockCacheLookupContext* lookup_context,
+    const ReadOptions& read_options) {
   if (!prefix_extractor || !prefix_extractor->InDomain(user_key_without_ts)) {
     *filter_checked = false;
     return true;
@@ -115,7 +109,7 @@ bool FilterBlockReaderCommon<TBlocklike>::RangeMayExist(
     return true;
   } else {
     *filter_checked = true;
-    return PrefixMayMatch(prefix, no_io, const_ikey_ptr,
+    return PrefixMayMatch(prefix, const_ikey_ptr,
                           /* get_context */ nullptr, lookup_context,
                           read_options);
   }
@@ -155,6 +149,18 @@ bool FilterBlockReaderCommon<TBlocklike>::IsFilterCompatible(
   }
 }
 
+template <typename TBlocklike>
+void FilterBlockReaderCommon<TBlocklike>::EraseFromCacheBeforeDestruction(
+    uint32_t uncache_aggressiveness) {
+  if (uncache_aggressiveness > 0) {
+    if (filter_block_.IsCached()) {
+      filter_block_.ResetEraseIfLastRef();
+    } else {
+      table()->EraseFromCache(table()->get_rep()->filter_handle);
+    }
+  }
+}
+
 // Explicitly instantiate templates for both "blocklike" types we use.
 // This makes it possible to keep the template definitions in the .cc file.
 template class FilterBlockReaderCommon<Block_kFilterPartitionIndex>;

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

@@ -38,10 +38,13 @@ class FilterBlockReaderCommon : public FilterBlockReader {
                      const SliceTransform* prefix_extractor,
                      const Comparator* comparator,
                      const Slice* const const_ikey_ptr, bool* filter_checked,
-                     bool need_upper_bound_check, bool no_io,
+                     bool need_upper_bound_check,
                      BlockCacheLookupContext* lookup_context,
                      const ReadOptions& read_options) override;
 
+  void EraseFromCacheBeforeDestruction(
+      uint32_t /*uncache_aggressiveness*/) override;
+
  protected:
   static Status ReadFilterBlock(const BlockBasedTable* table,
                                 FilePrefetchBuffer* prefetch_buffer,
@@ -55,7 +58,7 @@ class FilterBlockReaderCommon : public FilterBlockReader {
   bool whole_key_filtering() const;
   bool cache_filter_blocks() const;
 
-  Status GetOrReadFilterBlock(bool no_io, GetContext* get_context,
+  Status GetOrReadFilterBlock(GetContext* get_context,
                               BlockCacheLookupContext* lookup_context,
                               CachableEntry<TBlocklike>* filter_block,
                               const ReadOptions& read_options) const;

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

@@ -425,6 +425,9 @@ class FastLocalBloomBitsBuilder : public XXPH3FilterBitsBuilder {
   }
 
   double EstimatedFpRate(size_t keys, size_t len_with_metadata) override {
+    if (len_with_metadata <= kMetadataLen) {
+      return keys > 0 ? 1.0 : 0.0;
+    }
     int num_probes = GetNumProbes(keys, len_with_metadata);
     return FastLocalBloomImpl::EstimatedFpRate(
         keys, len_with_metadata - kMetadataLen, num_probes, /*hash bits*/ 64);
@@ -891,6 +894,9 @@ class Standard128RibbonBitsBuilder : public XXPH3FilterBitsBuilder {
 
   double EstimatedFpRate(size_t num_entries,
                          size_t len_with_metadata) override {
+    if (len_with_metadata <= kMetadataLen) {
+      return num_entries > 0 ? 1.0 : 0.0;
+    }
     if (num_entries > kMaxRibbonEntries) {
       // More entries than supported by this Ribbon
       return bloom_fallback_.EstimatedFpRate(num_entries, len_with_metadata);
@@ -1030,9 +1036,12 @@ class LegacyBloomBitsBuilder : public BuiltinFilterBitsBuilder {
     return CalculateSpace(num_entries, &dont_care1, &dont_care2);
   }
 
-  double EstimatedFpRate(size_t keys, size_t bytes) override {
-    return LegacyBloomImpl::EstimatedFpRate(keys, bytes - kMetadataLen,
-                                            num_probes_);
+  double EstimatedFpRate(size_t keys, size_t len_with_metadata) override {
+    if (len_with_metadata <= kMetadataLen) {
+      return keys > 0 ? 1.0 : 0.0;
+    }
+    return LegacyBloomImpl::EstimatedFpRate(
+        keys, len_with_metadata - kMetadataLen, num_probes_);
   }
 
   size_t ApproximateNumEntries(size_t bytes) override;

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

@@ -20,7 +20,8 @@ namespace ROCKSDB_NAMESPACE {
 FullFilterBlockBuilder::FullFilterBlockBuilder(
     const SliceTransform* _prefix_extractor, bool whole_key_filtering,
     FilterBitsBuilder* filter_bits_builder)
-    : prefix_extractor_(_prefix_extractor),
+    : need_last_prefix_(whole_key_filtering && _prefix_extractor != nullptr),
+      prefix_extractor_(_prefix_extractor),
       whole_key_filtering_(whole_key_filtering),
       last_whole_key_recorded_(false),
       last_prefix_recorded_(false),
@@ -38,7 +39,7 @@ void FullFilterBlockBuilder::Add(const Slice& key_without_ts) {
   const bool add_prefix =
       prefix_extractor_ && prefix_extractor_->InDomain(key_without_ts);
 
-  if (!last_prefix_recorded_ && last_key_in_domain_) {
+  if (need_last_prefix_ && !last_prefix_recorded_ && last_key_in_domain_) {
     // We can reach here when a new filter partition starts in partitioned
     // filter. The last prefix in the previous partition should be added if
     // necessary regardless of key_without_ts, to support prefix SeekForPrev.
@@ -82,7 +83,15 @@ inline void FullFilterBlockBuilder::AddKey(const Slice& key) {
 void FullFilterBlockBuilder::AddPrefix(const Slice& key) {
   assert(prefix_extractor_ && prefix_extractor_->InDomain(key));
   Slice prefix = prefix_extractor_->Transform(key);
-  if (whole_key_filtering_) {
+  if (need_last_prefix_) {
+    // WART/FIXME: Because last_prefix_str_ is needed above to make
+    // SeekForPrev work with partitioned + prefix filters, we are currently
+    // use this inefficient code in that case (in addition to prefix+whole
+    // key). Hopefully this can be optimized with some refactoring up the call
+    // chain to BlockBasedTableBuilder. Even in PartitionedFilterBlockBuilder,
+    // we don't currently have access to the previous key/prefix by the time we
+    // know we are starting a new partition.
+
     // if both whole_key and prefix are added to bloom then we will have whole
     // key and prefix addition being interleaved and thus cannot rely on the
     // bits builder to properly detect the duplicates by comparing with the last
@@ -103,19 +112,19 @@ void FullFilterBlockBuilder::Reset() {
   last_prefix_recorded_ = false;
 }
 
-Slice FullFilterBlockBuilder::Finish(
-    const BlockHandle& /*tmp*/, Status* status,
-    std::unique_ptr<const char[]>* filter_data) {
+Status FullFilterBlockBuilder::Finish(
+    const BlockHandle& /*last_partition_block_handle*/, Slice* filter,
+    std::unique_ptr<const char[]>* filter_owner) {
   Reset();
-  // In this impl we ignore BlockHandle
-  *status = Status::OK();
+  Status s = Status::OK();
   if (any_added_) {
     any_added_ = false;
-    Slice filter_content = filter_bits_builder_->Finish(
-        filter_data ? filter_data : &filter_data_, status);
-    return filter_content;
+    *filter = filter_bits_builder_->Finish(
+        filter_owner ? filter_owner : &filter_data_, &s);
+  } else {
+    *filter = Slice{};
   }
-  return Slice();
+  return s;
 }
 
 FullFilterBlockReader::FullFilterBlockReader(
@@ -123,7 +132,7 @@ FullFilterBlockReader::FullFilterBlockReader(
     CachableEntry<ParsedFullFilterBlock>&& filter_block)
     : FilterBlockReaderCommon(t, std::move(filter_block)) {}
 
-bool FullFilterBlockReader::KeyMayMatch(const Slice& key, const bool no_io,
+bool FullFilterBlockReader::KeyMayMatch(const Slice& key,
                                         const Slice* const /*const_ikey_ptr*/,
                                         GetContext* get_context,
                                         BlockCacheLookupContext* lookup_context,
@@ -131,7 +140,7 @@ bool FullFilterBlockReader::KeyMayMatch(const Slice& key, const bool no_io,
   if (!whole_key_filtering()) {
     return true;
   }
-  return MayMatch(key, no_io, get_context, lookup_context, read_options);
+  return MayMatch(key, get_context, lookup_context, read_options);
 }
 
 std::unique_ptr<FilterBlockReader> FullFilterBlockReader::Create(
@@ -162,19 +171,19 @@ std::unique_ptr<FilterBlockReader> FullFilterBlockReader::Create(
 }
 
 bool FullFilterBlockReader::PrefixMayMatch(
-    const Slice& prefix, const bool no_io,
-    const Slice* const /*const_ikey_ptr*/, GetContext* get_context,
-    BlockCacheLookupContext* lookup_context, const ReadOptions& read_options) {
-  return MayMatch(prefix, no_io, get_context, lookup_context, read_options);
+    const Slice& prefix, const Slice* const /*const_ikey_ptr*/,
+    GetContext* get_context, BlockCacheLookupContext* lookup_context,
+    const ReadOptions& read_options) {
+  return MayMatch(prefix, get_context, lookup_context, read_options);
 }
 
-bool FullFilterBlockReader::MayMatch(const Slice& entry, bool no_io,
+bool FullFilterBlockReader::MayMatch(const Slice& entry,
                                      GetContext* get_context,
                                      BlockCacheLookupContext* lookup_context,
                                      const ReadOptions& read_options) const {
   CachableEntry<ParsedFullFilterBlock> filter_block;
 
-  const Status s = GetOrReadFilterBlock(no_io, get_context, lookup_context,
+  const Status s = GetOrReadFilterBlock(get_context, lookup_context,
                                         &filter_block, read_options);
   if (!s.ok()) {
     IGNORE_STATUS_IF_ERROR(s);
@@ -199,32 +208,30 @@ bool FullFilterBlockReader::MayMatch(const Slice& entry, bool no_io,
 }
 
 void FullFilterBlockReader::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()) {
     // Simply return. Don't skip any key - consider all keys as likely to be
     // present
     return;
   }
-  MayMatch(range, no_io, nullptr, lookup_context, read_options);
+  MayMatch(range, nullptr, lookup_context, read_options);
 }
 
 void FullFilterBlockReader::PrefixesMayMatch(
     MultiGetRange* range, const SliceTransform* prefix_extractor,
-    const bool no_io, BlockCacheLookupContext* lookup_context,
-    const ReadOptions& read_options) {
-  MayMatch(range, no_io, prefix_extractor, lookup_context, read_options);
+    BlockCacheLookupContext* lookup_context, const ReadOptions& read_options) {
+  MayMatch(range, prefix_extractor, lookup_context, read_options);
 }
 
-void FullFilterBlockReader::MayMatch(MultiGetRange* range, bool no_io,
+void FullFilterBlockReader::MayMatch(MultiGetRange* range,
                                      const SliceTransform* prefix_extractor,
                                      BlockCacheLookupContext* lookup_context,
                                      const ReadOptions& read_options) const {
   CachableEntry<ParsedFullFilterBlock> filter_block;
 
-  const Status s =
-      GetOrReadFilterBlock(no_io, range->begin()->get_context, lookup_context,
-                           &filter_block, read_options);
+  const Status s = GetOrReadFilterBlock(
+      range->begin()->get_context, lookup_context, &filter_block, read_options);
   if (!s.ok()) {
     IGNORE_STATUS_IF_ERROR(s);
     return;

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

@@ -52,8 +52,8 @@ class FullFilterBlockBuilder : public FilterBlockBuilder {
   void Add(const Slice& key_without_ts) override;
   bool IsEmpty() const override { return !any_added_; }
   size_t EstimateEntriesAdded() override;
-  Slice Finish(const BlockHandle& tmp, 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;
   using FilterBlockBuilder::Finish;
 
   void ResetFilterBitsBuilder() override { filter_bits_builder_.reset(); }
@@ -69,6 +69,7 @@ class FullFilterBlockBuilder : public FilterBlockBuilder {
   void AddPrefix(const Slice& key);
   const SliceTransform* prefix_extractor() { return prefix_extractor_; }
   const std::string& last_prefix_str() const { return last_prefix_str_; }
+  bool need_last_prefix_;
 
  private:
   // important: all of these might point to invalid addresses
@@ -102,41 +103,38 @@ class FullFilterBlockReader
       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;
 
-  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 KeysMayMatch(MultiGetRange* range, const bool no_io,
+  void KeysMayMatch(MultiGetRange* range,
                     BlockCacheLookupContext* lookup_context,
                     const ReadOptions& read_options) override;
   // Used in partitioned filter code
   void KeysMayMatch2(MultiGetRange* range,
                      const SliceTransform* /*prefix_extractor*/,
-                     const bool no_io, BlockCacheLookupContext* lookup_context,
+                     BlockCacheLookupContext* lookup_context,
                      const ReadOptions& read_options) {
-    KeysMayMatch(range, no_io, lookup_context, read_options);
+    KeysMayMatch(range, lookup_context, read_options);
   }
 
   void PrefixesMayMatch(MultiGetRange* range,
                         const SliceTransform* prefix_extractor,
-                        const bool no_io,
                         BlockCacheLookupContext* lookup_context,
                         const ReadOptions& read_options) override;
   size_t ApproximateMemoryUsage() const override;
 
  private:
-  bool MayMatch(const Slice& entry, bool no_io, GetContext* get_context,
+  bool MayMatch(const Slice& entry, GetContext* get_context,
                 BlockCacheLookupContext* lookup_context,
                 const ReadOptions& read_options) const;
-  void MayMatch(MultiGetRange* range, bool no_io,
-                const SliceTransform* prefix_extractor,
+  void MayMatch(MultiGetRange* range, const SliceTransform* prefix_extractor,
                 BlockCacheLookupContext* lookup_context,
                 const ReadOptions& read_options) const;
 };

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

@@ -114,9 +114,8 @@ InternalIteratorBase<IndexValue>* HashIndexReader::NewIterator(
     IndexBlockIter* iter, GetContext* get_context,
     BlockCacheLookupContext* lookup_context) {
   const BlockBasedTable::Rep* rep = table()->get_rep();
-  const bool no_io = (read_options.read_tier == kBlockCacheTier);
   CachableEntry<Block> index_block;
-  const Status s = GetOrReadIndexBlock(no_io, get_context, lookup_context,
+  const Status s = GetOrReadIndexBlock(get_context, lookup_context,
                                        &index_block, read_options);
   if (!s.ok()) {
     if (iter != nullptr) {