@nxtedition/rocksdb 13.5.7 → 13.5.9

package/deps/rocksdb/rocksdb/db/log_writer.cc

@@ -22,7 +22,7 @@ namespace ROCKSDB_NAMESPACE::log {
 
 Writer::Writer(std::unique_ptr<WritableFileWriter>&& dest, uint64_t log_number,
                bool recycle_log_files, bool manual_flush,
-               CompressionType compression_type)
+               CompressionType compression_type, bool track_and_verify_wals)
     : dest_(std::move(dest)),
       block_offset_(0),
       log_number_(log_number),
@@ -31,8 +31,10 @@ Writer::Writer(std::unique_ptr<WritableFileWriter>&& dest, uint64_t log_number,
       header_size_(recycle_log_files ? kRecyclableHeaderSize : kHeaderSize),
       manual_flush_(manual_flush),
       compression_type_(compression_type),
-      compress_(nullptr) {
-  for (int i = 0; i <= kMaxRecordType; i++) {
+      compress_(nullptr),
+      track_and_verify_wals_(track_and_verify_wals),
+      last_seqno_recorded_(0) {
+  for (uint8_t i = 0; i <= kMaxRecordType; i++) {
     char t = static_cast<char>(i);
     type_crc_[i] = crc32c::Value(&t, 1);
   }
@@ -52,19 +54,12 @@ Writer::~Writer() {
 }
 
 IOStatus Writer::WriteBuffer(const WriteOptions& write_options) {
-  if (dest_->seen_error()) {
-#ifndef NDEBUG
-    if (dest_->seen_injected_error()) {
-      std::stringstream msg;
-      msg << "Seen " << FaultInjectionTestFS::kInjected
-          << " error. Skip writing buffer.";
-      return IOStatus::IOError(msg.str());
-    }
-#endif  // NDEBUG
-    return IOStatus::IOError("Seen error. Skip writing buffer.");
+  IOStatus s = MaybeHandleSeenFileWriterError();
+  if (!s.ok()) {
+    return s;
   }
   IOOptions opts;
-  IOStatus s = WritableFileWriter::PrepareIOOptions(write_options, opts);
+  s = WritableFileWriter::PrepareIOOptions(write_options, opts);
   if (!s.ok()) {
     return s;
   }
@@ -92,17 +87,10 @@ bool Writer::PublishIfClosed() {
 }
 
 IOStatus Writer::AddRecord(const WriteOptions& write_options,
-                           const Slice& slice) {
-  if (dest_->seen_error()) {
-#ifndef NDEBUG
-    if (dest_->seen_injected_error()) {
-      std::stringstream msg;
-      msg << "Seen " << FaultInjectionTestFS::kInjected
-          << " error. Skip writing buffer.";
-      return IOStatus::IOError(msg.str());
-    }
-#endif  // NDEBUG
-    return IOStatus::IOError("Seen error. Skip writing buffer.");
+                           const Slice& slice, const SequenceNumber& seqno) {
+  IOStatus s = MaybeHandleSeenFileWriterError();
+  if (!s.ok()) {
+    return s;
   }
   const char* ptr = slice.data();
   size_t left = slice.size();
@@ -118,7 +106,6 @@ IOStatus Writer::AddRecord(const WriteOptions& write_options,
     compress_start = true;
   }
 
-  IOStatus s;
   IOOptions opts;
   s = WritableFileWriter::PrepareIOOptions(write_options, opts);
   if (s.ok()) {
@@ -196,6 +183,10 @@ IOStatus Writer::AddRecord(const WriteOptions& write_options,
     }
   }
 
+  if (s.ok()) {
+    last_seqno_recorded_ = std::max(last_seqno_recorded_, seqno);
+  }
+
   return s;
 }
 
@@ -208,23 +199,16 @@ IOStatus Writer::AddCompressionTypeRecord(const WriteOptions& write_options) {
     return IOStatus::OK();
   }
 
-  if (dest_->seen_error()) {
-#ifndef NDEBUG
-    if (dest_->seen_injected_error()) {
-      std::stringstream msg;
-      msg << "Seen " << FaultInjectionTestFS::kInjected
-          << " error. Skip writing buffer.";
-      return IOStatus::IOError(msg.str());
-    }
-#endif  // NDEBUG
-    return IOStatus::IOError("Seen error. Skip writing buffer.");
+  IOStatus s = MaybeHandleSeenFileWriterError();
+  if (!s.ok()) {
+    return s;
   }
 
   CompressionTypeRecord record(compression_type_);
   std::string encode;
   record.EncodeTo(&encode);
-  IOStatus s = EmitPhysicalRecord(write_options, kSetCompressionType,
-                                  encode.data(), encode.size());
+  s = EmitPhysicalRecord(write_options, kSetCompressionType, encode.data(),
+                         encode.size());
   if (s.ok()) {
     if (!manual_flush_) {
       IOOptions io_opts;
@@ -251,6 +235,44 @@ IOStatus Writer::AddCompressionTypeRecord(const WriteOptions& write_options) {
   return s;
 }
 
+IOStatus Writer::MaybeAddPredecessorWALInfo(const WriteOptions& write_options,
+                                            const PredecessorWALInfo& info) {
+  IOStatus s = MaybeHandleSeenFileWriterError();
+
+  if (!s.ok()) {
+    return s;
+  }
+
+  if (!track_and_verify_wals_ || !info.IsInitialized()) {
+    return IOStatus::OK();
+  }
+
+  std::string encode;
+  info.EncodeTo(&encode);
+
+  s = MaybeSwitchToNewBlock(write_options, encode);
+  if (!s.ok()) {
+    return s;
+  }
+
+  RecordType type = recycle_log_files_ ? kRecyclePredecessorWALInfoType
+                                       : kPredecessorWALInfoType;
+  s = EmitPhysicalRecord(write_options, type, encode.data(), encode.size());
+
+  if (!s.ok()) {
+    return s;
+  }
+
+  if (!manual_flush_) {
+    IOOptions io_opts;
+    s = WritableFileWriter::PrepareIOOptions(write_options, io_opts);
+    if (s.ok()) {
+      s = dest_->Flush(io_opts);
+    }
+  }
+  return s;
+}
+
 IOStatus Writer::MaybeAddUserDefinedTimestampSizeRecord(
     const WriteOptions& write_options,
     const UnorderedMap<uint32_t, size_t>& cf_to_ts_sz) {
@@ -275,22 +297,9 @@ IOStatus Writer::MaybeAddUserDefinedTimestampSizeRecord(
   RecordType type = recycle_log_files_ ? kRecyclableUserDefinedTimestampSizeType
                                        : kUserDefinedTimestampSizeType;
 
-  // If there's not enough space for this record, switch to a new block.
-  const int64_t leftover = kBlockSize - block_offset_;
-  if (leftover < header_size_ + (int)encoded.size()) {
-    IOOptions opts;
-    IOStatus s = WritableFileWriter::PrepareIOOptions(write_options, opts);
-    if (!s.ok()) {
-      return s;
-    }
-
-    std::vector<char> trailer(leftover, '\x00');
-    s = dest_->Append(opts, Slice(trailer.data(), trailer.size()));
-    if (!s.ok()) {
-      return s;
-    }
-
-    block_offset_ = 0;
+  IOStatus s = MaybeSwitchToNewBlock(write_options, encoded);
+  if (!s.ok()) {
+    return s;
   }
 
   return EmitPhysicalRecord(write_options, type, encoded.data(),
@@ -313,7 +322,7 @@ IOStatus Writer::EmitPhysicalRecord(const WriteOptions& write_options,
 
   uint32_t crc = type_crc_[t];
   if (t < kRecyclableFullType || t == kSetCompressionType ||
-      t == kUserDefinedTimestampSizeType) {
+      t == kPredecessorWALInfoType || t == kUserDefinedTimestampSizeType) {
     // Legacy record format
     assert(block_offset_ + kHeaderSize + n <= kBlockSize);
     header_size = kHeaderSize;
@@ -352,4 +361,42 @@ IOStatus Writer::EmitPhysicalRecord(const WriteOptions& write_options,
   return s;
 }
 
+IOStatus Writer::MaybeHandleSeenFileWriterError() {
+  if (dest_->seen_error()) {
+#ifndef NDEBUG
+    if (dest_->seen_injected_error()) {
+      std::stringstream msg;
+      msg << "Seen " << FaultInjectionTestFS::kInjected
+          << " error. Skip writing buffer.";
+      return IOStatus::IOError(msg.str());
+    }
+#endif  // NDEBUG
+    return IOStatus::IOError("Seen error. Skip writing buffer.");
+  }
+  return IOStatus::OK();
+}
+
+IOStatus Writer::MaybeSwitchToNewBlock(const WriteOptions& write_options,
+                                       const std::string& content_to_write) {
+  IOStatus s;
+  const int64_t leftover = kBlockSize - block_offset_;
+  // If there's not enough space for this record, switch to a new block.
+  if (leftover < header_size_ + (int)content_to_write.size()) {
+    IOOptions opts;
+    s = WritableFileWriter::PrepareIOOptions(write_options, opts);
+    if (!s.ok()) {
+      return s;
+    }
+
+    std::vector<char> trailer(leftover, '\x00');
+    s = dest_->Append(opts, Slice(trailer.data(), trailer.size()));
+    if (!s.ok()) {
+      return s;
+    }
+
+    block_offset_ = 0;
+  }
+  return s;
+}
+
 }  // namespace ROCKSDB_NAMESPACE::log

package/deps/rocksdb/rocksdb/db/log_writer.h

@@ -13,6 +13,7 @@
 #include <unordered_map>
 #include <vector>
 
+#include "db/dbformat.h"
 #include "db/log_format.h"
 #include "rocksdb/compression_type.h"
 #include "rocksdb/env.h"
@@ -76,18 +77,24 @@ class Writer {
   // Create a writer that will append data to "*dest".
   // "*dest" must be initially empty.
   // "*dest" must remain live while this Writer is in use.
+  // TODO(hx235): seperate WAL related parameters from general `Reader`
+  // parameters
   explicit Writer(std::unique_ptr<WritableFileWriter>&& dest,
                   uint64_t log_number, bool recycle_log_files,
                   bool manual_flush = false,
-                  CompressionType compressionType = kNoCompression);
+                  CompressionType compressionType = kNoCompression,
+                  bool track_and_verify_wals = false);
   // No copying allowed
   Writer(const Writer&) = delete;
   void operator=(const Writer&) = delete;
 
   ~Writer();
 
-  IOStatus AddRecord(const WriteOptions& write_options, const Slice& slice);
+  IOStatus AddRecord(const WriteOptions& write_options, const Slice& slice,
+                     const SequenceNumber& seqno = 0);
   IOStatus AddCompressionTypeRecord(const WriteOptions& write_options);
+  IOStatus MaybeAddPredecessorWALInfo(const WriteOptions& write_options,
+                                      const PredecessorWALInfo& info);
 
   // If there are column families in `cf_to_ts_sz` not included in
   // `recorded_cf_to_ts_sz_` and its user-defined timestamp size is non-zero,
@@ -116,6 +123,8 @@ class Writer {
 
   size_t TEST_block_offset() const { return block_offset_; }
 
+  SequenceNumber GetLastSeqnoRecorded() const { return last_seqno_recorded_; };
+
  private:
   std::unique_ptr<WritableFileWriter> dest_;
   size_t block_offset_;  // Current offset in block
@@ -131,6 +140,11 @@ class Writer {
   IOStatus EmitPhysicalRecord(const WriteOptions& write_options,
                               RecordType type, const char* ptr, size_t length);
 
+  IOStatus MaybeHandleSeenFileWriterError();
+
+  IOStatus MaybeSwitchToNewBlock(const WriteOptions& write_options,
+                                 const std::string& content_to_write);
+
   // If true, it does not flush after each write. Instead it relies on the upper
   // layer to manually does the flush by calling ::WriteBuffer()
   bool manual_flush_;
@@ -145,6 +159,11 @@ class Writer {
   // Since the user-defined timestamp size cannot be changed while the DB is
   // running, existing entry in this map cannot be updated.
   UnorderedMap<uint32_t, size_t> recorded_cf_to_ts_sz_;
+
+  // See `Options::track_and_verify_wals`
+  bool track_and_verify_wals_;
+
+  SequenceNumber last_seqno_recorded_;
 };
 
 }  // namespace log

package/deps/rocksdb/rocksdb/db/malloc_stats.h

@@ -9,7 +9,6 @@
 
 #pragma once
 
-
 #include <string>
 
 #include "rocksdb/rocksdb_namespace.h"
@@ -19,4 +18,3 @@ namespace ROCKSDB_NAMESPACE {
 void DumpMallocStats(std::string*);
 
 }
-

package/deps/rocksdb/rocksdb/db/memtable.cc

@@ -147,7 +147,6 @@ MemTable::MemTable(const InternalKeyComparator& cmp,
   const Comparator* ucmp = cmp.user_comparator();
   assert(ucmp);
   ts_sz_ = ucmp->timestamp_size();
-  persist_user_defined_timestamps_ = ioptions.persist_user_defined_timestamps;
 }
 
 MemTable::~MemTable() {
@@ -175,6 +174,11 @@ size_t MemTable::ApproximateMemoryUsage() {
 }
 
 bool MemTable::ShouldFlushNow() {
+  if (IsMarkedForFlush()) {
+    // TODO: dedicated flush reason when marked for flush
+    return true;
+  }
+
   // This is set if memtable_max_range_deletions is > 0,
   // and that many range deletions are done
   if (memtable_max_range_deletions_ > 0 &&
@@ -192,10 +196,11 @@ bool MemTable::ShouldFlushNow() {
   // allocate one more block.
   const double kAllowOverAllocationRatio = 0.6;
 
+  // range deletion use skip list which allocates all memeory through `arena_`
+  assert(range_del_table_->ApproximateMemoryUsage() == 0);
   // If arena still have room for new block allocation, we can safely say it
   // shouldn't flush.
   auto allocated_memory = table_->ApproximateMemoryUsage() +
-                          range_del_table_->ApproximateMemoryUsage() +
                           arena_.MemoryAllocatedBytes();
 
   approximate_memory_usage_.store(allocated_memory, std::memory_order_relaxed);
@@ -618,8 +623,8 @@ class TimestampStrippingIterator : public InternalIterator {
       const SliceTransform* cf_prefix_extractor, size_t ts_sz)
       : arena_mode_(arena != nullptr), kind_(kind), ts_sz_(ts_sz) {
     assert(ts_sz_ != 0);
-    void* mem = arena ? arena->AllocateAligned(sizeof(MemTableIterator)) :
-                      operator new(sizeof(MemTableIterator));
+    void* mem = arena ? arena->AllocateAligned(sizeof(MemTableIterator))
+                      : operator new(sizeof(MemTableIterator));
     iter_ = new (mem)
         MemTableIterator(kind, memtable, read_options, seqno_to_time_mapping,
                          arena, cf_prefix_extractor);
@@ -1325,47 +1330,13 @@ static bool SaveValue(void* arg, const char* entry) {
         return false;
       }
       case kTypeMerge: {
-        if (!merge_operator) {
-          *(s->status) = Status::InvalidArgument(
-              "merge_operator is not properly initialized.");
-          // Normally we continue the loop (return true) when we see a merge
-          // operand.  But in case of an error, we should stop the loop
-          // immediately and pretend we have found the value to stop further
-          // seek.  Otherwise, the later call will override this error status.
-          *(s->found_final_value) = true;
-          return false;
-        }
         Slice v = GetLengthPrefixedSlice(key_ptr + key_length);
         *(s->merge_in_progress) = true;
-        merge_context->PushOperand(
-            v, s->inplace_update_support == false /* operand_pinned */);
-        PERF_COUNTER_ADD(internal_merge_point_lookup_count, 1);
-
-        if (s->do_merge && merge_operator->ShouldMerge(
-                               merge_context->GetOperandsDirectionBackward())) {
-          if (s->value || s->columns) {
-            // `op_failure_scope` (an output parameter) is not provided (set to
-            // nullptr) since a failure must be propagated regardless of its
-            // value.
-            *(s->status) = MergeHelper::TimedFullMerge(
-                merge_operator, s->key->user_key(), MergeHelper::kNoBaseValue,
-                merge_context->GetOperands(), s->logger, s->statistics,
-                s->clock, /* update_num_ops_stats */ true,
-                /* op_failure_scope */ nullptr, s->value, s->columns);
-          }
-
-          *(s->found_final_value) = true;
-          return false;
-        }
-        if (merge_context->get_merge_operands_options != nullptr &&
-            merge_context->get_merge_operands_options->continue_cb != nullptr &&
-            !merge_context->get_merge_operands_options->continue_cb(v)) {
-          // We were told not to continue.
-          *(s->found_final_value) = true;
-          return false;
-        }
-
-        return true;
+        *(s->found_final_value) = ReadOnlyMemTable::HandleTypeMerge(
+            s->key->user_key(), v, s->inplace_update_support == false,
+            s->do_merge, merge_context, s->merge_operator, s->clock,
+            s->statistics, s->logger, s->status, s->value, s->columns);
+        return !*(s->found_final_value);
       }
       default: {
         std::string msg("Corrupted value not expected.");
@@ -1835,7 +1806,7 @@ uint64_t MemTable::GetMinLogContainingPrepSection() {
 }
 
 void MemTable::MaybeUpdateNewestUDT(const Slice& user_key) {
-  if (ts_sz_ == 0 || persist_user_defined_timestamps_) {
+  if (ts_sz_ == 0) {
     return;
   }
   const Comparator* ucmp = GetInternalKeyComparator().user_comparator();
@@ -1846,9 +1817,7 @@ void MemTable::MaybeUpdateNewestUDT(const Slice& user_key) {
 }
 
 const Slice& MemTable::GetNewestUDT() const {
-  // This path should not be invoked for MemTables that does not enable the UDT
-  // in Memtable only feature.
-  assert(ts_sz_ > 0 && !persist_user_defined_timestamps_);
+  assert(ts_sz_ > 0);
   return newest_udt_;
 }
 

package/deps/rocksdb/rocksdb/db/memtable.h

@@ -30,6 +30,7 @@
 #include "rocksdb/db.h"
 #include "rocksdb/memtablerep.h"
 #include "table/multiget_context.h"
+#include "util/atomic.h"
 #include "util/cast_util.h"
 #include "util/dynamic_bloom.h"
 #include "util/hash.h"
@@ -186,10 +187,13 @@ class ReadOnlyMemTable {
                                               SequenceNumber read_seq,
                                               size_t ts_sz) = 0;
 
-  // Used to Get value associated with key or Get Merge Operands associated
-  // with key.
-  // Keys are considered if they are no larger than the parameter `key` in
+  // Used to get value associated with `key`, or Merge operands associated
+  // with key, or get the latest sequence number of `key` (e.g. transaction
+  // conflict checking).
+  //
+  // Keys are considered if they are no smaller than the parameter `key` in
   // the order defined by comparator and share the save user key with `key`.
+  //
   // If do_merge = true the default behavior which is Get value for key is
   // executed. Expected behavior is described right below.
   // If memtable contains a value for key, store it in *value and return true.
@@ -207,6 +211,7 @@ class ReadOnlyMemTable {
   // returned).  Otherwise, *seq will be set to kMaxSequenceNumber.
   // On success, *s may be set to OK, NotFound, or MergeInProgress.  Any other
   // status returned indicates a corruption or other unexpected error.
+  //
   // If do_merge = false then any Merge Operands encountered for key are simply
   // stored in merge_context.operands_list and never actually merged to get a
   // final value. The raw Merge Operands are eventually returned to the user.
@@ -215,6 +220,9 @@ class ReadOnlyMemTable {
   // @param column If not null and memtable contains a value/WideColumn for key,
   // `column` will be set to the result value/WideColumn.
   // Note: only one of `value` and `column` can be non-nullptr.
+  // To only query for key existence or the latest sequence number of a key,
+  // `value` and `column` can be both nullptr. In this case, returned status can
+  // be OK, NotFound or MergeInProgress if a key is found.
   // @param immutable_memtable Whether this memtable is immutable. Used
   // internally by NewRangeTombstoneIterator(). See comment above
   // NewRangeTombstoneIterator() for more detail.
@@ -347,13 +355,13 @@ class ReadOnlyMemTable {
   // be flushed to storage
   // REQUIRES: external synchronization to prevent simultaneous
   // operations on the same MemTable.
-  uint64_t GetNextLogNumber() const { return mem_next_logfile_number_; }
+  uint64_t GetNextLogNumber() const { return mem_next_walfile_number_; }
 
   // Sets the next active logfile number when this memtable is about to
   // be flushed to storage
   // REQUIRES: external synchronization to prevent simultaneous
   // operations on the same MemTable.
-  void SetNextLogNumber(uint64_t num) { mem_next_logfile_number_ = num; }
+  void SetNextLogNumber(uint64_t num) { mem_next_walfile_number_ = num; }
 
   // REQUIRES: db_mutex held.
   void SetID(uint64_t id) { id_ = id; }
@@ -394,7 +402,6 @@ class ReadOnlyMemTable {
       // can also be retained.
       merge_context->PushOperand(value, value_pinned);
     } else if (merge_in_progress) {
-      assert(do_merge);
       // `op_failure_scope` (an output parameter) is not provided (set to
       // nullptr) since a failure must be propagated regardless of its
       // value.
@@ -442,6 +449,58 @@ class ReadOnlyMemTable {
     }
   }
 
+  // Returns if a final value is found.
+  static bool HandleTypeMerge(const Slice& lookup_user_key, const Slice& value,
+                              bool value_pinned, bool do_merge,
+                              MergeContext* merge_context,
+                              const MergeOperator* merge_operator,
+                              SystemClock* clock, Statistics* statistics,
+                              Logger* logger, Status* s, std::string* out_value,
+                              PinnableWideColumns* out_columns) {
+    if (!merge_operator) {
+      *s = Status::InvalidArgument(
+          "merge_operator is not properly initialized.");
+      // Normally we continue the loop (return true) when we see a merge
+      // operand.  But in case of an error, we should stop the loop
+      // immediately and pretend we have found the value to stop further
+      // seek.  Otherwise, the later call will override this error status.
+      return true;
+    }
+    merge_context->PushOperand(value, value_pinned /* operand_pinned */);
+    PERF_COUNTER_ADD(internal_merge_point_lookup_count, 1);
+
+    if (do_merge && merge_operator->ShouldMerge(
+                        merge_context->GetOperandsDirectionBackward())) {
+      if (out_value || out_columns) {
+        // `op_failure_scope` (an output parameter) is not provided (set to
+        // nullptr) since a failure must be propagated regardless of its
+        // value.
+        *s = MergeHelper::TimedFullMerge(
+            merge_operator, lookup_user_key, MergeHelper::kNoBaseValue,
+            merge_context->GetOperands(), logger, statistics, clock,
+            /* update_num_ops_stats */ true,
+            /* op_failure_scope */ nullptr, out_value, out_columns);
+      }
+      return true;
+    }
+    if (merge_context->get_merge_operands_options != nullptr &&
+        merge_context->get_merge_operands_options->continue_cb != nullptr &&
+        !merge_context->get_merge_operands_options->continue_cb(value)) {
+      // We were told not to continue. `status` may be MergeInProress(),
+      // overwrite to signal the end of successful get. This status
+      // will be checked at the end of GetImpl().
+      *s = Status::OK();
+      return true;
+    }
+
+    // no final value found yet
+    return false;
+  }
+
+  void MarkForFlush() { marked_for_flush_.StoreRelaxed(true); }
+
+  bool IsMarkedForFlush() const { return marked_for_flush_.LoadRelaxed(); }
+
  protected:
   friend class MemTableList;
 
@@ -457,7 +516,7 @@ class ReadOnlyMemTable {
   VersionEdit edit_;
 
   // The log files earlier than this number can be deleted.
-  uint64_t mem_next_logfile_number_{0};
+  uint64_t mem_next_walfile_number_{0};
 
   // Memtable id to track flush.
   uint64_t id_ = 0;
@@ -470,6 +529,8 @@ class ReadOnlyMemTable {
 
   // Flush job info of the current memtable.
   std::unique_ptr<FlushJobInfo> flush_job_info_;
+
+  RelaxedAtomic<bool> marked_for_flush_{false};
 };
 
 class MemTable final : public ReadOnlyMemTable {
@@ -627,6 +688,7 @@ class MemTable final : public ReadOnlyMemTable {
   // Update counters and flush status after inserting a whole write batch
   // Used in concurrent memtable inserts.
   void BatchPostProcess(const MemTablePostProcessInfo& update_counters) {
+    table_->BatchPostProcess();
     num_entries_.fetch_add(update_counters.num_entries,
                            std::memory_order_relaxed);
     data_size_.fetch_add(update_counters.data_size, std::memory_order_relaxed);
@@ -637,6 +699,10 @@ class MemTable final : public ReadOnlyMemTable {
     if (update_counters.num_range_deletes > 0) {
       num_range_deletes_.fetch_add(update_counters.num_range_deletes,
                                    std::memory_order_relaxed);
+      // noop for skip-list memtable
+      // Besides correctness test in stress test, memtable flush record count
+      // check will catch this if it were not noop.
+      // range_del_table_->BatchPostProcess();
     }
     UpdateFlushState();
   }
@@ -764,6 +830,8 @@ class MemTable final : public ReadOnlyMemTable {
            is_range_del_table_empty_;
   }
 
+  //  Gets the newest user defined timestamps in the memtable. This should only
+  //  be called when user defined timestamp is enabled.
   const Slice& GetNewestUDT() const override;
 
   // Returns Corruption status if verification fails.
@@ -839,14 +907,10 @@ class MemTable final : public ReadOnlyMemTable {
   // Size in bytes for the user-defined timestamps.
   size_t ts_sz_;
 
-  // Whether to persist user-defined timestamps
-  bool persist_user_defined_timestamps_;
-
   // Newest user-defined timestamp contained in this MemTable. For ts1, and ts2
   // if Comparator::CompareTimestamp(ts1, ts2) > 0, ts1 is considered newer than
   // ts2. We track this field for a MemTable if its column family has UDT
-  // feature enabled and the `persist_user_defined_timestamp` flag is false.
-  // Otherwise, this field just contains an empty Slice.
+  // feature enabled.
   Slice newest_udt_;
 
   // Updates flush_state_ using ShouldFlushNow()