@nxtedition/rocksdb 10.1.5 → 10.2.0

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

@@ -24,6 +24,9 @@ class BlockBasedTable::IndexReaderCommon : public BlockBasedTable::IndexReader {
     assert(table_ != nullptr);
   }
 
+  void EraseFromCacheBeforeDestruction(
+      uint32_t /*uncache_aggressiveness*/) override;
+
  protected:
   static Status ReadIndexBlock(const BlockBasedTable* table,
                                FilePrefetchBuffer* prefetch_buffer,
@@ -71,7 +74,7 @@ class BlockBasedTable::IndexReaderCommon : public BlockBasedTable::IndexReader {
     return table_->get_rep()->user_defined_timestamps_persisted;
   }
 
-  Status GetOrReadIndexBlock(bool no_io, GetContext* get_context,
+  Status GetOrReadIndexBlock(GetContext* get_context,
                              BlockCacheLookupContext* lookup_context,
                              CachableEntry<Block>* index_block,
                              const ReadOptions& read_options) const;

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

@@ -45,6 +45,9 @@ PartitionedFilterBlockBuilder::PartitionedFilterBlockBuilder(
       p_index_builder_(p_index_builder),
       keys_added_to_partition_(0),
       total_added_in_built_(0) {
+  // 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) {
@@ -86,7 +89,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);
@@ -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/deps/rocksdb/rocksdb/table/block_based/partitioned_filter_block.h

@@ -111,22 +111,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 +136,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;

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

@@ -198,24 +198,23 @@ class PartitionedFilterBlockTest
     std::unique_ptr<PartitionedFilterBlockReader> reader(
         NewReader(builder, pib));
     // Querying added keys
-    const bool no_io = true;
     std::vector<std::string> keys = PrepareKeys(keys_without_ts, kKeyNum);
     for (const auto& key : keys) {
       auto ikey = InternalKey(key, 0, ValueType::kTypeValue);
       const Slice ikey_slice = Slice(*ikey.rep());
       ASSERT_TRUE(reader->KeyMayMatch(
-          StripTimestampFromUserKey(key, ts_sz_), !no_io, &ikey_slice,
+          StripTimestampFromUserKey(key, ts_sz_), &ikey_slice,
           /*get_context=*/nullptr,
-          /*lookup_context=*/nullptr, ReadOptions()));
+          /*lookup_context=*/nullptr, test::kReadOptionsNoIo));
     }
     {
       // querying a key twice
       auto ikey = InternalKey(keys[0], 0, ValueType::kTypeValue);
       const Slice ikey_slice = Slice(*ikey.rep());
       ASSERT_TRUE(reader->KeyMayMatch(
-          StripTimestampFromUserKey(keys[0], ts_sz_), !no_io, &ikey_slice,
+          StripTimestampFromUserKey(keys[0], ts_sz_), &ikey_slice,
           /*get_context=*/nullptr,
-          /*lookup_context=*/nullptr, ReadOptions()));
+          /*lookup_context=*/nullptr, test::kReadOptionsNoIo));
     }
     // querying missing keys
     std::vector<std::string> missing_keys =
@@ -225,15 +224,15 @@ class PartitionedFilterBlockTest
       const Slice ikey_slice = Slice(*ikey.rep());
       if (empty) {
         ASSERT_TRUE(reader->KeyMayMatch(
-            StripTimestampFromUserKey(key, ts_sz_), !no_io, &ikey_slice,
+            StripTimestampFromUserKey(key, ts_sz_), &ikey_slice,
             /*get_context=*/nullptr,
-            /*lookup_context=*/nullptr, ReadOptions()));
+            /*lookup_context=*/nullptr, test::kReadOptionsNoIo));
       } else {
         // assuming a good hash function
         ASSERT_FALSE(reader->KeyMayMatch(
-            StripTimestampFromUserKey(key, ts_sz_), !no_io, &ikey_slice,
+            StripTimestampFromUserKey(key, ts_sz_), &ikey_slice,
             /*get_context=*/nullptr,
-            /*lookup_context=*/nullptr, ReadOptions()));
+            /*lookup_context=*/nullptr, test::kReadOptionsNoIo));
       }
     }
   }
