@nxtedition/rocksdb 10.1.5 → 10.1.6

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

@@ -62,7 +62,6 @@ TBlockIter* BlockBasedTable::NewDataBlockIterator(
   CachableEntry<Block> block;
   if (rep_->uncompression_dict_reader && block_type == BlockType::kData) {
     CachableEntry<UncompressionDict> uncompression_dict;
-    const bool no_io = (ro.read_tier == kBlockCacheTier);
     // For async scans, don't use the prefetch buffer since an async prefetch
     // might already be under way and this would invalidate it. Also, the
     // uncompression dict is typically at the end of the file and would
@@ -72,8 +71,7 @@ TBlockIter* BlockBasedTable::NewDataBlockIterator(
     // pattern.
     s = rep_->uncompression_dict_reader->GetOrReadUncompressionDictionary(
         ((ro.async_io || ro.auto_readahead_size) ? nullptr : prefetch_buffer),
-        ro, no_io, ro.verify_checksums, get_context, lookup_context,
-        &uncompression_dict);
+        ro, get_context, lookup_context, &uncompression_dict);
     if (!s.ok()) {
       iter->Invalidate(s);
       return iter;

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

@@ -362,7 +362,6 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::MultiGet)
 
   // First check the full filter
   // If full filter not useful, Then go into each block
-  const bool no_io = read_options.read_tier == kBlockCacheTier;
   uint64_t tracing_mget_id = BlockCacheTraceHelper::kReservedGetId;
   if (sst_file_range.begin()->get_context) {
     tracing_mget_id = sst_file_range.begin()->get_context->get_tracing_get_id();
@@ -372,7 +371,7 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::MultiGet)
   BlockCacheLookupContext metadata_lookup_context{
       TableReaderCaller::kUserMultiGet, tracing_mget_id,
       /*_get_from_user_specified_snapshot=*/read_options.snapshot != nullptr};
-  FullFilterKeysMayMatch(filter, &sst_file_range, no_io, prefix_extractor,
+  FullFilterKeysMayMatch(filter, &sst_file_range, prefix_extractor,
                          &metadata_lookup_context, read_options);
 
   if (!sst_file_range.empty()) {
@@ -461,9 +460,9 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::MultiGet)
             uncompression_dict_status =
                 rep_->uncompression_dict_reader
                     ->GetOrReadUncompressionDictionary(
-                        nullptr /* prefetch_buffer */, read_options, no_io,
-                        read_options.verify_checksums, get_context,
-                        &metadata_lookup_context, &uncompression_dict);
+                        nullptr /* prefetch_buffer */, read_options,
+                        get_context, &metadata_lookup_context,
+                        &uncompression_dict);
             uncompression_dict_inited = true;
           }
 
@@ -668,7 +667,7 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::MultiGet)
             biter->status().IsIncomplete()) {
           // couldn't get block from block_cache
           // Update Saver.state to Found because we are only looking for
-          // whether we can guarantee the key is not there when "no_io" is set
+          // whether we can guarantee the key is not there with kBlockCacheTier
           get_context->MarkKeyMayExist();
           break;
         }

package/deps/rocksdb/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/deps/rocksdb/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/deps/rocksdb/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/deps/rocksdb/rocksdb/table/block_based/filter_block.h

@@ -100,39 +100,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 +135,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 +142,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 +163,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/deps/rocksdb/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/deps/rocksdb/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/deps/rocksdb/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
@@ -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/deps/rocksdb/rocksdb/table/block_based/full_filter_block.h

@@ -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/deps/rocksdb/rocksdb/table/block_based/full_filter_block_test.cc

@@ -115,7 +115,7 @@ TEST_F(PluginFullFilterBlockTest, PluginEmptyBuilder) {
   FullFilterBlockReader reader(table_.get(), std::move(block));
   // Remain same symantic with blockbased filter
   ASSERT_TRUE(reader.KeyMayMatch("foo",
-                                 /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                 /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr, ReadOptions()));
 }
