@nxtedition/rocksdb 7.1.25 → 7.1.27

package/deps/rocksdb/rocksdb/trace_replay/block_cache_tracer.cc

@@ -20,7 +20,8 @@
 namespace ROCKSDB_NAMESPACE {
 
 namespace {
-bool ShouldTrace(const Slice& block_key, const TraceOptions& trace_options) {
+bool ShouldTrace(const Slice& block_key,
+                 const BlockCacheTraceOptions& trace_options) {
   if (trace_options.sampling_frequency == 0 ||
       trace_options.sampling_frequency == 1) {
     return true;
@@ -36,6 +37,7 @@ const uint64_t kSecondInMinute = 60;
 const uint64_t kSecondInHour = 3600;
 const std::string BlockCacheTraceHelper::kUnknownColumnFamilyName =
     "UnknownColumnFamily";
+const uint64_t BlockCacheTraceRecord::kReservedGetId = 0;
 const uint64_t BlockCacheTraceHelper::kReservedGetId = 0;
 
 bool BlockCacheTraceHelper::IsGetOrMultiGetOnDataBlock(
@@ -79,9 +81,9 @@ uint64_t BlockCacheTraceHelper::GetSequenceNumber(
   if (!IsGetOrMultiGet(access.caller)) {
     return 0;
   }
-  return access.get_from_user_specified_snapshot == Boolean::kFalse
-             ? 0
-             : 1 + GetInternalKeySeqno(access.referenced_key);
+  return access.get_from_user_specified_snapshot
+             ? 1 + GetInternalKeySeqno(access.referenced_key)
+             : 0;
 }
 
 uint64_t BlockCacheTraceHelper::GetBlockOffsetInFile(
@@ -99,14 +101,14 @@ uint64_t BlockCacheTraceHelper::GetBlockOffsetInFile(
   return offset;
 }
 
-BlockCacheTraceWriter::BlockCacheTraceWriter(
-    SystemClock* clock, const TraceOptions& trace_options,
+BlockCacheTraceWriterImpl::BlockCacheTraceWriterImpl(
+    SystemClock* clock, const BlockCacheTraceWriterOptions& trace_options,
     std::unique_ptr<TraceWriter>&& trace_writer)
     : clock_(clock),
       trace_options_(trace_options),
       trace_writer_(std::move(trace_writer)) {}
 
-Status BlockCacheTraceWriter::WriteBlockAccess(
+Status BlockCacheTraceWriterImpl::WriteBlockAccess(
     const BlockCacheTraceRecord& record, const Slice& block_key,
     const Slice& cf_name, const Slice& referenced_key) {
   uint64_t trace_file_size = trace_writer_->GetFileSize();
@@ -141,7 +143,7 @@ Status BlockCacheTraceWriter::WriteBlockAccess(
   return trace_writer_->Write(encoded_trace);
 }
 
-Status BlockCacheTraceWriter::WriteHeader() {
+Status BlockCacheTraceWriterImpl::WriteHeader() {
   Trace trace;
   trace.ts = clock_->NowMicros();
   trace.type = TraceType::kTraceBegin;
@@ -255,13 +257,13 @@ Status BlockCacheTraceReader::ReadAccess(BlockCacheTraceRecord* record) {
     return Status::Incomplete(
         "Incomplete access record: Failed to read is_cache_hit.");
   }
-  record->is_cache_hit = static_cast<Boolean>(enc_slice[0]);
+  record->is_cache_hit = static_cast<char>(enc_slice[0]);
   enc_slice.remove_prefix(kCharSize);
   if (enc_slice.empty()) {
     return Status::Incomplete(
         "Incomplete access record: Failed to read no_insert.");
   }
-  record->no_insert = static_cast<Boolean>(enc_slice[0]);
+  record->no_insert = static_cast<char>(enc_slice[0]);
   enc_slice.remove_prefix(kCharSize);
   if (BlockCacheTraceHelper::IsGetOrMultiGet(record->caller)) {
     if (!GetFixed64(&enc_slice, &record->get_id)) {
@@ -273,8 +275,7 @@ Status BlockCacheTraceReader::ReadAccess(BlockCacheTraceRecord* record) {
           "Incomplete access record: Failed to read "
           "get_from_user_specified_snapshot.");
     }
-    record->get_from_user_specified_snapshot =
-        static_cast<Boolean>(enc_slice[0]);
+    record->get_from_user_specified_snapshot = static_cast<char>(enc_slice[0]);
     enc_slice.remove_prefix(kCharSize);
     Slice referenced_key;
     if (!GetLengthPrefixedSlice(&enc_slice, &referenced_key)) {
@@ -299,7 +300,7 @@ Status BlockCacheTraceReader::ReadAccess(BlockCacheTraceRecord* record) {
           "Incomplete access record: Failed to read "
           "referenced_key_exist_in_block.");
     }
-    record->referenced_key_exist_in_block = static_cast<Boolean>(enc_slice[0]);
+    record->referenced_key_exist_in_block = static_cast<char>(enc_slice[0]);
   }
   return Status::OK();
 }
@@ -391,14 +392,14 @@ Status BlockCacheHumanReadableTraceReader::ReadAccess(
   record->level = static_cast<uint32_t>(ParseUint64(record_strs[6]));
   record->sst_fd_number = ParseUint64(record_strs[7]);
   record->caller = static_cast<TableReaderCaller>(ParseUint64(record_strs[8]));
-  record->no_insert = static_cast<Boolean>(ParseUint64(record_strs[9]));
+  record->no_insert = static_cast<char>(ParseUint64(record_strs[9]));
   record->get_id = ParseUint64(record_strs[10]);
   uint64_t get_key_id = ParseUint64(record_strs[11]);
 
   record->referenced_data_size = ParseUint64(record_strs[12]);
-  record->is_cache_hit = static_cast<Boolean>(ParseUint64(record_strs[13]));
+  record->is_cache_hit = static_cast<char>(ParseUint64(record_strs[13]));
   record->referenced_key_exist_in_block =
-      static_cast<Boolean>(ParseUint64(record_strs[14]));
+      static_cast<char>(ParseUint64(record_strs[14]));
   record->num_keys_in_block = ParseUint64(record_strs[15]);
   uint64_t table_id = ParseUint64(record_strs[16]);
   if (table_id > 0) {
@@ -408,7 +409,7 @@ Status BlockCacheHumanReadableTraceReader::ReadAccess(
   }
   uint64_t get_sequence_number = ParseUint64(record_strs[17]);
   if (get_sequence_number > 0) {
-    record->get_from_user_specified_snapshot = Boolean::kTrue;
+    record->get_from_user_specified_snapshot = true;
     // Decrement since valid seq number in the trace file equals traced seq
     // number + 1.
     get_sequence_number -= 1;
@@ -445,16 +446,15 @@ BlockCacheTracer::BlockCacheTracer() { writer_.store(nullptr); }
 BlockCacheTracer::~BlockCacheTracer() { EndTrace(); }
 
 Status BlockCacheTracer::StartTrace(
-    SystemClock* clock, const TraceOptions& trace_options,
-    std::unique_ptr<TraceWriter>&& trace_writer) {
+    const BlockCacheTraceOptions& trace_options,
+    std::unique_ptr<BlockCacheTraceWriter>&& trace_writer) {
   InstrumentedMutexLock lock_guard(&trace_writer_mutex_);
   if (writer_.load()) {
     return Status::Busy();
   }
   get_id_counter_.store(1);
   trace_options_ = trace_options;
-  writer_.store(
-      new BlockCacheTraceWriter(clock, trace_options, std::move(trace_writer)));
+  writer_.store(trace_writer.release());
   return writer_.load()->WriteHeader();
 }
 
@@ -494,4 +494,11 @@ uint64_t BlockCacheTracer::NextGetId() {
   return prev_value;
 }
 
+std::unique_ptr<BlockCacheTraceWriter> NewBlockCacheTraceWriter(
+    SystemClock* clock, const BlockCacheTraceWriterOptions& trace_options,
+    std::unique_ptr<TraceWriter>&& trace_writer) {
+  return std::unique_ptr<BlockCacheTraceWriter>(new BlockCacheTraceWriterImpl(
+      clock, trace_options, std::move(trace_writer)));
+}
+
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/trace_replay/block_cache_tracer.h

@@ -9,9 +9,10 @@
 #include <fstream>
 
 #include "monitoring/instrumented_mutex.h"
+#include "rocksdb/block_cache_trace_writer.h"
 #include "rocksdb/options.h"
+#include "rocksdb/table_reader_caller.h"
 #include "rocksdb/trace_reader_writer.h"
-#include "table/table_reader_caller.h"
 #include "trace_replay/trace_replay.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -102,65 +103,6 @@ struct BlockCacheLookupContext {
   }
 };
 
-enum Boolean : char { kTrue = 1, kFalse = 0 };
-
-struct BlockCacheTraceRecord {
-  // Required fields for all accesses.
-  uint64_t access_timestamp = 0;
-  std::string block_key;
-  TraceType block_type = TraceType::kTraceMax;
-  uint64_t block_size = 0;
-  uint64_t cf_id = 0;
-  std::string cf_name;
-  uint32_t level = 0;
-  uint64_t sst_fd_number = 0;
-  TableReaderCaller caller = TableReaderCaller::kMaxBlockCacheLookupCaller;
-  Boolean is_cache_hit = Boolean::kFalse;
-  Boolean no_insert = Boolean::kFalse;
-  // Required field for Get and MultiGet
-  uint64_t get_id = BlockCacheTraceHelper::kReservedGetId;
-  Boolean get_from_user_specified_snapshot = Boolean::kFalse;
-  std::string referenced_key;
-  // Required fields for data block and user Get/Multi-Get only.
-  uint64_t referenced_data_size = 0;
-  uint64_t num_keys_in_block = 0;
-  Boolean referenced_key_exist_in_block = Boolean::kFalse;
-
-  BlockCacheTraceRecord() {}
-
-  BlockCacheTraceRecord(
-      uint64_t _access_timestamp, std::string _block_key, TraceType _block_type,
-      uint64_t _block_size, uint64_t _cf_id, std::string _cf_name,
-      uint32_t _level, uint64_t _sst_fd_number, TableReaderCaller _caller,
-      bool _is_cache_hit, bool _no_insert,
-      uint64_t _get_id = BlockCacheTraceHelper::kReservedGetId,
-      bool _get_from_user_specified_snapshot = false,
-      std::string _referenced_key = "", uint64_t _referenced_data_size = 0,
-      uint64_t _num_keys_in_block = 0,
-      bool _referenced_key_exist_in_block = false)
-      : access_timestamp(_access_timestamp),
-        block_key(_block_key),
-        block_type(_block_type),
-        block_size(_block_size),
-        cf_id(_cf_id),
-        cf_name(_cf_name),
-        level(_level),
-        sst_fd_number(_sst_fd_number),
-        caller(_caller),
-        is_cache_hit(_is_cache_hit ? Boolean::kTrue : Boolean::kFalse),
-        no_insert(_no_insert ? Boolean::kTrue : Boolean::kFalse),
-        get_id(_get_id),
-        get_from_user_specified_snapshot(_get_from_user_specified_snapshot
-                                             ? Boolean::kTrue
-                                             : Boolean::kFalse),
-        referenced_key(_referenced_key),
-        referenced_data_size(_referenced_data_size),
-        num_keys_in_block(_num_keys_in_block),
-        referenced_key_exist_in_block(
-            _referenced_key_exist_in_block ? Boolean::kTrue : Boolean::kFalse) {
-  }
-};
-
 struct BlockCacheTraceHeader {
   uint64_t start_time;
   uint32_t rocksdb_major_version;
@@ -171,16 +113,18 @@ struct BlockCacheTraceHeader {
 // user-provided TraceWriter. Every RocksDB operation is written as a single
 // trace. Each trace will have a timestamp and type, followed by the trace
 // payload.
-class BlockCacheTraceWriter {
+class BlockCacheTraceWriterImpl : public BlockCacheTraceWriter {
  public:
-  BlockCacheTraceWriter(SystemClock* clock, const TraceOptions& trace_options,
-                        std::unique_ptr<TraceWriter>&& trace_writer);
-  ~BlockCacheTraceWriter() = default;
+  BlockCacheTraceWriterImpl(SystemClock* clock,
+                            const BlockCacheTraceWriterOptions& trace_options,
+                            std::unique_ptr<TraceWriter>&& trace_writer);
+  ~BlockCacheTraceWriterImpl() = default;
   // No copy and move.
-  BlockCacheTraceWriter(const BlockCacheTraceWriter&) = delete;
-  BlockCacheTraceWriter& operator=(const BlockCacheTraceWriter&) = delete;
-  BlockCacheTraceWriter(BlockCacheTraceWriter&&) = delete;
-  BlockCacheTraceWriter& operator=(BlockCacheTraceWriter&&) = delete;
+  BlockCacheTraceWriterImpl(const BlockCacheTraceWriterImpl&) = delete;
+  BlockCacheTraceWriterImpl& operator=(const BlockCacheTraceWriterImpl&) =
+      delete;
+  BlockCacheTraceWriterImpl(BlockCacheTraceWriterImpl&&) = delete;
+  BlockCacheTraceWriterImpl& operator=(BlockCacheTraceWriterImpl&&) = delete;
 
   // Pass Slice references to avoid copy.
   Status WriteBlockAccess(const BlockCacheTraceRecord& record,
@@ -193,7 +137,7 @@ class BlockCacheTraceWriter {
 
  private:
   SystemClock* clock_;
-  TraceOptions trace_options_;
+  BlockCacheTraceWriterOptions trace_options_;
   std::unique_ptr<TraceWriter> trace_writer_;
 };
 
@@ -267,8 +211,8 @@ class BlockCacheTracer {
   BlockCacheTracer& operator=(BlockCacheTracer&&) = delete;
 
   // Start writing block cache accesses to the trace_writer.
-  Status StartTrace(SystemClock* clock, const TraceOptions& trace_options,
-                    std::unique_ptr<TraceWriter>&& trace_writer);
+  Status StartTrace(const BlockCacheTraceOptions& trace_options,
+                    std::unique_ptr<BlockCacheTraceWriter>&& trace_writer);
 
   // Stop writing block cache accesses to the trace_writer.
   void EndTrace();
@@ -285,7 +229,7 @@ class BlockCacheTracer {
   uint64_t NextGetId();
 
  private:
-  TraceOptions trace_options_;
+  BlockCacheTraceOptions trace_options_;
   // A mutex protects the writer_.
   InstrumentedMutex trace_writer_mutex_;
   std::atomic<BlockCacheTraceWriter*> writer_;

package/deps/rocksdb/rocksdb/trace_replay/block_cache_tracer_test.cc

@@ -74,17 +74,17 @@ class BlockCacheTracerTest : public testing::Test {
       record.caller = GetCaller(key_id);
       record.level = kLevel;
       record.sst_fd_number = kSSTFDNumber + key_id;
-      record.is_cache_hit = Boolean::kFalse;
-      record.no_insert = Boolean::kFalse;
+      record.is_cache_hit = false;
+      record.no_insert = false;
       // Provide get_id for all callers. The writer should only write get_id
       // when the caller is either GET or MGET.
       record.get_id = key_id + 1;
-      record.get_from_user_specified_snapshot = Boolean::kTrue;
+      record.get_from_user_specified_snapshot = true;
       // Provide these fields for all block types.
       // The writer should only write these fields for data blocks and the
       // caller is either GET or MGET.
       record.referenced_key = (kRefKeyPrefix + std::to_string(key_id));
-      record.referenced_key_exist_in_block = Boolean::kTrue;
+      record.referenced_key_exist_in_block = true;
       record.num_keys_in_block = kNumKeysInBlock;
       record.referenced_data_size = kReferencedDataSize + key_id;
       ASSERT_OK(writer->WriteBlockAccess(
@@ -104,10 +104,10 @@ class BlockCacheTracerTest : public testing::Test {
     record.caller = GetCaller(key_id);
     record.level = kLevel;
     record.sst_fd_number = kSSTFDNumber + key_id;
-    record.is_cache_hit = Boolean::kFalse;
-    record.no_insert = Boolean::kFalse;
+    record.is_cache_hit = false;
+    record.no_insert = false;
     record.referenced_key = kRefKeyPrefix + std::to_string(key_id);
-    record.referenced_key_exist_in_block = Boolean::kTrue;
+    record.referenced_key_exist_in_block = true;
     record.num_keys_in_block = kNumKeysInBlock;
     return record;
   }
@@ -127,28 +127,28 @@ class BlockCacheTracerTest : public testing::Test {
       ASSERT_EQ(GetCaller(key_id), record.caller);
       ASSERT_EQ(kLevel, record.level);
       ASSERT_EQ(kSSTFDNumber + key_id, record.sst_fd_number);
-      ASSERT_EQ(Boolean::kFalse, record.is_cache_hit);
-      ASSERT_EQ(Boolean::kFalse, record.no_insert);
+      ASSERT_FALSE(record.is_cache_hit);
+      ASSERT_FALSE(record.no_insert);
       if (record.caller == TableReaderCaller::kUserGet ||
           record.caller == TableReaderCaller::kUserMultiGet) {
         ASSERT_EQ(key_id + 1, record.get_id);
-        ASSERT_EQ(Boolean::kTrue, record.get_from_user_specified_snapshot);
+        ASSERT_TRUE(record.get_from_user_specified_snapshot);
         ASSERT_EQ(kRefKeyPrefix + std::to_string(key_id),
                   record.referenced_key);
       } else {
         ASSERT_EQ(BlockCacheTraceHelper::kReservedGetId, record.get_id);
-        ASSERT_EQ(Boolean::kFalse, record.get_from_user_specified_snapshot);
+        ASSERT_FALSE(record.get_from_user_specified_snapshot);
         ASSERT_EQ("", record.referenced_key);
       }
       if (block_type == TraceType::kBlockTraceDataBlock &&
           (record.caller == TableReaderCaller::kUserGet ||
            record.caller == TableReaderCaller::kUserMultiGet)) {
-        ASSERT_EQ(Boolean::kTrue, record.referenced_key_exist_in_block);
+        ASSERT_TRUE(record.referenced_key_exist_in_block);
         ASSERT_EQ(kNumKeysInBlock, record.num_keys_in_block);
         ASSERT_EQ(kReferencedDataSize + key_id, record.referenced_data_size);
         continue;
       }
-      ASSERT_EQ(Boolean::kFalse, record.referenced_key_exist_in_block);
+      ASSERT_FALSE(record.referenced_key_exist_in_block);
       ASSERT_EQ(0, record.num_keys_in_block);
       ASSERT_EQ(0, record.referenced_data_size);
     }
@@ -188,12 +188,18 @@ TEST_F(BlockCacheTracerTest, AtomicWriteBeforeStartTrace) {
 TEST_F(BlockCacheTracerTest, AtomicWrite) {
   BlockCacheTraceRecord record = GenerateAccessRecord();
   {
-    TraceOptions trace_opt;
+    BlockCacheTraceWriterOptions trace_writer_opt;
+    BlockCacheTraceOptions trace_opt;
     std::unique_ptr<TraceWriter> trace_writer;
     ASSERT_OK(NewFileTraceWriter(env_, env_options_, trace_file_path_,
                                  &trace_writer));
+    std::unique_ptr<BlockCacheTraceWriter> block_cache_trace_writer =
+        NewBlockCacheTraceWriter(env_->GetSystemClock().get(), trace_writer_opt,
+                                 std::move(trace_writer));
+    ASSERT_NE(block_cache_trace_writer, nullptr);
     BlockCacheTracer writer;
-    ASSERT_OK(writer.StartTrace(clock_, trace_opt, std::move(trace_writer)));
+    ASSERT_OK(
+        writer.StartTrace(trace_opt, std::move(block_cache_trace_writer)));
     ASSERT_OK(writer.WriteBlockAccess(record, record.block_key, record.cf_name,
                                       record.referenced_key));
     ASSERT_OK(env_->FileExists(trace_file_path_));
@@ -214,25 +220,36 @@ TEST_F(BlockCacheTracerTest, AtomicWrite) {
 }
 
 TEST_F(BlockCacheTracerTest, ConsecutiveStartTrace) {
-  TraceOptions trace_opt;
+  BlockCacheTraceWriterOptions trace_writer_opt;
+  BlockCacheTraceOptions trace_opt;
   std::unique_ptr<TraceWriter> trace_writer;
   ASSERT_OK(
       NewFileTraceWriter(env_, env_options_, trace_file_path_, &trace_writer));
+  std::unique_ptr<BlockCacheTraceWriter> block_cache_trace_writer =
+      NewBlockCacheTraceWriter(env_->GetSystemClock().get(), trace_writer_opt,
+                               std::move(trace_writer));
+  ASSERT_NE(block_cache_trace_writer, nullptr);
   BlockCacheTracer writer;
-  ASSERT_OK(writer.StartTrace(clock_, trace_opt, std::move(trace_writer)));
-  ASSERT_NOK(writer.StartTrace(clock_, trace_opt, std::move(trace_writer)));
+  ASSERT_OK(writer.StartTrace(trace_opt, std::move(block_cache_trace_writer)));
+  ASSERT_NOK(writer.StartTrace(trace_opt, std::move(block_cache_trace_writer)));
   ASSERT_OK(env_->FileExists(trace_file_path_));
 }
 
 TEST_F(BlockCacheTracerTest, AtomicNoWriteAfterEndTrace) {
   BlockCacheTraceRecord record = GenerateAccessRecord();
   {
-    TraceOptions trace_opt;
+    BlockCacheTraceWriterOptions trace_writer_opt;
+    BlockCacheTraceOptions trace_opt;
     std::unique_ptr<TraceWriter> trace_writer;
     ASSERT_OK(NewFileTraceWriter(env_, env_options_, trace_file_path_,
                                  &trace_writer));
+    std::unique_ptr<BlockCacheTraceWriter> block_cache_trace_writer =
+        NewBlockCacheTraceWriter(env_->GetSystemClock().get(), trace_writer_opt,
+                                 std::move(trace_writer));
+    ASSERT_NE(block_cache_trace_writer, nullptr);
     BlockCacheTracer writer;
-    ASSERT_OK(writer.StartTrace(clock_, trace_opt, std::move(trace_writer)));
+    ASSERT_OK(
+        writer.StartTrace(trace_opt, std::move(block_cache_trace_writer)));
     ASSERT_OK(writer.WriteBlockAccess(record, record.block_key, record.cf_name,
                                       record.referenced_key));
     writer.EndTrace();
@@ -260,14 +277,20 @@ TEST_F(BlockCacheTracerTest, AtomicNoWriteAfterEndTrace) {
 TEST_F(BlockCacheTracerTest, NextGetId) {
   BlockCacheTracer writer;
   {
-    TraceOptions trace_opt;
+    BlockCacheTraceWriterOptions trace_writer_opt;
+    BlockCacheTraceOptions trace_opt;
     std::unique_ptr<TraceWriter> trace_writer;
     ASSERT_OK(NewFileTraceWriter(env_, env_options_, trace_file_path_,
                                  &trace_writer));
+    std::unique_ptr<BlockCacheTraceWriter> block_cache_trace_writer =
+        NewBlockCacheTraceWriter(env_->GetSystemClock().get(), trace_writer_opt,
+                                 std::move(trace_writer));
+    ASSERT_NE(block_cache_trace_writer, nullptr);
     // next get id should always return 0 before we call StartTrace.
     ASSERT_EQ(0, writer.NextGetId());
     ASSERT_EQ(0, writer.NextGetId());
-    ASSERT_OK(writer.StartTrace(clock_, trace_opt, std::move(trace_writer)));
+    ASSERT_OK(
+        writer.StartTrace(trace_opt, std::move(block_cache_trace_writer)));
     ASSERT_EQ(1, writer.NextGetId());
     ASSERT_EQ(2, writer.NextGetId());
     writer.EndTrace();
@@ -277,11 +300,17 @@ TEST_F(BlockCacheTracerTest, NextGetId) {
 
   // Start trace again and next get id should return 1.
   {
-    TraceOptions trace_opt;
+    BlockCacheTraceWriterOptions trace_writer_opt;
+    BlockCacheTraceOptions trace_opt;
     std::unique_ptr<TraceWriter> trace_writer;
     ASSERT_OK(NewFileTraceWriter(env_, env_options_, trace_file_path_,
                                  &trace_writer));
-    ASSERT_OK(writer.StartTrace(clock_, trace_opt, std::move(trace_writer)));
+    std::unique_ptr<BlockCacheTraceWriter> block_cache_trace_writer =
+        NewBlockCacheTraceWriter(env_->GetSystemClock().get(), trace_writer_opt,
+                                 std::move(trace_writer));
+    ASSERT_NE(block_cache_trace_writer, nullptr);
+    ASSERT_OK(
+        writer.StartTrace(trace_opt, std::move(block_cache_trace_writer)));
     ASSERT_EQ(1, writer.NextGetId());
   }
 }
@@ -289,19 +318,26 @@ TEST_F(BlockCacheTracerTest, NextGetId) {
 TEST_F(BlockCacheTracerTest, MixedBlocks) {
   {
     // Generate a trace file containing a mix of blocks.
-    TraceOptions trace_opt;
+    BlockCacheTraceWriterOptions trace_writer_opt;
     std::unique_ptr<TraceWriter> trace_writer;
     ASSERT_OK(NewFileTraceWriter(env_, env_options_, trace_file_path_,
                                  &trace_writer));
-    BlockCacheTraceWriter writer(clock_, trace_opt, std::move(trace_writer));
-    ASSERT_OK(writer.WriteHeader());
+    std::unique_ptr<BlockCacheTraceWriter> block_cache_trace_writer =
+        NewBlockCacheTraceWriter(env_->GetSystemClock().get(), trace_writer_opt,
+                                 std::move(trace_writer));
+    ASSERT_NE(block_cache_trace_writer, nullptr);
+    ASSERT_OK(block_cache_trace_writer->WriteHeader());
     // Write blocks of different types.
-    WriteBlockAccess(&writer, 0, TraceType::kBlockTraceUncompressionDictBlock,
-                     10);
-    WriteBlockAccess(&writer, 10, TraceType::kBlockTraceDataBlock, 10);
-    WriteBlockAccess(&writer, 20, TraceType::kBlockTraceFilterBlock, 10);
-    WriteBlockAccess(&writer, 30, TraceType::kBlockTraceIndexBlock, 10);
-    WriteBlockAccess(&writer, 40, TraceType::kBlockTraceRangeDeletionBlock, 10);
+    WriteBlockAccess(block_cache_trace_writer.get(), 0,
+                     TraceType::kBlockTraceUncompressionDictBlock, 10);
+    WriteBlockAccess(block_cache_trace_writer.get(), 10,
+                     TraceType::kBlockTraceDataBlock, 10);
+    WriteBlockAccess(block_cache_trace_writer.get(), 20,
+                     TraceType::kBlockTraceFilterBlock, 10);
+    WriteBlockAccess(block_cache_trace_writer.get(), 30,
+                     TraceType::kBlockTraceIndexBlock, 10);
+    WriteBlockAccess(block_cache_trace_writer.get(), 40,
+                     TraceType::kBlockTraceRangeDeletionBlock, 10);
     ASSERT_OK(env_->FileExists(trace_file_path_));
   }
 
@@ -332,7 +368,7 @@ TEST_F(BlockCacheTracerTest, HumanReadableTrace) {
   record.get_id = 1;
   record.referenced_key = "";
   record.caller = TableReaderCaller::kUserGet;
-  record.get_from_user_specified_snapshot = Boolean::kTrue;
+  record.get_from_user_specified_snapshot = true;
   record.referenced_data_size = kReferencedDataSize;
   PutFixed32(&record.referenced_key, 111);
   PutLengthPrefixedSlice(&record.referenced_key, "get_key");
@@ -359,11 +395,11 @@ TEST_F(BlockCacheTracerTest, HumanReadableTrace) {
     ASSERT_EQ(TableReaderCaller::kUserGet, read_record.caller);
     ASSERT_EQ(kLevel, read_record.level);
     ASSERT_EQ(kSSTFDNumber, read_record.sst_fd_number);
-    ASSERT_EQ(Boolean::kFalse, read_record.is_cache_hit);
-    ASSERT_EQ(Boolean::kFalse, read_record.no_insert);
+    ASSERT_FALSE(read_record.is_cache_hit);
+    ASSERT_FALSE(read_record.no_insert);
     ASSERT_EQ(1, read_record.get_id);
-    ASSERT_EQ(Boolean::kTrue, read_record.get_from_user_specified_snapshot);
-    ASSERT_EQ(Boolean::kTrue, read_record.referenced_key_exist_in_block);
+    ASSERT_TRUE(read_record.get_from_user_specified_snapshot);
+    ASSERT_TRUE(read_record.referenced_key_exist_in_block);
     ASSERT_EQ(kNumKeysInBlock, read_record.num_keys_in_block);
     ASSERT_EQ(kReferencedDataSize, read_record.referenced_data_size);
     ASSERT_EQ(record.block_key.size(), read_record.block_key.size());

package/deps/rocksdb/rocksdb/util/user_comparator_wrapper.h

@@ -15,65 +15,45 @@ namespace ROCKSDB_NAMESPACE {
 
 // Wrapper of user comparator, with auto increment to
 // perf_context.user_key_comparison_count.
-class UserComparatorWrapper final : public Comparator {
+class UserComparatorWrapper {
  public:
   // `UserComparatorWrapper`s constructed with the default constructor are not
   // usable and will segfault on any attempt to use them for comparisons.
   UserComparatorWrapper() : user_comparator_(nullptr) {}
 
   explicit UserComparatorWrapper(const Comparator* const user_cmp)
-      : Comparator(user_cmp->timestamp_size()), user_comparator_(user_cmp) {}
+      : user_comparator_(user_cmp) {}
 
   ~UserComparatorWrapper() = default;
 
   const Comparator* user_comparator() const { return user_comparator_; }
 
-  int Compare(const Slice& a, const Slice& b) const override {
+  int Compare(const Slice& a, const Slice& b) const {
     PERF_COUNTER_ADD(user_key_comparison_count, 1);
     return user_comparator_->Compare(a, b);
   }
 
-  bool Equal(const Slice& a, const Slice& b) const override {
+  bool Equal(const Slice& a, const Slice& b) const {
     PERF_COUNTER_ADD(user_key_comparison_count, 1);
     return user_comparator_->Equal(a, b);
   }
 
-  const char* Name() const override { return user_comparator_->Name(); }
-
-  void FindShortestSeparator(std::string* start,
-                             const Slice& limit) const override {
-    return user_comparator_->FindShortestSeparator(start, limit);
-  }
-
-  void FindShortSuccessor(std::string* key) const override {
-    return user_comparator_->FindShortSuccessor(key);
-  }
-
-  const Comparator* GetRootComparator() const override {
-    return user_comparator_->GetRootComparator();
-  }
-
-  bool IsSameLengthImmediateSuccessor(const Slice& s,
-                                      const Slice& t) const override {
-    return user_comparator_->IsSameLengthImmediateSuccessor(s, t);
-  }
-
-  bool CanKeysWithDifferentByteContentsBeEqual() const override {
-    return user_comparator_->CanKeysWithDifferentByteContentsBeEqual();
+  int CompareTimestamp(const Slice& ts1, const Slice& ts2) const {
+    return user_comparator_->CompareTimestamp(ts1, ts2);
   }
 
-  int CompareTimestamp(const Slice& ts1, const Slice& ts2) const override {
-    return user_comparator_->CompareTimestamp(ts1, ts2);
+  int CompareWithoutTimestamp(const Slice& a, const Slice& b) const {
+    PERF_COUNTER_ADD(user_key_comparison_count, 1);
+    return user_comparator_->CompareWithoutTimestamp(a, b);
   }
 
-  using Comparator::CompareWithoutTimestamp;
   int CompareWithoutTimestamp(const Slice& a, bool a_has_ts, const Slice& b,
-                              bool b_has_ts) const override {
+                              bool b_has_ts) const {
     PERF_COUNTER_ADD(user_key_comparison_count, 1);
     return user_comparator_->CompareWithoutTimestamp(a, a_has_ts, b, b_has_ts);
   }
 
-  bool EqualWithoutTimestamp(const Slice& a, const Slice& b) const override {
+  bool EqualWithoutTimestamp(const Slice& a, const Slice& b) const {
     return user_comparator_->EqualWithoutTimestamp(a, b);
   }
 

package/deps/rocksdb/rocksdb/utilities/simulator_cache/cache_simulator.cc

@@ -41,7 +41,7 @@ void CacheSimulator::Access(const BlockCacheTraceRecord& access) {
   const bool is_user_access =
       BlockCacheTraceHelper::IsUserAccess(access.caller);
   bool is_cache_miss = true;
-  if (ghost_cache_ && access.no_insert == Boolean::kFalse) {
+  if (ghost_cache_ && !access.no_insert) {
     admit = ghost_cache_->Admit(access.block_key);
   }
   auto handle = sim_cache_->Lookup(access.block_key);
@@ -49,7 +49,7 @@ void CacheSimulator::Access(const BlockCacheTraceRecord& access) {
     sim_cache_->Release(handle);
     is_cache_miss = false;
   } else {
-    if (access.no_insert == Boolean::kFalse && admit && access.block_size > 0) {
+    if (!access.no_insert && admit && access.block_size > 0) {
       // Ignore errors on insert
       auto s = sim_cache_->Insert(access.block_key, /*value=*/nullptr,
                                   access.block_size,