@nxtedition/rocksdb 10.1.5 → 10.2.0

package/deps/rocksdb/rocksdb/options/cf_options.h

@@ -173,7 +173,8 @@ struct MutableCFOptions {
         compression_per_level(options.compression_per_level),
         memtable_max_range_deletions(options.memtable_max_range_deletions),
         bottommost_file_compaction_delay(
-            options.bottommost_file_compaction_delay) {
+            options.bottommost_file_compaction_delay),
+        uncache_aggressiveness(options.uncache_aggressiveness) {
     RefreshDerivedOptions(options.num_levels, options.compaction_style);
   }
 
@@ -223,7 +224,9 @@ struct MutableCFOptions {
         memtable_protection_bytes_per_key(0),
         block_protection_bytes_per_key(0),
         sample_for_compression(0),
-        memtable_max_range_deletions(0) {}
+        memtable_max_range_deletions(0),
+        bottommost_file_compaction_delay(0),
+        uncache_aggressiveness(0) {}
 
   explicit MutableCFOptions(const Options& options);
 
@@ -319,6 +322,7 @@ struct MutableCFOptions {
   std::vector<CompressionType> compression_per_level;
   uint32_t memtable_max_range_deletions;
   uint32_t bottommost_file_compaction_delay;
+  uint32_t uncache_aggressiveness;
 
   // Derived options
   // Per-level target file size.

package/deps/rocksdb/rocksdb/options/db_options.cc

@@ -388,6 +388,10 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct ImmutableDBOptions, wal_compression),
           OptionType::kCompressionType, OptionVerificationType::kNormal,
           OptionTypeFlags::kNone}},
+        {"background_close_inactive_wals",
+         {offsetof(struct ImmutableDBOptions, background_close_inactive_wals),
+          OptionType::kBoolean, OptionVerificationType::kNormal,
+          OptionTypeFlags::kNone}},
         {"seq_per_batch",
          {0, OptionType::kBoolean, OptionVerificationType::kDeprecated,
           OptionTypeFlags::kNone}},
@@ -755,6 +759,7 @@ ImmutableDBOptions::ImmutableDBOptions(const DBOptions& options)
       two_write_queues(options.two_write_queues),
       manual_wal_flush(options.manual_wal_flush),
       wal_compression(options.wal_compression),
+      background_close_inactive_wals(options.background_close_inactive_wals),
       atomic_flush(options.atomic_flush),
       avoid_unnecessary_blocking_io(options.avoid_unnecessary_blocking_io),
       persist_stats_to_disk(options.persist_stats_to_disk),
@@ -921,6 +926,9 @@ void ImmutableDBOptions::Dump(Logger* log) const {
                    manual_wal_flush);
   ROCKS_LOG_HEADER(log, "            Options.wal_compression: %d",
                    wal_compression);