@@ -389,11 +388,10 @@ TEST_P(PartitionedFilterBlockTest, SamePrefixInMultipleBlocks) {
   for (const auto& key : pkeys) {
     auto ikey = InternalKey(key, 0, ValueType::kTypeValue);
     const Slice ikey_slice = Slice(*ikey.rep());
-    ASSERT_TRUE(reader->PrefixMayMatch(prefix_extractor->Transform(key),
-                                       /*no_io=*/false, &ikey_slice,
-                                       /*get_context=*/nullptr,
-                                       /*lookup_context=*/nullptr,
-                                       ReadOptions()));
+    ASSERT_TRUE(
+        reader->PrefixMayMatch(prefix_extractor->Transform(key), &ikey_slice,
+                               /*get_context=*/nullptr,
+                               /*lookup_context=*/nullptr, ReadOptions()));
   }
   // Non-existent keys but with the same prefix
   const std::string pnonkeys_without_ts[4] = {"p-key9", "p-key11", "p-key21",
@@ -403,11 +401,10 @@ TEST_P(PartitionedFilterBlockTest, SamePrefixInMultipleBlocks) {
   for (const auto& key : pnonkeys) {
     auto ikey = InternalKey(key, 0, ValueType::kTypeValue);
     const Slice ikey_slice = Slice(*ikey.rep());
-    ASSERT_TRUE(reader->PrefixMayMatch(prefix_extractor->Transform(key),
-                                       /*no_io=*/false, &ikey_slice,
-                                       /*get_context=*/nullptr,
-                                       /*lookup_context=*/nullptr,
-                                       ReadOptions()));
+    ASSERT_TRUE(
+        reader->PrefixMayMatch(prefix_extractor->Transform(key), &ikey_slice,
+                               /*get_context=*/nullptr,
+                               /*lookup_context=*/nullptr, ReadOptions()));
   }
 }
 
@@ -444,8 +441,7 @@ TEST_P(PartitionedFilterBlockTest, PrefixInWrongPartitionBug) {
     auto prefix = prefix_extractor->Transform(key);
     auto ikey = InternalKey(key, 0, ValueType::kTypeValue);
     const Slice ikey_slice = Slice(*ikey.rep());
-    ASSERT_TRUE(reader->PrefixMayMatch(prefix,
-                                       /*no_io=*/false, &ikey_slice,
+    ASSERT_TRUE(reader->PrefixMayMatch(prefix, &ikey_slice,
                                        /*get_context=*/nullptr,
                                        /*lookup_context=*/nullptr,
                                        ReadOptions()));
@@ -477,4 +473,4 @@ int main(int argc, char** argv) {
   ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
-}
+}

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

@@ -47,9 +47,8 @@ InternalIteratorBase<IndexValue>* PartitionIndexReader::NewIterator(
     const ReadOptions& read_options, bool /* disable_prefix_seek */,
     IndexBlockIter* iter, GetContext* get_context,
     BlockCacheLookupContext* lookup_context) {
-  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) {
@@ -78,15 +77,10 @@ InternalIteratorBase<IndexValue>* PartitionIndexReader::NewIterator(
             index_value_is_full(), false /* block_contents_pinned */,
             user_defined_timestamps_persisted()));
   } else {
-    ReadOptions ro;
-    ro.fill_cache = read_options.fill_cache;
-    ro.deadline = read_options.deadline;
-    ro.io_timeout = read_options.io_timeout;
-    ro.adaptive_readahead = read_options.adaptive_readahead;
-    ro.async_io = read_options.async_io;
-    ro.rate_limiter_priority = read_options.rate_limiter_priority;
-    ro.verify_checksums = read_options.verify_checksums;
-    ro.io_activity = read_options.io_activity;
+    ReadOptions ro{read_options};
+    // FIXME? Possible regression seen in prefetch_test if this field is
+    // propagated
+    ro.readahead_size = ReadOptions{}.readahead_size;
 
     // We don't return pinned data from index blocks, so no need
     // to set `block_contents_pinned`.
@@ -130,8 +124,8 @@ Status PartitionIndexReader::CacheDependencies(
 
   CachableEntry<Block> index_block;
   {
-    Status s = GetOrReadIndexBlock(false /* no_io */, nullptr /* get_context */,
-                                   &lookup_context, &index_block, ro);
+    Status s = GetOrReadIndexBlock(nullptr /* get_context */, &lookup_context,
+                                   &index_block, ro);
     if (!s.ok()) {
       return s;
     }
@@ -223,4 +217,48 @@ Status PartitionIndexReader::CacheDependencies(
   return s;
 }
 
+void PartitionIndexReader::EraseFromCacheBeforeDestruction(
+    uint32_t uncache_aggressiveness) {
+  // NOTE: essentially a copy of
+  // PartitionedFilterBlockReader::EraseFromCacheBeforeDestruction
+  if (uncache_aggressiveness > 0) {
+    CachableEntry<Block> top_level_block;
+
+    ReadOptions ro_no_io;
+    ro_no_io.read_tier = ReadTier::kBlockCacheTier;
+    GetOrReadIndexBlock(/*get_context=*/nullptr,
+                        /*lookup_context=*/nullptr, &top_level_block, ro_no_io)
+        .PermitUncheckedError();
+
+    if (!partition_map_.empty()) {
+      // All partitions present if any
+      for (auto& e : partition_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::kIndex), &biter,
+          kNullStats, true /* total_order_seek */, index_has_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
+  BlockBasedTable::IndexReaderCommon::EraseFromCacheBeforeDestruction(
+      uncache_aggressiveness);
+}
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -42,6 +42,8 @@ class PartitionIndexReader : public BlockBasedTable::IndexReaderCommon {
     // TODO(myabandeh): more accurate estimate of partition_map_ mem usage
     return usage;
   }
+  void EraseFromCacheBeforeDestruction(
+      uint32_t /*uncache_aggressiveness*/) override;
 
  private:
   PartitionIndexReader(const BlockBasedTable* t,

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

@@ -77,9 +77,8 @@ Status UncompressionDictReader::ReadUncompressionDictionary(
 }
 
 Status UncompressionDictReader::GetOrReadUncompressionDictionary(
-    FilePrefetchBuffer* prefetch_buffer, const ReadOptions& ro, bool no_io,
-    bool verify_checksums, GetContext* get_context,
-    BlockCacheLookupContext* lookup_context,
+    FilePrefetchBuffer* prefetch_buffer, const ReadOptions& ro,
+    GetContext* get_context, BlockCacheLookupContext* lookup_context,
     CachableEntry<UncompressionDict>* uncompression_dict) const {
   assert(uncompression_dict);
 
@@ -88,14 +87,7 @@ Status UncompressionDictReader::GetOrReadUncompressionDictionary(
     return Status::OK();
   }
 
-  ReadOptions read_options;
-  if (no_io) {
-    read_options.read_tier = kBlockCacheTier;
-  }
-  read_options.verify_checksums = verify_checksums;
-  read_options.io_activity = ro.io_activity;
-
-  return ReadUncompressionDictionary(table_, prefetch_buffer, read_options,
+  return ReadUncompressionDictionary(table_, prefetch_buffer, ro,
                                      cache_dictionary_blocks(), get_context,
                                      lookup_context, uncompression_dict);
 }

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

@@ -32,9 +32,8 @@ class UncompressionDictReader {
       std::unique_ptr<UncompressionDictReader>* uncompression_dict_reader);
 
   Status GetOrReadUncompressionDictionary(
-      FilePrefetchBuffer* prefetch_buffer, const ReadOptions& ro, bool no_io,
-      bool verify_checksums, GetContext* get_context,
-      BlockCacheLookupContext* lookup_context,
+      FilePrefetchBuffer* prefetch_buffer, const ReadOptions& ro,
+      GetContext* get_context, BlockCacheLookupContext* lookup_context,
       CachableEntry<UncompressionDict>* uncompression_dict) const;
 
   size_t ApproximateMemoryUsage() const;

package/deps/rocksdb/rocksdb/table/compaction_merging_iterator.cc

@@ -11,8 +11,8 @@ class CompactionMergingIterator : public InternalIterator {
   CompactionMergingIterator(
       const InternalKeyComparator* comparator, InternalIterator** children,
       int n, bool is_arena_mode,
-      std::vector<
-          std::pair<TruncatedRangeDelIterator*, TruncatedRangeDelIterator***>>
+      std::vector<std::pair<std::unique_ptr<TruncatedRangeDelIterator>,
+                            std::unique_ptr<TruncatedRangeDelIterator>**>>&
           range_tombstones)
       : is_arena_mode_(is_arena_mode),
         comparator_(comparator),
@@ -27,7 +27,7 @@ class CompactionMergingIterator : public InternalIterator {
     }
     assert(range_tombstones.size() == static_cast<size_t>(n));
     for (auto& p : range_tombstones) {
-      range_tombstone_iters_.push_back(p.first);
+      range_tombstone_iters_.push_back(std::move(p.first));
     }
     pinned_heap_item_.resize(n);
     for (int i = 0; i < n; ++i) {
@@ -47,10 +47,7 @@ class CompactionMergingIterator : public InternalIterator {
   }
 
   ~CompactionMergingIterator() override {
-    // TODO: use unique_ptr for range_tombstone_iters_
-    for (auto child : range_tombstone_iters_) {
-      delete child;
-    }
+    range_tombstone_iters_.clear();
 
     for (auto& child : children_) {
       child.iter.DeleteIter(is_arena_mode_);
@@ -197,7 +194,8 @@ class CompactionMergingIterator : public InternalIterator {
   // nullptr means the sorted run of children_[i] does not have range
   // tombstones (or the current SSTable does not have range tombstones in the
   // case of LevelIterator).
-  std::vector<TruncatedRangeDelIterator*> range_tombstone_iters_;
+  std::vector<std::unique_ptr<TruncatedRangeDelIterator>>
+      range_tombstone_iters_;
   // Used as value for range tombstone keys
   std::string dummy_tombstone_val{};
 
@@ -349,8 +347,9 @@ void CompactionMergingIterator::AddToMinHeapOrCheckStatus(HeapItem* child) {
 
 InternalIterator* NewCompactionMergingIterator(
     const InternalKeyComparator* comparator, InternalIterator** children, int n,
-    std::vector<std::pair<TruncatedRangeDelIterator*,
-                          TruncatedRangeDelIterator***>>& range_tombstone_iters,
+    std::vector<std::pair<std::unique_ptr<TruncatedRangeDelIterator>,
+                          std::unique_ptr<TruncatedRangeDelIterator>**>>&
+        range_tombstone_iters,
     Arena* arena) {
   assert(n >= 0);
   if (n == 0) {

package/deps/rocksdb/rocksdb/table/compaction_merging_iterator.h

@@ -38,7 +38,8 @@ class CompactionMergingIterator;
 
 InternalIterator* NewCompactionMergingIterator(
     const InternalKeyComparator* comparator, InternalIterator** children, int n,
-    std::vector<std::pair<TruncatedRangeDelIterator*,
-                          TruncatedRangeDelIterator***>>& range_tombstone_iters,
+    std::vector<std::pair<std::unique_ptr<TruncatedRangeDelIterator>,
+                          std::unique_ptr<TruncatedRangeDelIterator>**>>&
+        range_tombstone_iters,
     Arena* arena = nullptr);
 }  // namespace ROCKSDB_NAMESPACE