@@ -136,31 +136,31 @@ TEST_F(PluginFullFilterBlockTest, PluginSingleChunk) {
 
   FullFilterBlockReader reader(table_.get(), std::move(block));
   ASSERT_TRUE(reader.KeyMayMatch("foo",
-                                 /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                 /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("bar",
-                                 /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                 /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("box",
-                                 /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                 /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("hello",
-                                 /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                 /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("foo",
-                                 /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                 /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(!reader.KeyMayMatch("missing",
-                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                  /*const_ikey_ptr=*/nullptr,
                                   /*get_context=*/nullptr,
                                   /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(!reader.KeyMayMatch("other",
-                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                  /*const_ikey_ptr=*/nullptr,
                                   /*get_context=*/nullptr,
                                   /*lookup_context=*/nullptr, ReadOptions()));
 }
@@ -185,7 +185,7 @@ TEST_F(FullFilterBlockTest, EmptyBuilder) {
   FullFilterBlockReader reader(table_.get(), std::move(block));
   // Remain same symantic with blockbased filter
   ASSERT_TRUE(reader.KeyMayMatch("foo",
-                                 /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                 /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr, ReadOptions()));
 }
@@ -285,31 +285,31 @@ TEST_F(FullFilterBlockTest, SingleChunk) {
 
   FullFilterBlockReader reader(table_.get(), std::move(block));
   ASSERT_TRUE(reader.KeyMayMatch("foo",
-                                 /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                 /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("bar",
-                                 /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                 /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("box",
-                                 /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                 /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("hello",
-                                 /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                 /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(reader.KeyMayMatch("foo",
-                                 /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                 /*const_ikey_ptr=*/nullptr,
                                  /*get_context=*/nullptr,
                                  /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(!reader.KeyMayMatch("missing",
-                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                  /*const_ikey_ptr=*/nullptr,
                                   /*get_context=*/nullptr,
                                   /*lookup_context=*/nullptr, ReadOptions()));
   ASSERT_TRUE(!reader.KeyMayMatch("other",
-                                  /*no_io=*/false, /*const_ikey_ptr=*/nullptr,
+                                  /*const_ikey_ptr=*/nullptr,
                                   /*get_context=*/nullptr,
                                   /*lookup_context=*/nullptr, ReadOptions()));
 }

package/deps/rocksdb/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) {

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

@@ -35,9 +35,8 @@ Status BlockBasedTable::IndexReaderCommon::ReadIndexBlock(
 }
 
 Status BlockBasedTable::IndexReaderCommon::GetOrReadIndexBlock(
-    bool no_io, GetContext* get_context,
-    BlockCacheLookupContext* lookup_context, CachableEntry<Block>* index_block,
-    const ReadOptions& ro) const {
+    GetContext* get_context, BlockCacheLookupContext* lookup_context,
+    CachableEntry<Block>* index_block, const ReadOptions& ro) const {
   assert(index_block != nullptr);
 
   if (!index_block_.IsEmpty()) {
@@ -45,13 +44,19 @@ Status BlockBasedTable::IndexReaderCommon::GetOrReadIndexBlock(
     return Status::OK();
   }
 
-  ReadOptions read_options = ro;
-  if (no_io) {
-    read_options.read_tier = kBlockCacheTier;
-  }
-
-  return ReadIndexBlock(table_, /*prefetch_buffer=*/nullptr, read_options,
+  return ReadIndexBlock(table_, /*prefetch_buffer=*/nullptr, ro,
                         cache_index_blocks(), get_context, lookup_context,
                         index_block);
 }
+
+void BlockBasedTable::IndexReaderCommon::EraseFromCacheBeforeDestruction(
+    uint32_t uncache_aggressiveness) {
+  if (uncache_aggressiveness > 0) {
+    if (index_block_.IsCached()) {
+      index_block_.ResetEraseIfLastRef();
+    } else {
+      table()->EraseFromCache(table()->get_rep()->index_handle);
+    }
+  }
+}
 }  // namespace ROCKSDB_NAMESPACE