+  ROCKS_LOG_HEADER(log,
+                   "            Options.background_close_inactive_wals: %d",
+                   background_close_inactive_wals);
   ROCKS_LOG_HEADER(log, "            Options.atomic_flush: %d", atomic_flush);
   ROCKS_LOG_HEADER(log,
                    "            Options.avoid_unnecessary_blocking_io: %d",

package/deps/rocksdb/rocksdb/options/db_options.h

@@ -84,6 +84,7 @@ struct ImmutableDBOptions {
   bool two_write_queues;
   bool manual_wal_flush;
   CompressionType wal_compression;
+  bool background_close_inactive_wals;
   bool atomic_flush;
   bool avoid_unnecessary_blocking_io;
   bool persist_stats_to_disk;
@@ -97,17 +98,20 @@ struct ImmutableDBOptions {
   std::string db_host_id;
   FileTypeSet checksum_handoff_file_types;
   CacheTier lowest_used_cache_tier;
-  // Convenience/Helper objects that are not part of the base DBOptions
-  std::shared_ptr<FileSystem> fs;
-  SystemClock* clock;
-  Statistics* stats;
-  Logger* logger;
   std::shared_ptr<CompactionService> compaction_service;
   bool enforce_single_del_contracts;
   uint64_t follower_refresh_catchup_period_ms;
   uint64_t follower_catchup_retry_count;
   uint64_t follower_catchup_retry_wait_ms;
 
+  // Beginning convenience/helper objects that are not part of the base
+  // DBOptions
+  std::shared_ptr<FileSystem> fs;
+  SystemClock* clock;
+  Statistics* stats;
+  Logger* logger;
+  // End of convenience/helper objects.
+
   bool IsWalDirSameAsDBPath() const;
   bool IsWalDirSameAsDBPath(const std::string& path) const;
   const std::string& GetWalDir() const;

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

@@ -360,6 +360,9 @@ void ColumnFamilyOptions::Dump(Logger* log) const {
     ROCKS_LOG_HEADER(log,
                      "Options.compaction_options_universal.stop_style: %s",
                      str_compaction_stop_style.c_str());
+    ROCKS_LOG_HEADER(log,
+                     "Options.compaction_options_universal.max_read_amp: %d",
+                     compaction_options_universal.max_read_amp);
     ROCKS_LOG_HEADER(
         log, "Options.compaction_options_fifo.max_table_files_size: %" PRIu64,
         compaction_options_fifo.max_table_files_size);

package/deps/rocksdb/rocksdb/options/options_helper.cc

@@ -274,6 +274,7 @@ void UpdateColumnFamilyOptions(const MutableCFOptions& moptions,
   cf_opts->last_level_temperature = moptions.last_level_temperature;
   cf_opts->default_write_temperature = moptions.default_write_temperature;
   cf_opts->memtable_max_range_deletions = moptions.memtable_max_range_deletions;
+  cf_opts->uncache_aggressiveness = moptions.uncache_aggressiveness;
 }
 
 void UpdateColumnFamilyOptions(const ImmutableCFOptions& ioptions,

package/deps/rocksdb/rocksdb/options/options_settable_test.cc

@@ -353,6 +353,7 @@ TEST_F(OptionsSettableTest, DBOptionsAllFieldsSettable) {
                              "two_write_queues=false;"
                              "manual_wal_flush=false;"
                              "wal_compression=kZSTD;"
+                             "background_close_inactive_wals=true;"
                              "seq_per_batch=false;"
                              "atomic_flush=false;"
                              "avoid_unnecessary_blocking_io=false;"
@@ -565,7 +566,8 @@ TEST_F(OptionsSettableTest, ColumnFamilyOptionsAllFieldsSettable) {
       "persist_user_defined_timestamps=true;"
       "block_protection_bytes_per_key=1;"
       "memtable_max_range_deletions=999999;"
-      "bottommost_file_compaction_delay=7200;",
+      "bottommost_file_compaction_delay=7200;"
+      "uncache_aggressiveness=1234;",
       new_options));
 
   ASSERT_NE(new_options->blob_cache.get(), nullptr);

package/deps/rocksdb/rocksdb/port/jemalloc_helper.h

@@ -6,7 +6,7 @@
 #pragma once
 
 #if defined(__clang__) && defined(__GLIBC__)
-// glibc's `posix_memalign()` declaration specifies `throw()` while clang's
+// glibc's `posix_memalign()` declaration specifies `noexcept` while clang's
 // declaration does not. There is a hack in clang to make its re-declaration
 // compatible with glibc's if they are declared consecutively. That hack breaks
 // if yet another `posix_memalign()` declaration comes between glibc's and
@@ -14,7 +14,7 @@
 // declarations both come before "jemalloc.h"'s `posix_memalign()` declaration.
 //
 // This problem could also be avoided if "jemalloc.h"'s `posix_memalign()`
-// declaration did not specify `throw()` when built with clang.
+// declaration did not specify `noexcept` when built with clang.
 #include <mm_malloc.h>
 #endif
 

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

@@ -39,6 +39,7 @@ void* SaveStack(int* /*num_frames*/, int /*first_frames_to_skip*/) {
 #endif  // OS_OPENBSD
 #ifdef OS_FREEBSD
 #include <sys/sysctl.h>
+#include <sys/wait.h>
 #endif  // OS_FREEBSD
 #ifdef OS_LINUX
 #include <sys/prctl.h>

package/deps/rocksdb/rocksdb/port/win/port_win.cc

@@ -101,8 +101,9 @@ bool CondVar::TimedWait(uint64_t abs_time_us) {
   std::unique_lock<std::mutex> lk(mu_->getLock(), std::adopt_lock);
 
   // Work around https://github.com/microsoft/STL/issues/369
-#if defined(_MSC_VER) && \
-    (!defined(_MSVC_STL_UPDATE) || _MSVC_STL_UPDATE < 202008L)
+  // std::condition_variable_any::wait_for had a fix, but
+  // std::condition_variable still doesn't have a fix in STL yet
+#if defined(_MSC_VER)
   if (relTimeUs == std::chrono::microseconds::zero()) {
     lk.unlock();
     lk.lock();

package/deps/rocksdb/rocksdb/src.mk

@@ -304,6 +304,7 @@ LIB_SOURCES =                                                   \
   utilities/persistent_cache/volatile_tier_impl.cc              \
   utilities/simulator_cache/cache_simulator.cc                  \
   utilities/simulator_cache/sim_cache.cc                        \
+  utilities/table_properties_collectors/compact_for_tiering_collector.cc \
   utilities/table_properties_collectors/compact_on_deletion_collector.cc \
   utilities/trace/file_trace_reader_writer.cc                   \
   utilities/trace/replayer_impl.cc                              \
@@ -380,6 +381,7 @@ STRESS_LIB_SOURCES =                                            \
   db_stress_tool/cf_consistency_stress.cc                      \
   db_stress_tool/db_stress_common.cc                           \
   db_stress_tool/db_stress_driver.cc                           \
+  db_stress_tool/db_stress_filters.cc                          \
   db_stress_tool/db_stress_gflags.cc                           \
   db_stress_tool/db_stress_listener.cc                         \
   db_stress_tool/db_stress_shared_state.cc                     \
@@ -405,6 +407,7 @@ TEST_LIB_SOURCES =                                              \
 FOLLY_SOURCES =                                                 \
   $(FOLLY_DIR)/folly/container/detail/F14Table.cpp              \
   $(FOLLY_DIR)/folly/detail/Futex.cpp                           \
+  $(FOLLY_DIR)/folly/lang/Exception.cpp                         \
   $(FOLLY_DIR)/folly/lang/SafeAssert.cpp                        \
   $(FOLLY_DIR)/folly/lang/ToAscii.cpp                           \
   $(FOLLY_DIR)/folly/ScopeGuard.cpp                             \
@@ -628,6 +631,7 @@ TEST_MAIN_SOURCES =                                                     \
   utilities/persistent_cache/persistent_cache_test.cc                   \
   utilities/simulator_cache/cache_simulator_test.cc                     \
   utilities/simulator_cache/sim_cache_test.cc                           \
+  utilities/table_properties_collectors/compact_for_tiering_collector_test.cc \
   utilities/table_properties_collectors/compact_on_deletion_collector_test.cc  \
   utilities/transactions/optimistic_transaction_test.cc                 \
   utilities/transactions/lock/range/range_locking_test.cc               \

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

@@ -44,9 +44,8 @@ InternalIteratorBase<IndexValue>* BinarySearchIndexReader::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/block_based_table_builder.cc

@@ -582,8 +582,10 @@ struct BlockBasedTableBuilder::Rep {
       assert(factory);
 
       std::unique_ptr<InternalTblPropColl> collector{
-          factory->CreateInternalTblPropColl(tbo.column_family_id,
-                                             tbo.level_at_creation)};
+          factory->CreateInternalTblPropColl(
+              tbo.column_family_id, tbo.level_at_creation,
+              tbo.ioptions.num_levels,
+              tbo.last_level_inclusive_max_seqno_threshold)};
       if (collector) {
         table_properties_collectors.emplace_back(std::move(collector));
       }

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

@@ -823,6 +823,12 @@ void BlockBasedTableIterator::BlockCacheLookupForReadAheadSize(
         read_options_, block_handle,
         &(block_handle_info.cachable_entry_).As<Block_kData>());
     if (!s.ok()) {
+#ifndef NDEBUG
+      // To allow fault injection verification to pass since non-okay status in
+      // `BlockCacheLookupForReadAheadSize()` won't fail the read but to have
+      // less or no readahead
+      IGNORE_STATUS_IF_ERROR(s);
+#endif
       break;
     }
 
@@ -852,6 +858,15 @@ void BlockBasedTableIterator::BlockCacheLookupForReadAheadSize(
     is_index_at_curr_block_ = false;
   }
 
+#ifndef NDEBUG
+  // To allow fault injection verification to pass since non-okay status in
+  // `BlockCacheLookupForReadAheadSize()` won't fail the read but to have less
+  // or no readahead
+  if (!index_iter_->status().ok()) {
+    IGNORE_STATUS_IF_ERROR(index_iter_->status());
+  }
+#endif
+
   if (found_first_miss_block) {
     // Iterate cache hit block handles from the end till a Miss is there, to
     // truncate and update the end offset till that Miss.

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

@@ -135,7 +135,46 @@ extern const uint64_t kBlockBasedTableMagicNumber;
 extern const std::string kHashIndexPrefixesBlock;
 extern const std::string kHashIndexPrefixesMetadataBlock;
 
-BlockBasedTable::~BlockBasedTable() { delete rep_; }
+BlockBasedTable::~BlockBasedTable() {
+  auto ua = rep_->uncache_aggressiveness.LoadRelaxed();
+  if (ua > 0 && rep_->table_options.block_cache) {
+    if (rep_->filter) {
+      rep_->filter->EraseFromCacheBeforeDestruction(ua);
+    }
+    if (rep_->index_reader) {
+      {
+        // TODO: Also uncache data blocks known after any gaps in partitioned
+        // index. Right now the iterator errors out as soon as there's an
+        // index partition not in cache.
+        IndexBlockIter iiter_on_stack;
+        ReadOptions ropts;
+        ropts.read_tier = kBlockCacheTier;  // No I/O
+        auto iiter = NewIndexIterator(
+            ropts, /*disable_prefix_seek=*/false, &iiter_on_stack,
+            /*get_context=*/nullptr, /*lookup_context=*/nullptr);
+        std::unique_ptr<InternalIteratorBase<IndexValue>> iiter_unique_ptr;
+        if (iiter != &iiter_on_stack) {
+          iiter_unique_ptr.reset(iiter);
+        }
+        // Un-cache the data blocks the index iterator with tell us about
+        // without I/O. (NOTE: It's extremely unlikely that a data block
+        // will be in block cache without the index block pointing to it
+        // also in block cache.)
+        UncacheAggressivenessAdvisor advisor(ua);
+        for (iiter->SeekToFirst(); iiter->Valid() && advisor.ShouldContinue();
+             iiter->Next()) {
+          bool erased = EraseFromCache(iiter->value().handle);
+          advisor.Report(erased);
+        }
+        iiter->status().PermitUncheckedError();
+      }
+
+      // Un-cache the index block(s)
+      rep_->index_reader->EraseFromCacheBeforeDestruction(ua);
+    }
+  }
+  delete rep_;
+}
 
 namespace {
 // Read the block identified by "handle" from "file".
@@ -439,6 +478,7 @@ bool IsFeatureSupported(const TableProperties& table_properties,
 }
 
 // Caller has to ensure seqno is not nullptr.
+// Set *seqno to the global sequence number for reading this file.
 Status GetGlobalSequenceNumber(const TableProperties& table_properties,
                                SequenceNumber largest_seqno,
                                SequenceNumber* seqno) {
@@ -461,12 +501,17 @@ Status GetGlobalSequenceNumber(const TableProperties& table_properties,
   }
 
   uint32_t version = DecodeFixed32(version_pos->second.c_str());
-  if (version < 2) {
-    if (seqno_pos != props.end() || version != 1) {
-      std::array<char, 200> msg_buf;
+  if (version != 2) {
+    std::array<char, 200> msg_buf;
+    if (version != 1) {
+      snprintf(msg_buf.data(), msg_buf.max_size(),
+               "An external sst file has corrupted version %u.", version);
+      return Status::Corruption(msg_buf.data());
+    }
+    if (seqno_pos != props.end()) {
       // This is a v1 external sst file, global_seqno is not supported.
       snprintf(msg_buf.data(), msg_buf.max_size(),
-               "An external sst file with version %u have global seqno "
+               "An external sst file with version %u has global seqno "
                "property with value %s",
                version, seqno_pos->second.c_str());
       return Status::Corruption(msg_buf.data());
@@ -594,6 +639,8 @@ Status BlockBasedTable::Open(
 
   // From read_options, retain deadline, io_timeout, rate_limiter_priority, and
   // verify_checksums. In future, we may retain more options.
+  // TODO: audit more ReadOptions and do this in a way that brings attention
+  // on new ReadOptions?
   ReadOptions ro;
   ro.deadline = read_options.deadline;
   ro.io_timeout = read_options.io_timeout;
@@ -844,6 +891,10 @@ Status BlockBasedTable::PrefetchTail(
   if (tail_size != 0) {
     tail_prefetch_size = tail_size;
   } else {
+    // Fallback for SST files, for which tail size is not recorded in the
+    // manifest. Eventually, this fallback might be removed, so it's
+    // better to make sure that such SST files get compacted.
+    // See https://github.com/facebook/rocksdb/issues/12664
     if (tail_prefetch_stats != nullptr) {
       // Multiple threads may get a 0 (no history) when running in parallel,
       // but it will get cleared after the first of them finishes.
@@ -858,14 +909,15 @@ Status BlockBasedTable::PrefetchTail(
       // properties, at which point we don't yet know the index type.
       tail_prefetch_size = prefetch_all || preload_all ? 512 * 1024 : 4 * 1024;
 
-      ROCKS_LOG_WARN(logger,
-                     "Tail prefetch size %zu is calculated based on heuristics",
-                     tail_prefetch_size);
-    } else {
       ROCKS_LOG_WARN(
           logger,
-          "Tail prefetch size %zu is calculated based on TailPrefetchStats",
-          tail_prefetch_size);
+          "[%s] Tail prefetch size %zu is calculated based on heuristics.",
+          file->file_name().c_str(), tail_prefetch_size);
+    } else {
+      ROCKS_LOG_WARN(logger,
+                     "[%s] Tail prefetch size %zu is calculated based on "
+                     "TailPrefetchStats.",
+                     file->file_name().c_str(), tail_prefetch_size);
     }
   }
   size_t prefetch_off;
@@ -1521,9 +1573,8 @@ Status BlockBasedTable::LookupAndPinBlocksInCache(
   Status s;
   CachableEntry<UncompressionDict> uncompression_dict;
   if (rep_->uncompression_dict_reader) {
-    const bool no_io = (ro.read_tier == kBlockCacheTier);
     s = rep_->uncompression_dict_reader->GetOrReadUncompressionDictionary(
-        /* prefetch_buffer= */ nullptr, ro, no_io, ro.verify_checksums,
+        /* prefetch_buffer= */ nullptr, ro,
         /* get_context= */ nullptr, /* lookup_context= */ nullptr,
         &uncompression_dict);
     if (!s.ok()) {
@@ -1978,14 +2029,11 @@ bool BlockBasedTable::PrefixRangeMayMatch(
   FilterBlockReader* const filter = rep_->filter.get();
   *filter_checked = false;
   if (filter != nullptr) {
-    const bool no_io = read_options.read_tier == kBlockCacheTier;
-
     const Slice* const const_ikey_ptr = &internal_key;
     may_match = filter->RangeMayExist(
         read_options.iterate_upper_bound, user_key_without_ts, prefix_extractor,
         rep_->internal_comparator.user_comparator(), const_ikey_ptr,
-        filter_checked, need_upper_bound_check, no_io, lookup_context,
-        read_options);
+        filter_checked, need_upper_bound_check, lookup_context, read_options);
   }
 
   return may_match;
@@ -2065,7 +2113,7 @@ FragmentedRangeTombstoneIterator* BlockBasedTable::NewRangeTombstoneIterator(
 }
 
 bool BlockBasedTable::FullFilterKeyMayMatch(
-    FilterBlockReader* filter, const Slice& internal_key, const bool no_io,
+    FilterBlockReader* filter, const Slice& internal_key,
     const SliceTransform* prefix_extractor, GetContext* get_context,
     BlockCacheLookupContext* lookup_context,
     const ReadOptions& read_options) const {
@@ -2078,7 +2126,7 @@ bool BlockBasedTable::FullFilterKeyMayMatch(
   size_t ts_sz = rep_->internal_comparator.user_comparator()->timestamp_size();
   Slice user_key_without_ts = StripTimestampFromUserKey(user_key, ts_sz);
   if (rep_->whole_key_filtering) {
-    may_match = filter->KeyMayMatch(user_key_without_ts, no_io, const_ikey_ptr,
+    may_match = filter->KeyMayMatch(user_key_without_ts, const_ikey_ptr,
                                     get_context, lookup_context, read_options);
     if (may_match) {
       RecordTick(rep_->ioptions.stats, BLOOM_FILTER_FULL_POSITIVE);
@@ -2092,7 +2140,7 @@ bool BlockBasedTable::FullFilterKeyMayMatch(
     // FIXME ^^^: there should be no reason for Get() to depend on current
     // prefix_extractor at all. It should always use table_prefix_extractor.
     may_match = filter->PrefixMayMatch(
-        prefix_extractor->Transform(user_key_without_ts), no_io, const_ikey_ptr,
+        prefix_extractor->Transform(user_key_without_ts), const_ikey_ptr,
         get_context, lookup_context, read_options);
     RecordTick(rep_->ioptions.stats, BLOOM_FILTER_PREFIX_CHECKED);
     if (may_match) {
@@ -2108,7 +2156,7 @@ bool BlockBasedTable::FullFilterKeyMayMatch(
 }
 
 void BlockBasedTable::FullFilterKeysMayMatch(
-    FilterBlockReader* filter, MultiGetRange* range, const bool no_io,
+    FilterBlockReader* filter, MultiGetRange* range,
     const SliceTransform* prefix_extractor,
     BlockCacheLookupContext* lookup_context,
     const ReadOptions& read_options) const {
@@ -2118,7 +2166,7 @@ void BlockBasedTable::FullFilterKeysMayMatch(
   uint64_t before_keys = range->KeysLeft();
   assert(before_keys > 0);  // Caller should ensure
   if (rep_->whole_key_filtering) {
-    filter->KeysMayMatch(range, no_io, lookup_context, read_options);
+    filter->KeysMayMatch(range, lookup_context, read_options);
     uint64_t after_keys = range->KeysLeft();
     if (after_keys) {
       RecordTick(rep_->ioptions.stats, BLOOM_FILTER_FULL_POSITIVE, after_keys);
@@ -2134,7 +2182,7 @@ void BlockBasedTable::FullFilterKeysMayMatch(
   } else if (!PrefixExtractorChanged(prefix_extractor)) {
     // FIXME ^^^: there should be no reason for MultiGet() to depend on current
     // prefix_extractor at all. It should always use table_prefix_extractor.
-    filter->PrefixesMayMatch(range, prefix_extractor, false, lookup_context,
+    filter->PrefixesMayMatch(range, prefix_extractor, lookup_context,
                              read_options);
     RecordTick(rep_->ioptions.stats, BLOOM_FILTER_PREFIX_CHECKED, before_keys);
     uint64_t after_keys = range->KeysLeft();
@@ -2240,7 +2288,6 @@ Status BlockBasedTable::Get(const ReadOptions& read_options, const Slice& key,
   assert(key.size() >= 8);  // key must be internal key
   assert(get_context != nullptr);
   Status s;
-  const bool no_io = read_options.read_tier == kBlockCacheTier;
 
   FilterBlockReader* const filter =
       !skip_filters ? rep_->filter.get() : nullptr;
@@ -2259,7 +2306,7 @@ Status BlockBasedTable::Get(const ReadOptions& read_options, const Slice& key,
   }
   TEST_SYNC_POINT("BlockBasedTable::Get:BeforeFilterMatch");
   const bool may_match =
-      FullFilterKeyMayMatch(filter, key, no_io, prefix_extractor, get_context,
+      FullFilterKeyMayMatch(filter, key, prefix_extractor, get_context,
                             &lookup_context, read_options);
   TEST_SYNC_POINT("BlockBasedTable::Get:AfterFilterMatch");
   if (may_match) {
@@ -2309,7 +2356,8 @@ Status BlockBasedTable::Get(const ReadOptions& read_options, const Slice& key,
           /*for_compaction=*/false, /*async_read=*/false, tmp_status,
           /*use_block_cache_for_lookup=*/true);
 
-      if (no_io && biter.status().IsIncomplete()) {
+      if (read_options.read_tier == kBlockCacheTier &&
+          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
@@ -2421,7 +2469,6 @@ Status BlockBasedTable::MultiGetFilter(const ReadOptions& read_options,
 
   // 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 (mget_range->begin()->get_context) {
     tracing_mget_id = mget_range->begin()->get_context->get_tracing_get_id();
@@ -2429,8 +2476,8 @@ Status BlockBasedTable::MultiGetFilter(const ReadOptions& read_options,
   BlockCacheLookupContext lookup_context{
       TableReaderCaller::kUserMultiGet, tracing_mget_id,
       /*_get_from_user_specified_snapshot=*/read_options.snapshot != nullptr};
-  FullFilterKeysMayMatch(filter, mget_range, no_io, prefix_extractor,
-                         &lookup_context, read_options);
+  FullFilterKeysMayMatch(filter, mget_range, prefix_extractor, &lookup_context,
+                         read_options);
 
   return Status::OK();
 }
@@ -2663,6 +2710,24 @@ Status BlockBasedTable::VerifyChecksumInMetaBlocks(
   return s;
 }
 
+bool BlockBasedTable::EraseFromCache(const BlockHandle& handle) const {
+  assert(rep_ != nullptr);
+
+  Cache* const cache = rep_->table_options.block_cache.get();
+  if (cache == nullptr) {
+    return false;
+  }
+
+  CacheKey key = GetCacheKey(rep_->base_cache_key, handle);
+
+  Cache::Handle* const cache_handle = cache->Lookup(key.AsSlice());
+  if (cache_handle == nullptr) {
+    return false;
+  }
+
+  return cache->Release(cache_handle, /*erase_if_last_ref=*/true);
+}
+
 bool BlockBasedTable::TEST_BlockInCache(const BlockHandle& handle) const {
   assert(rep_ != nullptr);
 
@@ -2796,11 +2861,8 @@ uint64_t BlockBasedTable::ApproximateOffsetOf(const ReadOptions& read_options,
 
   BlockCacheLookupContext context(caller);
   IndexBlockIter iiter_on_stack;
-  ReadOptions ro;
-  ro.total_order_seek = true;
-  ro.io_activity = read_options.io_activity;
   auto index_iter =
-      NewIndexIterator(ro, /*disable_prefix_seek=*/true,
+      NewIndexIterator(read_options, /*disable_prefix_seek=*/true,
                        /*input_iter=*/&iiter_on_stack, /*get_context=*/nullptr,
                        /*lookup_context=*/&context);
   std::unique_ptr<InternalIteratorBase<IndexValue>> iiter_unique_ptr;
@@ -2843,11 +2905,8 @@ uint64_t BlockBasedTable::ApproximateSize(const ReadOptions& read_options,
 
   BlockCacheLookupContext context(caller);
   IndexBlockIter iiter_on_stack;
-  ReadOptions ro;
-  ro.total_order_seek = true;
-  ro.io_activity = read_options.io_activity;
   auto index_iter =
-      NewIndexIterator(ro, /*disable_prefix_seek=*/true,
+      NewIndexIterator(read_options, /*disable_prefix_seek=*/true,
                        /*input_iter=*/&iiter_on_stack, /*get_context=*/nullptr,
                        /*lookup_context=*/&context);
   std::unique_ptr<InternalIteratorBase<IndexValue>> iiter_unique_ptr;
@@ -3023,10 +3082,8 @@ Status BlockBasedTable::DumpTable(WritableFile* out_file) {
   if (rep_->uncompression_dict_reader) {
     CachableEntry<UncompressionDict> uncompression_dict;
     s = rep_->uncompression_dict_reader->GetOrReadUncompressionDictionary(
-        nullptr /* prefetch_buffer */, ro, false /* no_io */,
-        false, /* verify_checksums */
-        nullptr /* get_context */, nullptr /* lookup_context */,
-        &uncompression_dict);
+        nullptr /* prefetch_buffer */, ro, nullptr /* get_context */,
+        nullptr /* lookup_context */, &uncompression_dict);
     if (!s.ok()) {
       return s;
     }
@@ -3232,4 +3289,8 @@ void BlockBasedTable::DumpKeyValue(const Slice& key, const Slice& value,
   out_stream << "  ------\n";
 }
 
+void BlockBasedTable::MarkObsolete(uint32_t uncache_aggressiveness) {
+  rep_->uncache_aggressiveness.StoreRelaxed(uncache_aggressiveness);
+}
+
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -33,6 +33,7 @@
 #include "table/table_reader.h"
 #include "table/two_level_iterator.h"
 #include "trace_replay/block_cache_tracer.h"
+#include "util/atomic.h"
 #include "util/coro_utils.h"
 #include "util/hash_containers.h"
 
@@ -183,6 +184,8 @@ class BlockBasedTable : public TableReader {
   Status ApproximateKeyAnchors(const ReadOptions& read_options,
                                std::vector<Anchor>& anchors) override;
 
+  bool EraseFromCache(const BlockHandle& handle) const;
+
   bool TEST_BlockInCache(const BlockHandle& handle) const;
 
   // Returns true if the block for the specified key is in cache.
@@ -208,6 +211,8 @@ class BlockBasedTable : public TableReader {
   Status VerifyChecksum(const ReadOptions& readOptions,
                         TableReaderCaller caller) override;
 
+  void MarkObsolete(uint32_t uncache_aggressiveness) override;
+
   ~BlockBasedTable();
 
   bool TEST_FilterBlockInCache() const;
@@ -241,6 +246,8 @@ class BlockBasedTable : public TableReader {
         FilePrefetchBuffer* /* tail_prefetch_buffer */) {
       return Status::OK();
     }
+    virtual void EraseFromCacheBeforeDestruction(
+        uint32_t /*uncache_aggressiveness*/) {}
   };
 
   class IndexReaderCommon;
@@ -462,14 +469,12 @@ class BlockBasedTable : public TableReader {
                            std::unique_ptr<IndexReader>* index_reader);
 
   bool FullFilterKeyMayMatch(FilterBlockReader* filter, const Slice& user_key,
-                             const bool no_io,
                              const SliceTransform* prefix_extractor,
                              GetContext* get_context,
                              BlockCacheLookupContext* lookup_context,
                              const ReadOptions& read_options) const;
 
   void FullFilterKeysMayMatch(FilterBlockReader* filter, MultiGetRange* range,
-                              const bool no_io,
                               const SliceTransform* prefix_extractor,
                               BlockCacheLookupContext* lookup_context,
                               const ReadOptions& read_options) const;
@@ -619,11 +624,7 @@ struct BlockBasedTable::Rep {
 
   std::shared_ptr<FragmentedRangeTombstoneList> fragmented_range_dels;
 
-  // FIXME
-  // If true, data blocks in this file are definitely ZSTD compressed. If false
-  // they might not be. When false we skip creating a ZSTD digested
-  // uncompression dictionary. Even if we get a false negative, things should
-  // still work, just not as quickly.
+  // Context for block cache CreateCallback
   BlockCreateContext create_context;
 
   // If global_seqno is used, all Keys in this file will have the same
@@ -672,6 +673,13 @@ struct BlockBasedTable::Rep {
   // `end_key` for range deletion entries.
   const bool user_defined_timestamps_persisted;
 
+  // Set to >0 when the file is known to be obsolete and should have its block
+  // cache entries evicted on close. NOTE: when the file becomes obsolete,
+  // there could be multiple table cache references that all mark this file as
+  // obsolete. An atomic resolves the race quite reasonably. Even in the rare
+  // case of such a race, they will most likely be storing the same value.
+  RelaxedAtomic<uint32_t> uncache_aggressiveness{0};
+
   std::unique_ptr<CacheReservationManager::CacheReservationHandle>
       table_reader_cache_res_handle = nullptr;