@nxtedition/rocksdb 8.2.0 → 8.2.2

package/deps/rocksdb/rocksdb/monitoring/perf_step_timer.h

@@ -5,7 +5,7 @@
 //
 #pragma once
 #include "monitoring/perf_level_imp.h"
-#include "monitoring/statistics.h"
+#include "monitoring/statistics_impl.h"
 #include "rocksdb/system_clock.h"
 
 namespace ROCKSDB_NAMESPACE {

package/deps/rocksdb/rocksdb/monitoring/statistics.cc

@@ -3,14 +3,14 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 //
-#include "monitoring/statistics.h"
+#include "rocksdb/statistics.h"
 
 #include <algorithm>
 #include <cinttypes>
 #include <cstdio>
 
+#include "monitoring/statistics_impl.h"
 #include "rocksdb/convenience.h"
-#include "rocksdb/statistics.h"
 #include "rocksdb/utilities/customizable_util.h"
 #include "rocksdb/utilities/options_type.h"
 #include "util/string_util.h"
@@ -83,6 +83,8 @@ const std::vector<std::pair<Tickers, std::string>> TickersNameMap = {
     {NUMBER_MERGE_FAILURES, "rocksdb.number.merge.failures"},
     {BLOOM_FILTER_PREFIX_CHECKED, "rocksdb.bloom.filter.prefix.checked"},
     {BLOOM_FILTER_PREFIX_USEFUL, "rocksdb.bloom.filter.prefix.useful"},
+    {BLOOM_FILTER_PREFIX_TRUE_POSITIVE,
+     "rocksdb.bloom.filter.prefix.true.positive"},
     {NUMBER_OF_RESEEKS_IN_ITERATION, "rocksdb.number.reseeks.iteration"},
     {GET_UPDATES_SINCE_CALLS, "rocksdb.getupdatessince.calls"},
     {WAL_FILE_SYNCED, "rocksdb.wal.synced"},
@@ -204,7 +206,23 @@ const std::vector<std::pair<Tickers, std::string>> TickersNameMap = {
     {LAST_LEVEL_READ_COUNT, "rocksdb.last.level.read.count"},
     {NON_LAST_LEVEL_READ_BYTES, "rocksdb.non.last.level.read.bytes"},
     {NON_LAST_LEVEL_READ_COUNT, "rocksdb.non.last.level.read.count"},
+    {LAST_LEVEL_SEEK_FILTERED, "rocksdb.last.level.seek.filtered"},
+    {LAST_LEVEL_SEEK_FILTER_MATCH, "rocksdb.last.level.seek.filter.match"},
+    {LAST_LEVEL_SEEK_DATA, "rocksdb.last.level.seek.data"},
+    {LAST_LEVEL_SEEK_DATA_USEFUL_NO_FILTER,
+     "rocksdb.last.level.seek.data.useful.no.filter"},
+    {LAST_LEVEL_SEEK_DATA_USEFUL_FILTER_MATCH,
+     "rocksdb.last.level.seek.data.useful.filter.match"},
+    {NON_LAST_LEVEL_SEEK_FILTERED, "rocksdb.non.last.level.seek.filtered"},
+    {NON_LAST_LEVEL_SEEK_FILTER_MATCH,
+     "rocksdb.non.last.level.seek.filter.match"},
+    {NON_LAST_LEVEL_SEEK_DATA, "rocksdb.non.last.level.seek.data"},
+    {NON_LAST_LEVEL_SEEK_DATA_USEFUL_NO_FILTER,
+     "rocksdb.non.last.level.seek.data.useful.no.filter"},
+    {NON_LAST_LEVEL_SEEK_DATA_USEFUL_FILTER_MATCH,
+     "rocksdb.non.last.level.seek.data.useful.filter.match"},
     {BLOCK_CHECKSUM_COMPUTE_COUNT, "rocksdb.block.checksum.compute.count"},
+    {BLOCK_CHECKSUM_MISMATCH_COUNT, "rocksdb.block.checksum.mismatch.count"},
     {MULTIGET_COROUTINE_COUNT, "rocksdb.multiget.coroutine.count"},
     {BLOB_DB_CACHE_MISS, "rocksdb.blobdb.cache.miss"},
     {BLOB_DB_CACHE_HIT, "rocksdb.blobdb.cache.hit"},
@@ -219,6 +237,19 @@ const std::vector<std::pair<Tickers, std::string>> TickersNameMap = {
     {SECONDARY_CACHE_DATA_HITS, "rocksdb.secondary.cache.data.hits"},
     {TABLE_OPEN_PREFETCH_TAIL_MISS, "rocksdb.table.open.prefetch.tail.miss"},
     {TABLE_OPEN_PREFETCH_TAIL_HIT, "rocksdb.table.open.prefetch.tail.hit"},
+    {TIMESTAMP_FILTER_TABLE_CHECKED, "rocksdb.timestamp.filter.table.checked"},
+    {TIMESTAMP_FILTER_TABLE_FILTERED,
+     "rocksdb.timestamp.filter.table.filtered"},
+    {BYTES_COMPRESSED_FROM, "rocksdb.bytes.compressed.from"},
+    {BYTES_COMPRESSED_TO, "rocksdb.bytes.compressed.to"},
+    {BYTES_COMPRESSION_BYPASSED, "rocksdb.bytes.compression_bypassed"},
+    {BYTES_COMPRESSION_REJECTED, "rocksdb.bytes.compression.rejected"},
+    {NUMBER_BLOCK_COMPRESSION_BYPASSED,
+     "rocksdb.number.block_compression_bypassed"},
+    {NUMBER_BLOCK_COMPRESSION_REJECTED,
+     "rocksdb.number.block_compression_rejected"},
+    {BYTES_DECOMPRESSED_FROM, "rocksdb.bytes.decompressed.from"},
+    {BYTES_DECOMPRESSED_TO, "rocksdb.bytes.decompressed.to"},
 };
 
 const std::vector<std::pair<Histograms, std::string>> HistogramsNameMap = {
@@ -240,6 +271,9 @@ const std::vector<std::pair<Histograms, std::string>> HistogramsNameMap = {
     {DB_SEEK, "rocksdb.db.seek.micros"},
     {WRITE_STALL, "rocksdb.db.write.stall"},
     {SST_READ_MICROS, "rocksdb.sst.read.micros"},
+    {FILE_READ_FLUSH_MICROS, "rocksdb.file.read.flush.micros"},
+    {FILE_READ_COMPACTION_MICROS, "rocksdb.file.read.compaction.micros"},
+    {FILE_READ_DB_OPEN_MICROS, "rocksdb.file.read.db.open.micros"},
     {NUM_SUBCOMPACTIONS_SCHEDULED, "rocksdb.num.subcompactions.scheduled"},
     {BYTES_PER_READ, "rocksdb.bytes.per.read"},
     {BYTES_PER_WRITE, "rocksdb.bytes.per.write"},

package/deps/rocksdb/rocksdb/monitoring/thread_status_updater.cc

@@ -47,15 +47,19 @@ void ThreadStatusUpdater::ResetThreadStatus() {
   SetColumnFamilyInfoKey(nullptr);
 }
 
+void ThreadStatusUpdater::SetEnableTracking(bool enable_tracking) {
+  auto* data = Get();
+  if (data == nullptr) {
+    return;
+  }
+  data->enable_tracking.store(enable_tracking, std::memory_order_relaxed);
+}
+
 void ThreadStatusUpdater::SetColumnFamilyInfoKey(const void* cf_key) {
   auto* data = Get();
   if (data == nullptr) {
     return;
   }
-  // set the tracking flag based on whether cf_key is non-null or not.
-  // If enable_thread_tracking is set to false, the input cf_key
-  // would be nullptr.
-  data->enable_tracking = (cf_key != nullptr);
   data->cf_key.store(const_cast<void*>(cf_key), std::memory_order_relaxed);
 }
 
@@ -86,6 +90,14 @@ void ThreadStatusUpdater::SetThreadOperation(
   }
 }
 
+ThreadStatus::OperationType ThreadStatusUpdater::GetThreadOperation() {
+  ThreadStatusData* data = GetLocalThreadStatus();
+  if (data == nullptr) {
+    return ThreadStatus::OperationType::OP_UNKNOWN;
+  }
+  return data->operation_type.load(std::memory_order_relaxed);
+}
+
 void ThreadStatusUpdater::SetThreadOperationProperty(int i, uint64_t value) {
   auto* data = GetLocalThreadStatus();
   if (data == nullptr) {
@@ -211,9 +223,7 @@ ThreadStatusData* ThreadStatusUpdater::GetLocalThreadStatus() {
   if (thread_status_data_ == nullptr) {
     return nullptr;
   }
-  if (!thread_status_data_->enable_tracking) {
-    assert(thread_status_data_->cf_key.load(std::memory_order_relaxed) ==
-           nullptr);
+  if (!thread_status_data_->enable_tracking.load(std::memory_order_relaxed)) {
     return nullptr;
   }
   return thread_status_data_;

package/deps/rocksdb/rocksdb/monitoring/thread_status_updater.h

@@ -62,7 +62,8 @@ struct ConstantColumnFamilyInfo {
 // status of a thread using a set of atomic pointers.
 struct ThreadStatusData {
 #ifdef ROCKSDB_USING_THREAD_STATUS
-  explicit ThreadStatusData() : enable_tracking(false) {
+  explicit ThreadStatusData() {
+    enable_tracking.store(false);
     thread_id.store(0);
     thread_type.store(ThreadStatus::USER);
     cf_key.store(nullptr);
@@ -72,13 +73,10 @@ struct ThreadStatusData {
   }
 
   // A flag to indicate whether the thread tracking is enabled
-  // in the current thread.  This value will be updated based on whether
-  // the associated Options::enable_thread_tracking is set to true
-  // in ThreadStatusUtil::SetColumnFamily().
-  //
+  // in the current thread.
   // If set to false, then SetThreadOperation and SetThreadState
   // will be no-op.
-  bool enable_tracking;
+  std::atomic<bool> enable_tracking;
 
   std::atomic<uint64_t> thread_id;
   std::atomic<ThreadStatus::ThreadType> thread_type;
@@ -119,8 +117,10 @@ class ThreadStatusUpdater {
   // Register the current thread for tracking.
   void RegisterThread(ThreadStatus::ThreadType ttype, uint64_t thread_id);
 
+  void SetEnableTracking(bool enable_tracking);
+
   // Update the column-family info of the current thread by setting
-  // its thread-local pointer of ThreadStateInfo to the correct entry.
+  // its thread-local pointer of ThreadStatusData to the correct entry.
   void SetColumnFamilyInfoKey(const void* cf_key);
 
   // returns the column family info key.
@@ -129,6 +129,9 @@ class ThreadStatusUpdater {
   // Update the thread operation of the current thread.
   void SetThreadOperation(const ThreadStatus::OperationType type);
 
+  // Return the thread operation of the current thread.
+  ThreadStatus::OperationType GetThreadOperation();
+
   // The start time of the current thread operation.  It is in the format
   // of micro-seconds since some fixed point in time.
   void SetOperationStartTime(const uint64_t start_time);

package/deps/rocksdb/rocksdb/monitoring/thread_status_util.cc

@@ -33,27 +33,23 @@ void ThreadStatusUtil::UnregisterThread() {
   }
 }
 
-void ThreadStatusUtil::SetColumnFamily(const ColumnFamilyData* cfd,
-                                       const Env* env,
-                                       bool enable_thread_tracking) {
-  if (!MaybeInitThreadLocalUpdater(env)) {
+void ThreadStatusUtil::SetEnableTracking(bool enable_tracking) {
+  if (thread_updater_local_cache_ == nullptr) {
     return;
   }
-  assert(thread_updater_local_cache_);
-  if (cfd != nullptr && enable_thread_tracking) {
-    thread_updater_local_cache_->SetColumnFamilyInfoKey(cfd);
-  } else {
-    // When cfd == nullptr or enable_thread_tracking == false, we set
-    // ColumnFamilyInfoKey to nullptr, which makes SetThreadOperation
-    // and SetThreadState become no-op.
-    thread_updater_local_cache_->SetColumnFamilyInfoKey(nullptr);
+  thread_updater_local_cache_->SetEnableTracking(enable_tracking);
+}
+
+void ThreadStatusUtil::SetColumnFamily(const ColumnFamilyData* cfd) {
+  if (thread_updater_local_cache_ == nullptr) {
+    return;
   }
+  assert(cfd);
+  thread_updater_local_cache_->SetColumnFamilyInfoKey(cfd);
 }
 
 void ThreadStatusUtil::SetThreadOperation(ThreadStatus::OperationType op) {
   if (thread_updater_local_cache_ == nullptr) {
-    // thread_updater_local_cache_ must be set in SetColumnFamily
-    // or other ThreadStatusUtil functions.
     return;
   }
 
@@ -68,6 +64,13 @@ void ThreadStatusUtil::SetThreadOperation(ThreadStatus::OperationType op) {
   thread_updater_local_cache_->SetThreadOperation(op);
 }
 
+ThreadStatus::OperationType ThreadStatusUtil::GetThreadOperation() {
+  if (thread_updater_local_cache_ == nullptr) {
+    return ThreadStatus::OperationType::OP_UNKNOWN;
+  }
+  return thread_updater_local_cache_->GetThreadOperation();
+}
+
 ThreadStatus::OperationStage ThreadStatusUtil::SetThreadOperationStage(
     ThreadStatus::OperationStage stage) {
   if (thread_updater_local_cache_ == nullptr) {
@@ -172,9 +175,7 @@ bool ThreadStatusUtil::MaybeInitThreadLocalUpdater(const Env* /*env*/) {
   return false;
 }
 
-void ThreadStatusUtil::SetColumnFamily(const ColumnFamilyData* /*cfd*/,
-                                       const Env* /*env*/,
-                                       bool /*enable_thread_tracking*/) {}
+void ThreadStatusUtil::SetColumnFamily(const ColumnFamilyData* /*cfd*/) {}
 
 void ThreadStatusUtil::SetThreadOperation(ThreadStatus::OperationType /*op*/) {}
 
@@ -189,7 +190,7 @@ void ThreadStatusUtil::SetThreadState(ThreadStatus::StateType /*state*/) {}
 void ThreadStatusUtil::NewColumnFamilyInfo(const DB* /*db*/,
                                            const ColumnFamilyData* /*cfd*/,
                                            const std::string& /*cf_name*/,
-                                           const Env* /*env*/) {}
+                                           const Env* env) {}
 
 void ThreadStatusUtil::EraseColumnFamilyInfo(const ColumnFamilyData* /*cfd*/) {}
 

package/deps/rocksdb/rocksdb/monitoring/thread_status_util.h

@@ -52,13 +52,18 @@ class ThreadStatusUtil {
   // the current thread does not hold db_mutex.
   static void EraseDatabaseInfo(const DB* db);
 
+  static void SetEnableTracking(bool enable_tracking);
+
   // Update the thread status to indicate the current thread is doing
   // something related to the specified column family.
-  static void SetColumnFamily(const ColumnFamilyData* cfd, const Env* env,
-                              bool enable_thread_tracking);
+  //
+  // REQUIRES: cfd != nullptr
+  static void SetColumnFamily(const ColumnFamilyData* cfd);
 
   static void SetThreadOperation(ThreadStatus::OperationType type);
 
+  static ThreadStatus::OperationType GetThreadOperation();
+
   static ThreadStatus::OperationStage SetThreadOperationStage(
       ThreadStatus::OperationStage stage);
 
@@ -74,6 +79,9 @@ class ThreadStatusUtil {
   static void TEST_SetStateDelay(const ThreadStatus::StateType state,
                                  int micro);
   static void TEST_StateDelay(const ThreadStatus::StateType state);
+
+  static Env::IOActivity TEST_GetExpectedIOActivity(
+      ThreadStatus::OperationType thread_op);
 #endif
 
  protected:

package/deps/rocksdb/rocksdb/monitoring/thread_status_util_debug.cc

@@ -27,6 +27,20 @@ void ThreadStatusUtil::TEST_StateDelay(const ThreadStatus::StateType state) {
   }
 }
 
+Env::IOActivity ThreadStatusUtil::TEST_GetExpectedIOActivity(
+    ThreadStatus::OperationType thread_op) {
+  switch (thread_op) {
+    case ThreadStatus::OperationType::OP_FLUSH:
+      return Env::IOActivity::kFlush;
+    case ThreadStatus::OperationType::OP_COMPACTION:
+      return Env::IOActivity::kCompaction;
+    case ThreadStatus::OperationType::OP_DBOPEN:
+      return Env::IOActivity::kDBOpen;
+    default:
+      return Env::IOActivity::kUnknown;
+  }
+}
+
 #endif  // !NDEBUG
 
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -147,6 +147,10 @@ static std::unordered_map<std::string, OptionTypeInfo>
         {"strategy",
          {offsetof(struct CompressionOptions, strategy), OptionType::kInt,
           OptionVerificationType::kNormal, OptionTypeFlags::kMutable}},
+        {"max_compressed_bytes_per_kb",
+         {offsetof(struct CompressionOptions, max_compressed_bytes_per_kb),
+          OptionType::kInt, OptionVerificationType::kNormal,
+          OptionTypeFlags::kMutable}},
         {"max_dict_bytes",
          {offsetof(struct CompressionOptions, max_dict_bytes), OptionType::kInt,
           OptionVerificationType::kNormal, OptionTypeFlags::kMutable}},
@@ -171,6 +175,17 @@ static std::unordered_map<std::string, OptionTypeInfo>
           OptionTypeFlags::kMutable}},
 };
 
+static std::unordered_map<std::string, OptionTypeInfo>
+    file_temperature_age_type_info = {
+        {"temperature",
+         {offsetof(struct FileTemperatureAge, temperature),
+          OptionType::kTemperature, OptionVerificationType::kNormal,
+          OptionTypeFlags::kMutable}},
+        {"age",
+         {offsetof(struct FileTemperatureAge, age), OptionType::kUInt64T,
+          OptionVerificationType::kNormal, OptionTypeFlags::kMutable}},
+};
+
 static std::unordered_map<std::string, OptionTypeInfo>
     fifo_compaction_options_type_info = {
         {"max_table_files_size",
@@ -188,7 +203,15 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct CompactionOptionsFIFO, allow_compaction),
           OptionType::kBoolean, OptionVerificationType::kNormal,
           OptionTypeFlags::kMutable}},
-};
+        {"file_temperature_age_thresholds",
+         OptionTypeInfo::Vector<struct FileTemperatureAge>(
+             offsetof(struct CompactionOptionsFIFO,
+                      file_temperature_age_thresholds),
+             OptionVerificationType::kNormal, OptionTypeFlags::kMutable,
+             OptionTypeInfo::Struct("file_temperature_age_thresholds",
+                                    &file_temperature_age_type_info, 0,
+                                    OptionVerificationType::kNormal,
+                                    OptionTypeFlags::kMutable))}};
 
 static std::unordered_map<std::string, OptionTypeInfo>
     universal_compaction_options_type_info = {
@@ -484,6 +507,10 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct MutableCFOptions, memtable_protection_bytes_per_key),
           OptionType::kUInt32T, OptionVerificationType::kNormal,
           OptionTypeFlags::kMutable}},
+        {"block_protection_bytes_per_key",
+         {offsetof(struct MutableCFOptions, block_protection_bytes_per_key),
+          OptionType::kUInt8T, OptionVerificationType::kNormal,
+          OptionTypeFlags::kMutable}},
         {kOptNameCompOpts,
          OptionTypeInfo::Struct(
              kOptNameCompOpts, &compression_options_type_info,
@@ -775,6 +802,10 @@ static std::unordered_map<std::string, OptionTypeInfo>
             auto* cache = static_cast<std::shared_ptr<Cache>*>(addr);
             return Cache::CreateFromString(opts, value, cache);
           }}},
+        {"persist_user_defined_timestamps",
+         {offsetof(struct ImmutableCFOptions, persist_user_defined_timestamps),
+          OptionType::kBoolean, OptionVerificationType::kNormal,
+          OptionTypeFlags::kCompareLoose}},
 };
 
 const std::string OptionsHelper::kCFOptionsName = "ColumnFamilyOptions";
@@ -918,7 +949,9 @@ ImmutableCFOptions::ImmutableCFOptions(const ColumnFamilyOptions& cf_options)
       cf_paths(cf_options.cf_paths),
       compaction_thread_limiter(cf_options.compaction_thread_limiter),
       sst_partitioner_factory(cf_options.sst_partitioner_factory),
-      blob_cache(cf_options.blob_cache) {}
+      blob_cache(cf_options.blob_cache),
+      persist_user_defined_timestamps(
+          cf_options.persist_user_defined_timestamps) {}
 
 ImmutableOptions::ImmutableOptions() : ImmutableOptions(Options()) {}
 

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

@@ -86,6 +86,8 @@ struct ImmutableCFOptions {
   std::shared_ptr<SstPartitionerFactory> sst_partitioner_factory;
 
   std::shared_ptr<Cache> blob_cache;
+
+  bool persist_user_defined_timestamps;
 };
 
 struct ImmutableOptions : public ImmutableDBOptions, public ImmutableCFOptions {
@@ -170,6 +172,7 @@ struct MutableCFOptions {
                                    : options.last_level_temperature),
         memtable_protection_bytes_per_key(
             options.memtable_protection_bytes_per_key),
+        block_protection_bytes_per_key(options.block_protection_bytes_per_key),
         sample_for_compression(
             options.sample_for_compression),  // TODO: is 0 fine here?
         compression_per_level(options.compression_per_level) {
@@ -220,6 +223,7 @@ struct MutableCFOptions {
         bottommost_compression(kDisableCompressionOption),
         last_level_temperature(Temperature::kUnknown),
         memtable_protection_bytes_per_key(0),
+        block_protection_bytes_per_key(0),
         sample_for_compression(0) {}
 
   explicit MutableCFOptions(const Options& options);
@@ -310,6 +314,7 @@ struct MutableCFOptions {
   CompressionOptions bottommost_compression_opts;
   Temperature last_level_temperature;
   uint32_t memtable_protection_bytes_per_key;
+  uint8_t block_protection_bytes_per_key;
 
   uint64_t sample_for_compression;
   std::vector<CompressionType> compression_per_level;

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

@@ -35,7 +35,7 @@
 #include "rocksdb/utilities/object_registry.h"
 #include "rocksdb/utilities/options_type.h"
 #include "table/block_based/filter_policy_internal.h"
-#include "table/block_based/flush_block_policy.h"
+#include "table/block_based/flush_block_policy_impl.h"
 #include "table/mock_table.h"
 #include "test_util/mock_time_env.h"
 #include "test_util/testharness.h"

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

@@ -13,7 +13,7 @@
 #include <limits>
 
 #include "logging/logging.h"
-#include "monitoring/statistics.h"
+#include "monitoring/statistics_impl.h"
 #include "options/db_options.h"
 #include "options/options_helper.h"
 #include "rocksdb/cache.h"
@@ -109,7 +109,8 @@ AdvancedColumnFamilyOptions::AdvancedColumnFamilyOptions(const Options& options)
       blob_compaction_readahead_size(options.blob_compaction_readahead_size),
       blob_file_starting_level(options.blob_file_starting_level),
       blob_cache(options.blob_cache),
-      prepopulate_blob_cache(options.prepopulate_blob_cache) {
+      prepopulate_blob_cache(options.prepopulate_blob_cache),
+      persist_user_defined_timestamps(options.persist_user_defined_timestamps) {
   assert(memtable_factory.get() != nullptr);
   if (max_bytes_for_level_multiplier_additional.size() <
       static_cast<unsigned int>(num_levels)) {
@@ -137,6 +138,11 @@ void DBOptions::Dump(Logger* log) const {
 void ColumnFamilyOptions::Dump(Logger* log) const {
   ROCKS_LOG_HEADER(log, "              Options.comparator: %s",
                    comparator->Name());
+  if (comparator->timestamp_size() > 0) {
+    ROCKS_LOG_HEADER(
+        log, "              Options.persist_user_defined_timestamps: %s",
+        persist_user_defined_timestamps ? "true" : "false");
+  }
   ROCKS_LOG_HEADER(log, "          Options.merge_operator: %s",
                    merge_operator ? merge_operator->Name() : "None");
   ROCKS_LOG_HEADER(log, "       Options.compaction_filter: %s",
@@ -677,57 +683,10 @@ DBOptions* DBOptions::IncreaseParallelism(int total_threads) {
   return this;
 }
 
+ReadOptions::ReadOptions(bool _verify_checksums, bool _fill_cache)
+    : verify_checksums(_verify_checksums), fill_cache(_fill_cache) {}
 
-ReadOptions::ReadOptions()
-    : snapshot(nullptr),
-      iterate_lower_bound(nullptr),
-      iterate_upper_bound(nullptr),
-      readahead_size(0),
-      max_skippable_internal_keys(0),
-      read_tier(kReadAllTier),
-      verify_checksums(true),
-      fill_cache(true),
-      tailing(false),
-      managed(false),
-      total_order_seek(false),
-      auto_prefix_mode(false),
-      prefix_same_as_start(false),
-      pin_data(false),
-      background_purge_on_iterator_cleanup(false),
-      ignore_range_deletions(false),
-      timestamp(nullptr),
-      iter_start_ts(nullptr),
-      deadline(std::chrono::microseconds::zero()),
-      io_timeout(std::chrono::microseconds::zero()),
-      value_size_soft_limit(std::numeric_limits<uint64_t>::max()),
-      adaptive_readahead(false),
-      async_io(false),
-      optimize_multiget_for_io(true) {}
-
-ReadOptions::ReadOptions(bool cksum, bool cache)
-    : snapshot(nullptr),
-      iterate_lower_bound(nullptr),
-      iterate_upper_bound(nullptr),
-      readahead_size(0),
-      max_skippable_internal_keys(0),
-      read_tier(kReadAllTier),
-      verify_checksums(cksum),
-      fill_cache(cache),
-      tailing(false),
-      managed(false),
-      total_order_seek(false),
-      auto_prefix_mode(false),
-      prefix_same_as_start(false),
-      pin_data(false),
-      background_purge_on_iterator_cleanup(false),
-      ignore_range_deletions(false),
-      timestamp(nullptr),
-      iter_start_ts(nullptr),
-      deadline(std::chrono::microseconds::zero()),
-      io_timeout(std::chrono::microseconds::zero()),
-      value_size_soft_limit(std::numeric_limits<uint64_t>::max()),
-      adaptive_readahead(false),
-      async_io(false),
-      optimize_multiget_for_io(true) {}
+ReadOptions::ReadOptions(Env::IOActivity _io_activity)
+    : io_activity(_io_activity) {}
 
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -206,6 +206,8 @@ void UpdateColumnFamilyOptions(const MutableCFOptions& moptions,
       moptions.experimental_mempurge_threshold;
   cf_opts->memtable_protection_bytes_per_key =
       moptions.memtable_protection_bytes_per_key;
+  cf_opts->block_protection_bytes_per_key =
+      moptions.block_protection_bytes_per_key;
 
   // Compaction related options
   cf_opts->disable_auto_compactions = moptions.disable_auto_compactions;
@@ -308,6 +310,8 @@ void UpdateColumnFamilyOptions(const ImmutableCFOptions& ioptions,
       ioptions.preclude_last_level_data_seconds;
   cf_opts->preserve_internal_time_seconds =
       ioptions.preserve_internal_time_seconds;
+  cf_opts->persist_user_defined_timestamps =
+      ioptions.persist_user_defined_timestamps;
 
   // TODO(yhchiang): find some way to handle the following derived options
   // * max_file_size

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

@@ -75,6 +75,7 @@ Status PersistRocksDBOptions(const ConfigOptions& config_options_in,
   std::unique_ptr<WritableFileWriter> writable;
   writable.reset(new WritableFileWriter(std::move(wf), file_name, EnvOptions(),
                                         nullptr /* statistics */));
+  TEST_SYNC_POINT("PersistRocksDBOptions:create");
 
   std::string options_file_content;
 
@@ -135,6 +136,7 @@ Status PersistRocksDBOptions(const ConfigOptions& config_options_in,
   if (s.ok()) {
     s = writable->Close();
   }
+  TEST_SYNC_POINT("PersistRocksDBOptions:written");
   if (s.ok()) {
     return RocksDBOptionsParser::VerifyRocksDBOptionsFromFile(
         config_options, db_opt, cf_names, cf_opts, file_name, fs);
@@ -679,6 +681,15 @@ Status RocksDBOptionsParser::VerifyCFOptions(
     Status s = base_config->GetOption(config_options, mismatch, &base_value);
     if (s.ok()) {
       s = file_config->GetOption(config_options, mismatch, &file_value);
+      // In file_opt, certain options like MergeOperator may be nullptr due to
+      //   factor methods not available. So we use opt_map to get
+      //   option value to use in the error message below.
+      if (s.ok() && file_value == kNullptrString && opt_map) {
+        auto const& opt_val_str = (opt_map->find(mismatch));
+        if (opt_val_str != opt_map->end()) {
+          file_value = opt_val_str->second;
+        }
+      }
     }
     int offset = snprintf(buffer, sizeof(buffer),
                           "[RocksDBOptionsParser]: "

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

@@ -400,6 +400,8 @@ TEST_F(OptionsSettableTest, ColumnFamilyOptionsAllFieldsSettable) {
       {offsetof(struct ColumnFamilyOptions,
                 max_bytes_for_level_multiplier_additional),
        sizeof(std::vector<int>)},
+      {offsetof(struct ColumnFamilyOptions, compaction_options_fifo),
+       sizeof(struct CompactionOptionsFIFO)},
       {offsetof(struct ColumnFamilyOptions, memtable_factory),
        sizeof(std::shared_ptr<MemTableRepFactory>)},
       {offsetof(struct ColumnFamilyOptions,
@@ -497,8 +499,13 @@ TEST_F(OptionsSettableTest, ColumnFamilyOptionsAllFieldsSettable) {
       "max_bytes_for_level_multiplier=60;"
       "memtable_factory=SkipListFactory;"
       "compression=kNoCompression;"
-      "compression_opts=5:6:7:8:9:10:true:11:false;"
-      "bottommost_compression_opts=4:5:6:7:8:9:true:10:true;"
+      "compression_opts={max_dict_buffer_bytes=5;use_zstd_dict_trainer=true;"
+      "enabled=false;parallel_threads=6;zstd_max_train_bytes=7;strategy=8;max_"
+      "dict_bytes=9;level=10;window_bits=11;max_compressed_bytes_per_kb=987;};"
+      "bottommost_compression_opts={max_dict_buffer_bytes=4;use_zstd_dict_"
+      "trainer=true;enabled=true;parallel_threads=5;zstd_max_train_bytes=6;"
+      "strategy=7;max_dict_bytes=8;level=9;window_bits=10;max_compressed_bytes_"
+      "per_kb=876;};"
       "bottommost_compression=kDisableCompressionOption;"
       "level0_stop_writes_trigger=33;"
       "num_levels=99;"
@@ -544,9 +551,12 @@ TEST_F(OptionsSettableTest, ColumnFamilyOptionsAllFieldsSettable) {
       "preclude_last_level_data_seconds=86400;"
       "preserve_internal_time_seconds=86400;"
       "compaction_options_fifo={max_table_files_size=3;allow_"
-      "compaction=false;age_for_warm=1;};"
+      "compaction=true;age_for_warm=0;file_temperature_age_thresholds={{"
+      "temperature=kCold;age=12345}};};"
       "blob_cache=1M;"
-      "memtable_protection_bytes_per_key=2;",
+      "memtable_protection_bytes_per_key=2;"
+      "persist_user_defined_timestamps=true;"
+      "block_protection_bytes_per_key=1;",
       new_options));
 
   ASSERT_NE(new_options->blob_cache.get(), nullptr);
@@ -555,6 +565,22 @@ TEST_F(OptionsSettableTest, ColumnFamilyOptionsAllFieldsSettable) {
             NumUnsetBytes(new_options_ptr, sizeof(ColumnFamilyOptions),
                           kColumnFamilyOptionsExcluded));
 
+  // Custom verification since compaction_options_fifo was in
+  // kColumnFamilyOptionsExcluded
+  ASSERT_EQ(new_options->compaction_options_fifo.max_table_files_size, 3);
+  ASSERT_EQ(new_options->compaction_options_fifo.allow_compaction, true);
+  ASSERT_EQ(new_options->compaction_options_fifo.file_temperature_age_thresholds
+                .size(),
+            1);
+  ASSERT_EQ(
+      new_options->compaction_options_fifo.file_temperature_age_thresholds[0]
+          .temperature,
+      Temperature::kCold);
+  ASSERT_EQ(
+      new_options->compaction_options_fifo.file_temperature_age_thresholds[0]
+          .age,
+      12345);
+
   ColumnFamilyOptions rnd_filled_options = *new_options;
 
   options->~ColumnFamilyOptions();
@@ -571,6 +597,8 @@ TEST_F(OptionsSettableTest, ColumnFamilyOptionsAllFieldsSettable) {
       {offsetof(struct MutableCFOptions,
                 max_bytes_for_level_multiplier_additional),
        sizeof(std::vector<int>)},
+      {offsetof(struct MutableCFOptions, compaction_options_fifo),
+       sizeof(struct CompactionOptionsFIFO)},
       {offsetof(struct MutableCFOptions, compression_per_level),
        sizeof(std::vector<CompressionType>)},
       {offsetof(struct MutableCFOptions, max_file_size),