@nxtedition/rocksdb 15.1.2 → 15.1.3

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

@@ -143,6 +143,7 @@ void PartitionedFilterBlockBuilder::CutAFilterBlock(const Slice* next_key,
     ikey = p_index_builder_->GetPartitionKey();
   }
   filters_.push_back({std::move(ikey), std::move(filter_data), filter});
+  completed_partitions_size_.FetchAddRelaxed(filter.size());
   partitioned_filters_construction_status_.UpdateIfOk(
       filter_construction_status);
 
@@ -209,6 +210,56 @@ size_t PartitionedFilterBlockBuilder::EstimateEntriesAdded() {
   return total_added_in_built_ + filter_bits_builder_->EstimateEntriesAdded();
 }
 
+size_t PartitionedFilterBlockBuilder::CurrentFilterSizeEstimate() {
+  size_t active_partition_size =
+      filter_bits_builder_->EstimateEntriesAdded() * 2;  // 2 bytes per key
+
+  return estimated_filter_size_.LoadRelaxed() + active_partition_size;
+}
+
+void PartitionedFilterBlockBuilder::OnDataBlockFinalized(
+    uint64_t num_data_blocks) {
+  UpdateFilterSizeEstimate(num_data_blocks);
+}
+
+void PartitionedFilterBlockBuilder::UpdateFilterSizeEstimate(
+    uint64_t num_data_blocks) {
+  size_t partitions_size = completed_partitions_size_.LoadRelaxed();
+
+  // Reserve space if no partitions have been cut
+  size_t active_filter_estimate = 0;
+  if (partitions_size == 0) {
+    size_t avg_bytes_per_entry =
+        2;  // 2 bytes per entry, approx 15 bits per key
+
+    // Estimate using keys_per_partition_ since we expect to cut the first
+    // partition once it reaches approx. this many entries.
+    active_filter_estimate = keys_per_partition_ * avg_bytes_per_entry;
+
+    // Add a 2x buffer (for top-level index, etc.)
+    active_filter_estimate = active_filter_estimate * 2;
+  }
+  size_t filter_estimate = std::max(partitions_size, active_filter_estimate);
+
+  // Estimate top-level partition index size
+  if (p_index_builder_->separator_is_key_plus_seq()) {
+    filter_estimate += index_on_filter_block_builder_.CurrentSizeEstimate();
+  } else {
+    filter_estimate +=
+        index_on_filter_block_builder_without_seq_.CurrentSizeEstimate();
+  }
+
+  // Reserve filter space for the next data block
+  size_t reserved = 0;
+  if (num_data_blocks > 0) {
+    reserved = (filter_estimate / num_data_blocks) *
+               2;  // 2x average size per data block
+    estimated_filter_size_.StoreRelaxed(filter_estimate + reserved);
+  } else {
+    estimated_filter_size_.StoreRelaxed(filter_estimate);
+  }
+}
+
 void PartitionedFilterBlockBuilder::PrevKeyBeforeFinish(
     const Slice& prev_key_without_ts) {
   assert(prev_key_without_ts.compare(DEBUG_add_with_prev_key_called_

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

@@ -18,6 +18,7 @@
 #include "table/block_based/filter_block_reader_common.h"
 #include "table/block_based/full_filter_block.h"
 #include "table/block_based/index_builder.h"
+#include "util/atomic.h"
 #include "util/autovector.h"
 #include "util/hash_containers.h"
 
@@ -46,6 +47,8 @@ class PartitionedFilterBlockBuilder : public FullFilterBlockBuilder {
   }
 
   size_t EstimateEntriesAdded() override;
+  size_t CurrentFilterSizeEstimate() override;
+  void OnDataBlockFinalized(uint64_t num_data_blocks) override;
 
   void PrevKeyBeforeFinish(const Slice& prev_key_without_ts) override;
   Status Finish(const BlockHandle& last_partition_block_handle, Slice* filter,
@@ -67,6 +70,11 @@ class PartitionedFilterBlockBuilder : public FullFilterBlockBuilder {
     return Status::OK();
   }
 
+ protected:
+  // Needs to be thread-safe to be invoked from background worker
+  // thread when parallel compression is enabled.
+  void UpdateFilterSizeEstimate(uint64_t num_data_blocks) override;
+
  private:  // fns
   // Whether to cut a filter block before the next key
   bool DecideCutAFilterBlock();
@@ -92,6 +100,11 @@ class PartitionedFilterBlockBuilder : public FullFilterBlockBuilder {
   };
   std::deque<FilterEntry> filters_;  // list of partitioned filters and keys
                                      // used in building the index
+  // Running total of completed filter partition sizes to avoid
+  // iterating over filters_ deque, which can be concurrently modified by
+  // the main thread when parallel compression is enabled.
+  RelaxedAtomic<size_t> completed_partitions_size_{0};
+
   // The desired number of keys per partition
   uint32_t keys_per_partition_;
   // According to the bits builders, how many keys/prefixes added
@@ -107,6 +120,12 @@ class PartitionedFilterBlockBuilder : public FullFilterBlockBuilder {
   // For Add without prev key
   std::string prev_key_without_ts_;
 
+  // Cached filter size estimate for hot path performance - updated only when
+  // data blocks are written for meaningful estimate updates.
+  // Must be atomic since UpdateFilterSizeEstimate() can be called from
+  // background worker threads when parallel compression is enabled.
+  RelaxedAtomic<size_t> estimated_filter_size_{0};
+
 #ifndef NDEBUG
   // For verifying accurate previous keys are provided by the caller, so that
   // release code can be fast

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

@@ -158,7 +158,7 @@ class UserDefinedIndexBuilderWrapper : public IndexBuilder {
 
   size_t IndexSize() const override { return index_size_; }
 
-  uint64_t EstimateCurrentIndexSize() const override { return 0; }
+  uint64_t CurrentIndexSizeEstimate() const override { return 0; }
 
   bool separator_is_key_plus_seq() override {
     return internal_index_builder_->separator_is_key_plus_seq();

package/deps/rocksdb/rocksdb/table/external_table.cc

@@ -239,8 +239,8 @@ class ExternalTableReaderAdapter : public TableReader {
         "Get() not supported on external file iterator");
   }
 
-  virtual Status VerifyChecksum(const ReadOptions& /*ro*/,
-                                TableReaderCaller /*caller*/) override {
+  Status VerifyChecksum(const ReadOptions& /*ro*/, TableReaderCaller /*caller*/,
+                        bool /*meta_blocks_only*/ = false) override {
     return Status::OK();
   }
 

package/deps/rocksdb/rocksdb/table/sst_file_dumper.cc

@@ -47,12 +47,13 @@ SstFileDumper::SstFileDumper(const Options& options,
                              Temperature file_temp, size_t readahead_size,
                              bool verify_checksum, bool output_hex,
                              bool decode_blob_index, const EnvOptions& soptions,
-                             bool silent)
+                             bool silent, bool show_sequence_number_type)
     : file_name_(file_path),
       read_num_(0),
       file_temp_(file_temp),
       output_hex_(output_hex),
       decode_blob_index_(decode_blob_index),
+      show_sequence_number_type_(show_sequence_number_type),
       soptions_(soptions),
       silent_(silent),
       options_(options),
@@ -220,7 +221,7 @@ Status SstFileDumper::DumpTable(const std::string& out_filename) {
   Env* env = options_.env;
   Status s = env->NewWritableFile(out_filename, &out_file, soptions_);
   if (s.ok()) {
-    s = table_reader_->DumpTable(out_file.get());
+    s = table_reader_->DumpTable(out_file.get(), show_sequence_number_type_);
   }
   if (!s.ok()) {
     // close the file before return error, ignore the close error if there's any

package/deps/rocksdb/rocksdb/table/sst_file_dumper.h

@@ -21,7 +21,8 @@ class SstFileDumper {
                          bool verify_checksum, bool output_hex,
                          bool decode_blob_index,
                          const EnvOptions& soptions = EnvOptions(),
-                         bool silent = false);
+                         bool silent = false,
+                         bool show_sequence_number_type = false);
 
   // read_num_limit limits the total number of keys read. If read_num_limit = 0,
   // then there is no limit. If read_num_limit = 0 or
@@ -79,6 +80,7 @@ class SstFileDumper {
   Temperature file_temp_;
   bool output_hex_;
   bool decode_blob_index_;
+  bool show_sequence_number_type_;
   EnvOptions soptions_;
   // less verbose in stdout/stderr
   bool silent_;

package/deps/rocksdb/rocksdb/table/table_builder.h

@@ -225,6 +225,11 @@ class TableBuilder {
   // is enabled.
   virtual uint64_t EstimatedFileSize() const { return FileSize(); }
 
+  // Estimated tail size of the SST file generated so far. The "tail" refers to
+  // all blocks written after data blocks (index + filter). This value helps
+  // estimate the total file size when deciding when to cut files.
+  virtual uint64_t EstimatedTailSize() const { return 0; }
+
   virtual uint64_t GetTailSize() const { return 0; }
 
   // If the user defined table properties collector suggest the file to

package/deps/rocksdb/rocksdb/table/table_reader.h

@@ -179,13 +179,15 @@ class TableReader {
   }
 
   // convert db file to a human readable form
-  virtual Status DumpTable(WritableFile* /*out_file*/) {
+  virtual Status DumpTable(WritableFile* /*out_file*/,
+                           bool /*show_sequence_number_type*/ = false) {
     return Status::NotSupported("DumpTable() not supported");
   }
 
   // check whether there is corruption in this db file
   virtual Status VerifyChecksum(const ReadOptions& /*read_options*/,
-                                TableReaderCaller /*caller*/) {
+                                TableReaderCaller /*caller*/,
+                                bool /*meta_blocks_only*/ = false) {
     return Status::NotSupported("VerifyChecksum() not supported");
   }
 

package/deps/rocksdb/rocksdb/table/table_test.cc

@@ -9140,6 +9140,7 @@ class UserDefinedIndexStressTest
                                const std::vector<DataRange>& ranges,
                                bool& data_added) {
     std::unique_ptr<SstFileWriter> writer;
+
     data_added = false;
 
     std::vector<DataRange> ranges_in_file;
@@ -9151,9 +9152,12 @@ class UserDefinedIndexStressTest
       }
 
       if (writer == nullptr) {
+        // lazy create writer until there is data to be written to avoid
+        // unchecked status error
         writer = std::make_unique<SstFileWriter>(EnvOptions(), options_);
         ASSERT_OK(writer->Open(ingest_file));
       }
+
       ranges_in_file.push_back(range);
 
       data_added = true;
@@ -9256,6 +9260,7 @@ class UserDefinedIndexStressTest
       if (kVerbose) {
         std::cout << "iteration " << i << std::endl;
       }
+      SCOPED_TRACE("Iteration " + std::to_string(i));
       // randomly generate 1 to 3 ranges
       auto ranges = GenerateKeyRanges(rnd.Uniform(3) + 4, 2, "");
 
@@ -9299,13 +9304,14 @@ class UserDefinedIndexStressTest
                              size_t& ingest_file_count,
                              const IngestExternalFileOptions& ifo,
                              bool combine_ranges = false) {
-    std::vector<std::string> ingest_files;
     // Generate SST file and bulk load them one level at a time
+    std::vector<std::string> ingest_files;
     if (combine_ranges) {
       size_t i = 0;
       while (i < ranges_in_level.size()) {
         // if combine ranges, generate 1 SST file that combines muliple ranges
         // together
+        // Randomly combine ranges to SST file.
         size_t batch_end_idx =
             std::min(i + rnd.Uniform(3) + 2, ranges_in_level.size());
         bool data_added = false;
@@ -9361,22 +9367,7 @@ class UserDefinedIndexStressTest
   }
 };
 
-// TODO(xingbo)
-// This test is disabled due to following test case condition:
-// level n:   delete range 4-6
-// level n+1: data range 0-------10
-// query: 3-9, count=2.
-// Becuase query count == 2, level n+1 would only prepare 3-5. but since 4-6
-// got deleted in the upper level, they are not returned, so only 3 is
-// returned. Meantime the query should have return [3, 6]
-// One way to fix this is by preparing more data blocks once prepared blocks
-// are exhausted, but upper bound is not reached yet. This requires following
-// changes:
-// 1. Fix out of bound flag in block table iterator. Only set it if the key is
-// larger than the upper bound.
-// 2. Refactor the prepared block single dimension vector into 2 dimension of
-// vectors, so that more blocks could be prepared if needed.
-TEST_P(UserDefinedIndexStressTest, DISABLED_PartialDeleteRange) {
+TEST_P(UserDefinedIndexStressTest, PartialDeleteRange) {
   // Create 2 column families. One use normal put/del, the other uses sst
   // ingest Randomly generate multiple non overlapping range for multiple
   // levels Range scan same range between the 2 CF and validate the result is
@@ -9387,6 +9378,22 @@ TEST_P(UserDefinedIndexStressTest, DISABLED_PartialDeleteRange) {
   SCOPED_TRACE("dbname: " + dbname_);
   ASSERT_NO_FATAL_FAILURE(SetupDB(dbname_));
 
+  if (enable_udi_) {
+    // Skip UDI for now.
+    // The issue is that with UDI enabled, prepare might not prepare enough keys
+    // at lower level due to range delete from upper level.
+    // E.g. consider a LSM tree:
+    // L1: Data         [0-1]
+    // L2: Delete Range [0-6]
+    // L3: Data         [0-9]
+    // When multiscan queries range [0-9) with UDI count as 3, the L3 file
+    // will only prepare range [0-3). However, this range is masked out by upper
+    // layer delete range from [0-6] from L2. This causes query to only return
+    // [0,1], while [0,1,7] is the right result. Until prepare is able to
+    // preparing additional block supported, UDI is skipped.
+    return;
+  }
+
   for (int i = 0; i < 5; i++) {
     ranges_in_levels_.push_back(
         GenerateKeyRanges(rnd.Uniform(3) + 4, 2,
@@ -9408,9 +9415,9 @@ TEST_P(UserDefinedIndexStressTest, DeleteRangeMixedWithDataFile) {
   // Create 2 column families. One use normal put/del, the other uses sst
   // ingest.
   // Test the case where there are 3 levels, the middle level is a delete
-  // range file that span across the entire key space. The top level file have
-  // multiple files and each one has both data and delete range Scan same
-  // range between the 2 CF and validate the result is same
+  // range file that span across the entire key space. The top and bottom level
+  // file have multiple files and each one has both data and delete range. Scan
+  // same range between the 2 CF and validate the result is same
   SCOPED_TRACE("Start with random seed: " + std::to_string(rand_seed_));
   dbname_ = test::PerThreadDBPath(
       "UserDefinedIndexStressTest_DeleteRangeMixedWithDataFile");
@@ -9418,9 +9425,9 @@ TEST_P(UserDefinedIndexStressTest, DeleteRangeMixedWithDataFile) {
   ASSERT_NO_FATAL_FAILURE(SetupDB(dbname_));
 
   // Test 3 levels.
-  // bottom level is normal data files.
-  ranges_in_levels_.push_back(GenerateKeyRanges(rnd.Uniform(3) + 4, 2, "L6"));
-  // middle level delete range between each level
+  // Bottom level is mixed data with delete range.
+  ranges_in_levels_.push_back(GenerateKeyRanges(rnd.Uniform(3) + 6, 2, "L6"));
+  // Middle level delete range across entire key space.
   if (is_reverse_comparator_) {
     ranges_in_levels_.push_back({{.start = 100,
                                   .end = 0,
@@ -9437,8 +9444,8 @@ TEST_P(UserDefinedIndexStressTest, DeleteRangeMixedWithDataFile) {
                                   .end_key = "keyz"}});
   }
 
-  // Top level is normal data files
-  ranges_in_levels_.push_back(GenerateKeyRanges(rnd.Uniform(3) + 4, 2, "L4"));
+  // Top level is mixed data with delete range.
+  ranges_in_levels_.push_back(GenerateKeyRanges(rnd.Uniform(3) + 6, 2, "L4"));
 
   IngestExternalFileOptions ifo;
   ifo.snapshot_consistency = false;
@@ -9448,7 +9455,7 @@ TEST_P(UserDefinedIndexStressTest, DeleteRangeMixedWithDataFile) {
   for (auto const& ranges_in_level : ranges_in_levels_) {
     ASSERT_NO_FATAL_FAILURE(
         IngestFilesInOneLevel(ranges_in_level, ingest_file_name_prefix,
-                              ingest_file_count, ifo, true));
+                              ingest_file_count, ifo, /*combine_ranges=*/true));
     if (first_level) {
       first_level = false;
       if (enable_compaction_with_sst_partitioner_) {
@@ -9475,9 +9482,10 @@ TEST_P(UserDefinedIndexStressTest, DeleteRange) {
   ASSERT_NO_FATAL_FAILURE(SetupDB(dbname_));
 
   // Test 3 levels.
-  // bottom level is normal data files.
+  // bottom level constains multiple files, each could have data or delete
+  // ranges or both.
   ranges_in_levels_.push_back(GenerateKeyRanges(rnd.Uniform(3) + 4, 2, "L6"));
-  // middle level delete range between each level
+  // middle level delete range across entire key space
   if (is_reverse_comparator_) {
     ranges_in_levels_.push_back({{.start = 100,
                                   .end = 0,
@@ -9493,7 +9501,8 @@ TEST_P(UserDefinedIndexStressTest, DeleteRange) {
                                   .start_key = "key",
                                   .end_key = "keyz"}});
   }
-  // Top level is normal data files
+  // Top level constains multiple files, each could have data or delete
+  // ranges or both.
   ranges_in_levels_.push_back(GenerateKeyRanges(rnd.Uniform(3) + 4, 2, "L4"));
 
   IngestExternalFileOptions ifo;
@@ -9519,20 +9528,19 @@ TEST_P(UserDefinedIndexStressTest, DeleteRange) {
 }
 
 TEST_P(UserDefinedIndexStressTest, AtomicReplaceBulkLoad) {
-  // Create 2 column families. One use normal put/del, the other uses sst
-  // ingest.
-  // Test the case where there are 3 levels, the middle level is a delete
-  // range file that span across the entire key space. Range scan same range
-  // between the 2 CF and validate the result is same
+  // Create 2 column families. One use normal put/del, the other uses SST
+  // ingest. The SST ingest uses atomic range replace.
   SCOPED_TRACE("Start with random seed: " + std::to_string(rand_seed_));
-  dbname_ = test::PerThreadDBPath("UserDefinedIndexStressTest_DeleteRange");
+  dbname_ =
+      test::PerThreadDBPath("UserDefinedIndexStressTest_AtomicReplaceBulkLoad");
   SCOPED_TRACE("dbname: " + dbname_);
   ASSERT_NO_FATAL_FAILURE(SetupDB(dbname_));
 
   // Test 3 levels.
-  // bottom level is normal data files.
+  // bottom level constains multiple files, each could have data or delete
+  // ranges or both.
   ranges_in_levels_.push_back(GenerateKeyRanges(rnd.Uniform(3) + 4, 2, "L6"));
-  // middle level delete range between each level
+  // middle level delete range across entire key space
   if (is_reverse_comparator_) {
     ranges_in_levels_.push_back({{.start = 100,
                                   .end = 0,
@@ -9548,7 +9556,8 @@ TEST_P(UserDefinedIndexStressTest, AtomicReplaceBulkLoad) {
                                   .start_key = "key",
                                   .end_key = "keyz"}});
   }
-  // Top level is normal data files
+  // Top level constains multiple files, each could have data or delete
+  // ranges or both.
   ranges_in_levels_.push_back(GenerateKeyRanges(rnd.Uniform(3) + 4, 2, "L4"));
 
   IngestExternalFileOptions ifo;
@@ -9569,7 +9578,7 @@ TEST_P(UserDefinedIndexStressTest, AtomicReplaceBulkLoad) {
   }
 
   // Ingest the a new file with atomic replace with full key space, this layer
-  // is exactly same as the one at Level 4
+  // is exactly same as the one at the top level
   bool data_added;
   ASSERT_NO_FATAL_FAILURE(CreateSstFileWithRanges(
       ingest_file_name_prefix + std::to_string(++ingest_file_count),

package/deps/rocksdb/rocksdb/test_util/sync_point.cc

@@ -79,4 +79,8 @@ void SetupSyncPointsToMockDirectIO() {
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
 #endif
 }
+
+#ifndef NDEBUG
+std::atomic<int> g_throw_on_testable_assertion_failure{0};
+#endif  // NDEBUG
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/test_util/sync_point.h

@@ -180,3 +180,35 @@ void SetupSyncPointsToMockDirectIO();
     }                                               \
   }
 #endif  // NDEBUG
+
+// An alternative to assert() that is more test-friendly than using
+// ASSERT_DEATH. Relies on exception propagation.
+#ifdef NDEBUG
+#define testable_assert(cond)
+#else
+namespace ROCKSDB_NAMESPACE {
+// Intentionally not based on std::exception to reduce places where this
+// would be caught
+struct TestableAssertionFailure {};
+extern std::atomic<int> g_throw_on_testable_assertion_failure;
+}  // namespace ROCKSDB_NAMESPACE
+#define testable_assert(cond)                                          \
+  do {                                                                 \
+    if (ROCKSDB_NAMESPACE::g_throw_on_testable_assertion_failure.load( \
+            std::memory_order_relaxed) > 0) {                          \
+      if (cond) {                                                      \
+      } else                                                           \
+        throw ROCKSDB_NAMESPACE::TestableAssertionFailure();           \
+    } else {                                                           \
+      assert(cond);                                                    \
+    }                                                                  \
+  } while (0)
+#define ASSERT_TESTABLE_FAILURE(expr)                                   \
+  do {                                                                  \
+    ROCKSDB_NAMESPACE::g_throw_on_testable_assertion_failure.fetch_add( \
+        1, std::memory_order_relaxed);                                  \
+    ASSERT_THROW(expr, ROCKSDB_NAMESPACE::TestableAssertionFailure);    \
+    ROCKSDB_NAMESPACE::g_throw_on_testable_assertion_failure.fetch_sub( \
+        1, std::memory_order_relaxed);                                  \
+  } while (0)
+#endif

package/deps/rocksdb/rocksdb/test_util/testutil.h

@@ -766,6 +766,10 @@ struct CompressorCustomAlg : public CompressorWrapper {
     return kCompression;
   }
 
+  std::unique_ptr<Compressor> Clone() const override {
+    return std::make_unique<CompressorCustomAlg>(wrapped_->Clone());
+  }
+
   Status CompressBlock(Slice uncompressed_data, char* compressed_output,
                        size_t* compressed_output_size,
                        CompressionType* out_compression_type,
@@ -792,9 +796,9 @@ struct CompressorCustomAlg : public CompressorWrapper {
   }
 
   std::unique_ptr<Compressor> MaybeCloneSpecialized(
-      CacheEntryRole block_type, DictSampleArgs&& dict_samples) override {
+      CacheEntryRole block_type, DictSampleArgs&& dict_samples) const override {
     auto clone =
-        wrapped_->MaybeCloneSpecialized(block_type, std::move(dict_samples));
+        wrapped_->CloneMaybeSpecialized(block_type, std::move(dict_samples));
     return std::make_unique<CompressorCustomAlg>(std::move(clone));
   }
 

package/deps/rocksdb/rocksdb/tools/db_bench_tool.cc

@@ -446,6 +446,14 @@ DEFINE_int64(db_write_buffer_size,
              ROCKSDB_NAMESPACE::Options().db_write_buffer_size,
              "Number of bytes to buffer in all memtables before compacting");
 
+DEFINE_int64(max_manifest_file_size,
+             ROCKSDB_NAMESPACE::Options().max_manifest_file_size,
+             "Max manifest file size (or minimum max with auto-tuning)");
+
+DEFINE_int32(max_manifest_space_amp_pct,
+             ROCKSDB_NAMESPACE::Options().max_manifest_space_amp_pct,
+             "Max manifest space amp percentage for auto-tuning");
+
 DEFINE_bool(cost_write_buffer_to_cache, false,
             "The usage of memtable is costed to the block cache");
 
@@ -579,7 +587,7 @@ DEFINE_double(cache_high_pri_pool_ratio, 0.0,
 DEFINE_double(cache_low_pri_pool_ratio, 0.0,
               "Ratio of block cache reserve for low pri blocks.");
 
-DEFINE_string(cache_type, "lru_cache", "Type of block cache.");
+DEFINE_string(cache_type, "hyper_clock_cache", "Type of block cache.");
 
 DEFINE_bool(use_compressed_secondary_cache, false,
             "Use the CompressedSecondaryCache as the secondary cache.");
@@ -3252,10 +3260,10 @@ class Benchmark {
       db_bench_exit(1);
     } else if (EndsWith(FLAGS_cache_type, "hyper_clock_cache")) {
       size_t estimated_entry_charge;
-      if (FLAGS_cache_type == "fixed_hyper_clock_cache" ||
-          FLAGS_cache_type == "hyper_clock_cache") {
+      if (FLAGS_cache_type == "fixed_hyper_clock_cache") {
         estimated_entry_charge = FLAGS_block_size;
-      } else if (FLAGS_cache_type == "auto_hyper_clock_cache") {
+      } else if (FLAGS_cache_type == "auto_hyper_clock_cache" ||
+                 FLAGS_cache_type == "hyper_clock_cache") {
         estimated_entry_charge = 0;
       } else {
         fprintf(stderr, "Cache type not supported.");
@@ -4368,6 +4376,8 @@ class Benchmark {
       options.write_buffer_manager.reset(
           new WriteBufferManager(FLAGS_db_write_buffer_size, cache_));
     }
+    options.max_manifest_file_size = FLAGS_max_manifest_file_size;
+    options.max_manifest_space_amp_pct = FLAGS_max_manifest_space_amp_pct;
     options.arena_block_size = FLAGS_arena_block_size;
     options.write_buffer_size = FLAGS_write_buffer_size;
     options.max_write_buffer_number = FLAGS_max_write_buffer_number;

package/deps/rocksdb/rocksdb/tools/ldb_cmd.cc

@@ -1610,11 +1610,12 @@ void DumpManifestFile(Options options, std::string file, bool verbose, bool hex,
   WriteController wc(options.delayed_write_rate);
   WriteBufferManager wb(options.db_write_buffer_size);
   ImmutableDBOptions immutable_db_options(options);
-  VersionSet versions(dbname, &immutable_db_options, sopt, tc.get(), &wb, &wc,
+  VersionSet versions(dbname, &immutable_db_options, MutableDBOptions{}, sopt,
+                      tc.get(), &wb, &wc,
                       /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr,
                       /*db_id=*/"", /*db_session_id=*/"",
                       options.daily_offpeak_time_utc,
-                      /*error_handler=*/nullptr, /*read_only=*/true);
+                      /*error_handler=*/nullptr, /*unchanging=*/true);
   Status s = versions.DumpManifest(options, file, verbose, hex, json, cf_descs);
   if (!s.ok()) {
     fprintf(stderr, "Error in processing file %s %s\n", file.c_str(),
@@ -1805,11 +1806,12 @@ Status GetLiveFilesChecksumInfoFromVersionSet(Options options,
   WriteController wc(options.delayed_write_rate);
   WriteBufferManager wb(options.db_write_buffer_size);
   ImmutableDBOptions immutable_db_options(options);
-  VersionSet versions(dbname, &immutable_db_options, sopt, tc.get(), &wb, &wc,
+  VersionSet versions(dbname, &immutable_db_options, MutableDBOptions{options},
+                      sopt, tc.get(), &wb, &wc,
                       /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr,
                       /*db_id=*/"", /*db_session_id=*/"",
                       options.daily_offpeak_time_utc,
-                      /*error_handler=*/nullptr, /*read_only=*/true);
+                      /*error_handler=*/nullptr, /*unchanging=*/true);
   std::vector<std::string> cf_name_list;
   s = versions.ListColumnFamilies(&cf_name_list, db_path,
                                   immutable_db_options.fs.get());
@@ -2660,7 +2662,8 @@ Status ReduceDBLevelsCommand::GetOldNumOfLevels(Options& opt, int* levels) {
   const InternalKeyComparator cmp(opt.comparator);
   WriteController wc(opt.delayed_write_rate);
   WriteBufferManager wb(opt.db_write_buffer_size);
-  VersionSet versions(db_path_, &db_options, soptions, tc.get(), &wb, &wc,
+  VersionSet versions(db_path_, &db_options, MutableDBOptions{opt}, soptions,
+                      tc.get(), &wb, &wc,
                       /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr,
                       /*db_id=*/"", /*db_session_id=*/"",
                       opt.daily_offpeak_time_utc,

package/deps/rocksdb/rocksdb/tools/ldb_cmd_test.cc

@@ -208,8 +208,9 @@ class FileChecksumTestHelper {
     WriteController wc(options_.delayed_write_rate);
     WriteBufferManager wb(options_.db_write_buffer_size);
     ImmutableDBOptions immutable_db_options(options_);
-    VersionSet versions(dbname_, &immutable_db_options, sopt, tc.get(), &wb,
-                        &wc, nullptr, nullptr, "", "",
+    VersionSet versions(dbname_, &immutable_db_options,
+                        MutableDBOptions{options_}, sopt, tc.get(), &wb, &wc,
+                        nullptr, nullptr, "", "",
                         options_.daily_offpeak_time_utc, nullptr,
                         /*read_only=*/false);
     std::vector<std::string> cf_name_list;