@nxtedition/rocksdb 8.2.7 → 9.0.0

package/deps/rocksdb/rocksdb/util/mutexlock.h

@@ -12,10 +12,13 @@
 
 #include <atomic>
 #include <functional>
+#include <memory>
 #include <mutex>
 #include <thread>
 
 #include "port/port.h"
+#include "util/fastrange.h"
+#include "util/hash.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -129,10 +132,25 @@ class SpinMutex {
   std::atomic<bool> locked_;
 };
 
-// We want to prevent false sharing
+// For preventing false sharing, especially for mutexes.
+// NOTE: if a mutex is less than half the size of a cache line, it would
+// make more sense for Striped structure below to pack more than one mutex
+// into each cache line, as this would only reduce contention for the same
+// amount of space and cache sharing. However, a mutex is often 40 bytes out
+// of a 64 byte cache line.
 template <class T>
-struct ALIGN_AS(CACHE_LINE_SIZE) LockData {
-  T lock_;
+struct ALIGN_AS(CACHE_LINE_SIZE) CacheAlignedWrapper {
+  T obj_;
+};
+template <class T>
+struct Unwrap {
+  using type = T;
+  static type &Go(T &t) { return t; }
+};
+template <class T>
+struct Unwrap<CacheAlignedWrapper<T>> {
+  using type = T;
+  static type &Go(CacheAlignedWrapper<T> &t) { return t.obj_; }
 };
 
 //
@@ -144,38 +162,28 @@ struct ALIGN_AS(CACHE_LINE_SIZE) LockData {
 // single lock and allowing independent operations to lock different stripes and
 // proceed concurrently, instead of creating contention for a single lock.
 //
-template <class T, class P>
+template <class T, class Key = Slice, class Hash = SliceNPHasher64>
 class Striped {
  public:
-  Striped(size_t stripes, std::function<uint64_t(const P &)> hash)
-      : stripes_(stripes), hash_(hash) {
-    locks_ = reinterpret_cast<LockData<T> *>(
-        port::cacheline_aligned_alloc(sizeof(LockData<T>) * stripes));
-    for (size_t i = 0; i < stripes; i++) {
-      new (&locks_[i]) LockData<T>();
-    }
-  }
+  explicit Striped(size_t stripe_count)
+      : stripe_count_(stripe_count), data_(new T[stripe_count]) {}
 
-  virtual ~Striped() {
-    if (locks_ != nullptr) {
-      assert(stripes_ > 0);
-      for (size_t i = 0; i < stripes_; i++) {
-        locks_[i].~LockData<T>();
-      }
-      port::cacheline_aligned_free(locks_);
-    }
+  using Unwrapped = typename Unwrap<T>::type;
+  Unwrapped &Get(const Key &key, uint64_t seed = 0) {
+    size_t index = FastRangeGeneric(hash_(key, seed), stripe_count_);
+    return Unwrap<T>::Go(data_[index]);
   }
 
-  T *get(const P &key) {
-    uint64_t h = hash_(key);
-    size_t index = h % stripes_;
-    return &reinterpret_cast<LockData<T> *>(&locks_[index])->lock_;
+  size_t ApproximateMemoryUsage() const {
+    // NOTE: could use malloc_usable_size() here, but that could count unmapped
+    // pages and could mess up unit test OccLockBucketsTest::CacheAligned
+    return sizeof(*this) + stripe_count_ * sizeof(T);
   }
 
  private:
-  size_t stripes_;
-  LockData<T> *locks_;
-  std::function<uint64_t(const P &)> hash_;
+  size_t stripe_count_;
+  std::unique_ptr<T[]> data_;
+  Hash hash_;
 };
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/util/single_thread_executor.h

@@ -8,6 +8,7 @@
 
 #if USE_COROUTINES
 #include <atomic>
+#include <queue>
 
 #include "folly/CPortability.h"
 #include "folly/CppAttributes.h"

package/deps/rocksdb/rocksdb/util/stop_watch.h

@@ -32,7 +32,7 @@ class StopWatch {
         elapsed_(elapsed),
         overwrite_(overwrite),
         stats_enabled_(statistics &&
-                       statistics->get_stats_level() >=
+                       statistics->get_stats_level() >
                            StatsLevel::kExceptTimers &&
                        (hist_type_1_ != Histograms::HISTOGRAM_ENUM_MAX ||
                         hist_type_2_ != Histograms::HISTOGRAM_ENUM_MAX)),

package/deps/rocksdb/rocksdb/util/thread_operation.h

@@ -39,7 +39,14 @@ static OperationInfo global_operation_table[] = {
     {ThreadStatus::OP_UNKNOWN, ""},
     {ThreadStatus::OP_COMPACTION, "Compaction"},
     {ThreadStatus::OP_FLUSH, "Flush"},
-    {ThreadStatus::OP_DBOPEN, "DBOpen"}};
+    {ThreadStatus::OP_DBOPEN, "DBOpen"},
+    {ThreadStatus::OP_GET, "Get"},
+    {ThreadStatus::OP_MULTIGET, "MultiGet"},
+    {ThreadStatus::OP_DBITERATOR, "DBIterator"},
+    {ThreadStatus::OP_VERIFY_DB_CHECKSUM, "VerifyDBChecksum"},
+    {ThreadStatus::OP_VERIFY_FILE_CHECKSUMS, "VerifyFileChecksums"},
+
+};
 
 struct OperationStageInfo {
   const ThreadStatus::OperationStage stage;

package/deps/rocksdb/rocksdb/util/udt_util.cc

@@ -0,0 +1,343 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#include "util/udt_util.h"
+
+#include "db/dbformat.h"
+#include "rocksdb/types.h"
+#include "util/write_batch_util.h"
+
+namespace ROCKSDB_NAMESPACE {
+namespace {
+enum class RecoveryType {
+  kNoop,
+  kUnrecoverable,
+  kStripTimestamp,
+  kPadTimestamp,
+};
+
+RecoveryType GetRecoveryType(const size_t running_ts_sz,
+                             const std::optional<size_t>& recorded_ts_sz) {
+  if (running_ts_sz == 0) {
+    if (!recorded_ts_sz.has_value()) {
+      // A column family id not recorded is equivalent to that column family has
+      // zero timestamp size.
+      return RecoveryType::kNoop;
+    }
+    return RecoveryType::kStripTimestamp;
+  }
+
+  assert(running_ts_sz != 0);
+
+  if (!recorded_ts_sz.has_value()) {
+    return RecoveryType::kPadTimestamp;
+  }
+
+  if (running_ts_sz != *recorded_ts_sz) {
+    return RecoveryType::kUnrecoverable;
+  }
+
+  return RecoveryType::kNoop;
+}
+
+bool AllRunningColumnFamiliesConsistent(
+    const UnorderedMap<uint32_t, size_t>& running_ts_sz,
+    const UnorderedMap<uint32_t, size_t>& record_ts_sz) {
+  for (const auto& [cf_id, ts_sz] : running_ts_sz) {
+    auto record_it = record_ts_sz.find(cf_id);
+    RecoveryType recovery_type =
+        GetRecoveryType(ts_sz, record_it != record_ts_sz.end()
+                                   ? std::optional<size_t>(record_it->second)
+                                   : std::nullopt);
+    if (recovery_type != RecoveryType::kNoop) {
+      return false;
+    }
+  }
+  return true;
+}
+
+Status CheckWriteBatchTimestampSizeConsistency(
+    const WriteBatch* batch,
+    const UnorderedMap<uint32_t, size_t>& running_ts_sz,
+    const UnorderedMap<uint32_t, size_t>& record_ts_sz,
+    TimestampSizeConsistencyMode check_mode, bool* ts_need_recovery) {
+  std::vector<uint32_t> column_family_ids;
+  Status status =
+      CollectColumnFamilyIdsFromWriteBatch(*batch, &column_family_ids);
+  if (!status.ok()) {
+    return status;
+  }
+  for (const auto& cf_id : column_family_ids) {
+    auto running_iter = running_ts_sz.find(cf_id);
+    if (running_iter == running_ts_sz.end()) {
+      // Ignore dropped column family referred to in a WriteBatch regardless of
+      // its consistency.
+      continue;
+    }
+    auto record_iter = record_ts_sz.find(cf_id);
+    RecoveryType recovery_type = GetRecoveryType(
+        running_iter->second, record_iter != record_ts_sz.end()
+                                  ? std::optional<size_t>(record_iter->second)
+                                  : std::nullopt);
+    if (recovery_type != RecoveryType::kNoop) {
+      if (check_mode == TimestampSizeConsistencyMode::kVerifyConsistency) {
+        return Status::InvalidArgument(
+            "WriteBatch contains timestamp size inconsistency.");
+      }
+
+      if (recovery_type == RecoveryType::kUnrecoverable) {
+        return Status::InvalidArgument(
+            "WriteBatch contains unrecoverable timestamp size inconsistency.");
+      }
+
+      // If any column family needs reconciliation, it will mark the whole
+      // WriteBatch to need recovery and rebuilt.
+      *ts_need_recovery = true;
+    }
+  }
+  return Status::OK();
+}
+
+enum class ToggleUDT {
+  kUnchanged,
+  kEnableUDT,
+  kDisableUDT,
+  kInvalidChange,
+};
+
+ToggleUDT CompareComparator(const Comparator* new_comparator,
+                            const std::string& old_comparator_name) {
+  static const char* kUDTSuffix = ".u64ts";
+  static const Slice kSuffixSlice = kUDTSuffix;
+  static const size_t kSuffixSize = 6;
+  size_t ts_sz = new_comparator->timestamp_size();
+  (void)ts_sz;
+  Slice new_ucmp_name(new_comparator->Name());
+  Slice old_ucmp_name(old_comparator_name);
+  if (new_ucmp_name.compare(old_ucmp_name) == 0) {
+    return ToggleUDT::kUnchanged;
+  }
+  if (new_ucmp_name.size() == old_ucmp_name.size() + kSuffixSize &&
+      new_ucmp_name.starts_with(old_ucmp_name) &&
+      new_ucmp_name.ends_with(kSuffixSlice)) {
+    assert(ts_sz == 8);
+    return ToggleUDT::kEnableUDT;
+  }
+  if (old_ucmp_name.size() == new_ucmp_name.size() + kSuffixSize &&
+      old_ucmp_name.starts_with(new_ucmp_name) &&
+      old_ucmp_name.ends_with(kSuffixSlice)) {
+    assert(ts_sz == 0);
+    return ToggleUDT::kDisableUDT;
+  }
+  return ToggleUDT::kInvalidChange;
+}
+}  // namespace
+
+TimestampRecoveryHandler::TimestampRecoveryHandler(
+    const UnorderedMap<uint32_t, size_t>& running_ts_sz,
+    const UnorderedMap<uint32_t, size_t>& record_ts_sz)
+    : running_ts_sz_(running_ts_sz),
+      record_ts_sz_(record_ts_sz),
+      new_batch_(new WriteBatch()),
+      handler_valid_(true),
+      new_batch_diff_from_orig_batch_(false) {}
+
+Status TimestampRecoveryHandler::PutCF(uint32_t cf, const Slice& key,
+                                       const Slice& value) {
+  std::string new_key_buf;
+  Slice new_key;
+  Status status =
+      ReconcileTimestampDiscrepancy(cf, key, &new_key_buf, &new_key);
+  if (!status.ok()) {
+    return status;
+  }
+  return WriteBatchInternal::Put(new_batch_.get(), cf, new_key, value);
+}
+
+Status TimestampRecoveryHandler::DeleteCF(uint32_t cf, const Slice& key) {
+  std::string new_key_buf;
+  Slice new_key;
+  Status status =
+      ReconcileTimestampDiscrepancy(cf, key, &new_key_buf, &new_key);
+  if (!status.ok()) {
+    return status;
+  }
+  return WriteBatchInternal::Delete(new_batch_.get(), cf, new_key);
+}
+
+Status TimestampRecoveryHandler::SingleDeleteCF(uint32_t cf, const Slice& key) {
+  std::string new_key_buf;
+  Slice new_key;
+  Status status =
+      ReconcileTimestampDiscrepancy(cf, key, &new_key_buf, &new_key);
+  if (!status.ok()) {
+    return status;
+  }
+  return WriteBatchInternal::SingleDelete(new_batch_.get(), cf, new_key);
+}
+
+Status TimestampRecoveryHandler::DeleteRangeCF(uint32_t cf,
+                                               const Slice& begin_key,
+                                               const Slice& end_key) {
+  std::string new_begin_key_buf;
+  Slice new_begin_key;
+  std::string new_end_key_buf;
+  Slice new_end_key;
+  Status status = ReconcileTimestampDiscrepancy(
+      cf, begin_key, &new_begin_key_buf, &new_begin_key);
+  if (!status.ok()) {
+    return status;
+  }
+  status = ReconcileTimestampDiscrepancy(cf, end_key, &new_end_key_buf,
+                                         &new_end_key);
+  if (!status.ok()) {
+    return status;
+  }
+  return WriteBatchInternal::DeleteRange(new_batch_.get(), cf, new_begin_key,
+                                         new_end_key);
+}
+
+Status TimestampRecoveryHandler::MergeCF(uint32_t cf, const Slice& key,
+                                         const Slice& value) {
+  std::string new_key_buf;
+  Slice new_key;
+  Status status =
+      ReconcileTimestampDiscrepancy(cf, key, &new_key_buf, &new_key);
+  if (!status.ok()) {
+    return status;
+  }
+  return WriteBatchInternal::Merge(new_batch_.get(), cf, new_key, value);
+}
+
+Status TimestampRecoveryHandler::PutBlobIndexCF(uint32_t cf, const Slice& key,
+                                                const Slice& value) {
+  std::string new_key_buf;
+  Slice new_key;
+  Status status =
+      ReconcileTimestampDiscrepancy(cf, key, &new_key_buf, &new_key);
+  if (!status.ok()) {
+    return status;
+  }
+  return WriteBatchInternal::PutBlobIndex(new_batch_.get(), cf, new_key, value);
+}
+
+Status TimestampRecoveryHandler::ReconcileTimestampDiscrepancy(
+    uint32_t cf, const Slice& key, std::string* new_key_buf, Slice* new_key) {
+  assert(handler_valid_);
+  auto running_iter = running_ts_sz_.find(cf);
+  if (running_iter == running_ts_sz_.end()) {
+    // The column family referred to by the WriteBatch is no longer running.
+    // Copy over the entry as is to the new WriteBatch.
+    *new_key = key;
+    return Status::OK();
+  }
+  size_t running_ts_sz = running_iter->second;
+  auto record_iter = record_ts_sz_.find(cf);
+  std::optional<size_t> record_ts_sz =
+      record_iter != record_ts_sz_.end()
+          ? std::optional<size_t>(record_iter->second)
+          : std::nullopt;
+  RecoveryType recovery_type = GetRecoveryType(running_ts_sz, record_ts_sz);
+
+  switch (recovery_type) {
+    case RecoveryType::kNoop:
+      *new_key = key;
+      break;
+    case RecoveryType::kStripTimestamp:
+      assert(record_ts_sz.has_value());
+      *new_key = StripTimestampFromUserKey(key, *record_ts_sz);
+      new_batch_diff_from_orig_batch_ = true;
+      break;
+    case RecoveryType::kPadTimestamp:
+      AppendKeyWithMinTimestamp(new_key_buf, key, running_ts_sz);
+      *new_key = *new_key_buf;
+      new_batch_diff_from_orig_batch_ = true;
+      break;
+    case RecoveryType::kUnrecoverable:
+      return Status::InvalidArgument(
+          "Unrecoverable timestamp size inconsistency encountered by "
+          "TimestampRecoveryHandler.");
+    default:
+      assert(false);
+  }
+  return Status::OK();
+}
+
+Status HandleWriteBatchTimestampSizeDifference(
+    const WriteBatch* batch,
+    const UnorderedMap<uint32_t, size_t>& running_ts_sz,
+    const UnorderedMap<uint32_t, size_t>& record_ts_sz,
+    TimestampSizeConsistencyMode check_mode,
+    std::unique_ptr<WriteBatch>* new_batch) {
+  // Quick path to bypass checking the WriteBatch.
+  if (AllRunningColumnFamiliesConsistent(running_ts_sz, record_ts_sz)) {
+    return Status::OK();
+  }
+  bool need_recovery = false;
+  Status status = CheckWriteBatchTimestampSizeConsistency(
+      batch, running_ts_sz, record_ts_sz, check_mode, &need_recovery);
+  if (!status.ok()) {
+    return status;
+  } else if (need_recovery) {
+    assert(new_batch);
+    SequenceNumber sequence = WriteBatchInternal::Sequence(batch);
+    TimestampRecoveryHandler recovery_handler(running_ts_sz, record_ts_sz);
+    status = batch->Iterate(&recovery_handler);
+    if (!status.ok()) {
+      return status;
+    } else {
+      *new_batch = recovery_handler.TransferNewBatch();
+      WriteBatchInternal::SetSequence(new_batch->get(), sequence);
+    }
+  }
+  return Status::OK();
+}
+
+Status ValidateUserDefinedTimestampsOptions(
+    const Comparator* new_comparator, const std::string& old_comparator_name,
+    bool new_persist_udt, bool old_persist_udt,
+    bool* mark_sst_files_has_no_udt) {
+  size_t ts_sz = new_comparator->timestamp_size();
+  ToggleUDT res = CompareComparator(new_comparator, old_comparator_name);
+  switch (res) {
+    case ToggleUDT::kUnchanged:
+      if (old_persist_udt == new_persist_udt) {
+        return Status::OK();
+      }
+      if (ts_sz == 0) {
+        return Status::OK();
+      }
+      return Status::InvalidArgument(
+          "Cannot toggle the persist_user_defined_timestamps flag for a column "
+          "family with user-defined timestamps feature enabled.");
+    case ToggleUDT::kEnableUDT:
+      if (!new_persist_udt) {
+        *mark_sst_files_has_no_udt = true;
+        return Status::OK();
+      }
+      return Status::InvalidArgument(
+          "Cannot open a column family and enable user-defined timestamps "
+          "feature without setting persist_user_defined_timestamps flag to "
+          "false.");
+    case ToggleUDT::kDisableUDT:
+      if (!old_persist_udt) {
+        return Status::OK();
+      }
+      return Status::InvalidArgument(
+          "Cannot open a column family and disable user-defined timestamps "
+          "feature if its existing persist_user_defined_timestamps flag is not "
+          "false.");
+    case ToggleUDT::kInvalidChange:
+      return Status::InvalidArgument(
+          new_comparator->Name(),
+          "does not match existing comparator " + old_comparator_name);
+    default:
+      break;
+  }
+  return Status::InvalidArgument(
+      "Unsupported user defined timestamps settings change.");
+}
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/util/udt_util.h

@@ -1,15 +1,22 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//
 //  This source code is licensed under both the GPLv2 (found in the
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
 #pragma once
+#include <memory>
+#include <optional>
 #include <sstream>
+#include <unordered_map>
 #include <vector>
 
+#include "db/write_batch_internal.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/status.h"
+#include "rocksdb/write_batch.h"
 #include "util/coding.h"
+#include "util/hash_containers.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -74,4 +81,169 @@ class UserDefinedTimestampSizeRecord {
   std::vector<std::pair<uint32_t, size_t>> cf_to_ts_sz_;
 };
 
+// This handler is used to recover a WriteBatch read from WAL logs during
+// recovery. It does a best-effort recovery if the column families contained in
+// the WriteBatch have inconsistency between the recorded timestamp size and the
+// running timestamp size. And creates a new WriteBatch that are consistent with
+// the running timestamp size with entries from the original WriteBatch.
+//
+// Note that for a WriteBatch with no inconsistency, a new WriteBatch is created
+// nonetheless, and it should be exactly the same as the original WriteBatch.
+//
+// To access the new WriteBatch, invoke `TransferNewBatch` after calling
+// `Iterate`. The handler becomes invalid afterwards.
+//
+// For the user key in each entry, the best effort recovery means:
+// 1) If recorded timestamp size is 0, running timestamp size is > 0, a min
+// timestamp of length running timestamp size is padded to the user key.
+// 2) If recorded timestamp size is > 0, running timestamp size is 0, the last
+// bytes of length recorded timestamp size is stripped from user key.
+// 3) If recorded timestamp size is the same as running timestamp size, no-op.
+// 4) If recorded timestamp size and running timestamp size are both non-zero
+// but not equal, return Status::InvalidArgument.
+class TimestampRecoveryHandler : public WriteBatch::Handler {
+ public:
+  TimestampRecoveryHandler(const UnorderedMap<uint32_t, size_t>& running_ts_sz,
+                           const UnorderedMap<uint32_t, size_t>& record_ts_sz);
+
+  ~TimestampRecoveryHandler() override {}
+
+  // No copy or move.
+  TimestampRecoveryHandler(const TimestampRecoveryHandler&) = delete;
+  TimestampRecoveryHandler(TimestampRecoveryHandler&&) = delete;
+  TimestampRecoveryHandler& operator=(const TimestampRecoveryHandler&) = delete;
+  TimestampRecoveryHandler& operator=(TimestampRecoveryHandler&&) = delete;
+
+  Status PutCF(uint32_t cf, const Slice& key, const Slice& value) override;
+
+  Status DeleteCF(uint32_t cf, const Slice& key) override;
+
+  Status SingleDeleteCF(uint32_t cf, const Slice& key) override;
+
+  Status DeleteRangeCF(uint32_t cf, const Slice& begin_key,
+                       const Slice& end_key) override;
+
+  Status MergeCF(uint32_t cf, const Slice& key, const Slice& value) override;
+
+  Status PutBlobIndexCF(uint32_t cf, const Slice& key,
+                        const Slice& value) override;
+
+  Status MarkBeginPrepare(bool) override { return Status::OK(); }
+
+  Status MarkEndPrepare(const Slice&) override { return Status::OK(); }
+
+  Status MarkCommit(const Slice&) override { return Status::OK(); }
+
+  Status MarkCommitWithTimestamp(const Slice&, const Slice&) override {
+    return Status::OK();
+  }
+
+  Status MarkRollback(const Slice&) override { return Status::OK(); }
+
+  Status MarkNoop(bool /*empty_batch*/) override { return Status::OK(); }
+
+  std::unique_ptr<WriteBatch>&& TransferNewBatch() {
+    assert(new_batch_diff_from_orig_batch_);
+    handler_valid_ = false;
+    return std::move(new_batch_);
+  }
+
+ private:
+  Status ReconcileTimestampDiscrepancy(uint32_t cf, const Slice& key,
+                                       std::string* new_key_buf,
+                                       Slice* new_key);
+
+  // Mapping from column family id to user-defined timestamp size for all
+  // running column families including the ones with zero timestamp size.
+  const UnorderedMap<uint32_t, size_t>& running_ts_sz_;
+
+  // Mapping from column family id to user-defined timestamp size as recorded
+  // in the WAL. This only contains non-zero user-defined timestamp size.
+  const UnorderedMap<uint32_t, size_t>& record_ts_sz_;
+
+  std::unique_ptr<WriteBatch> new_batch_;
+  // Handler is valid upon creation and becomes invalid after its `new_batch_`
+  // is transferred.
+  bool handler_valid_;
+
+  // False upon creation, and become true if at least one user key from the
+  // original batch is updated when creating the new batch.
+  bool new_batch_diff_from_orig_batch_;
+};
+
+// Mode for checking and handling timestamp size inconsistency encountered in a
+// WriteBatch read from WAL log.
+enum class TimestampSizeConsistencyMode {
+  // Verified that the recorded user-defined timestamp size is consistent with
+  // the running one for all the column families involved in a WriteBatch.
+  // Column families referred to in the WriteBatch but are dropped are ignored.
+  kVerifyConsistency,
+  // Verified that if any inconsistency exists in a WriteBatch, it's all
+  // tolerable by a best-effort reconciliation. And optionally creates a new
+  // WriteBatch from the original WriteBatch that is consistent with the running
+  // timestamp size. Column families referred to in the WriteBatch but are
+  // dropped are ignored. If a new WriteBatch is created, such entries are
+  // copied over as is.
+  kReconcileInconsistency,
+};
+
+// Handles the inconsistency between recorded timestamp sizes and running
+// timestamp sizes for a WriteBatch. A non-OK `status` indicates there are
+// intolerable inconsistency with the specified `check_mode`.
+//
+// If `check_mode` is `kVerifyConsistency`, intolerable inconsistency means any
+// running column family has an inconsistent user-defined timestamp size.
+//
+// If `check_mode` is `kReconcileInconsistency`, intolerable inconsistency means
+// any running column family has an inconsistent user-defined timestamp size
+// that cannot be reconciled with a best-effort recovery. Check
+// `TimestampRecoveryHandler` for what a best-effort recovery is capable of. In
+// this mode, output argument `new_batch` should be set, a new WriteBatch is
+// created on the heap and transferred to `new_batch` if there is tolerable
+// inconsistency.
+//
+// An invariant that WAL logging ensures is that all timestamp size info
+// is logged prior to a WriteBatch that needed this info. And zero timestamp
+// size is skipped. So `record_ts_sz` only contains column family with non-zero
+// timestamp size and a column family id absent from `record_ts_sz` will be
+// interpreted as that column family has zero timestamp size. On the other hand,
+// `running_ts_sz` should contain the timestamp size for all running column
+// families including the ones with zero timestamp size.
+Status HandleWriteBatchTimestampSizeDifference(
+    const WriteBatch* batch,
+    const UnorderedMap<uint32_t, size_t>& running_ts_sz,
+    const UnorderedMap<uint32_t, size_t>& record_ts_sz,
+    TimestampSizeConsistencyMode check_mode,
+    std::unique_ptr<WriteBatch>* new_batch = nullptr);
+
+// This util function is used when opening an existing column family and
+// processing its VersionEdit. It does a sanity check for the column family's
+// old user comparator and the persist_user_defined_timestamps flag as recorded
+// in the VersionEdit, against its new settings from the column family's
+// ImmutableCFOptions.
+//
+// Valid settings change include:
+// 1) no user comparator change and no effective persist_user_defined_timestamp
+// flag change.
+// 2) switch user comparator to enable user-defined timestamps feature provided
+// the immediately effective persist_user_defined_timestamps flag is false.
+// 3) switch user comparator to disable user-defined timestamps feature provided
+// that the before-change persist_user_defined_timestamps is already false.
+//
+// Switch user comparator to disable/enable UDT is only sanity checked by a user
+// comparator name comparison. The full check includes enforcing the new user
+// comparator ranks user keys exactly the same as the old user comparator and
+// only add / remove the user-defined timestamp comparison. We don't have ways
+// to strictly enforce this so currently only the RocksDB builtin comparator
+// wrapper `ComparatorWithU64TsImpl` is  supported to enable / disable
+// user-defined timestamps. It formats user-defined timestamps as uint64_t.
+//
+// When the settings indicate a legit change to enable user-defined timestamps
+// feature on a column family, `mark_sst_files_has_no_udt` will be set to true
+// to indicate marking all existing SST files has no user-defined timestamps
+// when re-writing the manifest.
+Status ValidateUserDefinedTimestampsOptions(
+    const Comparator* new_comparator, const std::string& old_comparator_name,
+    bool new_persist_udt, bool old_persist_udt,
+    bool* mark_sst_files_has_no_udt);
 }  // namespace ROCKSDB_NAMESPACE