@nxtedition/rocksdb 5.2.21 → 5.2.28

package/deps/rocksdb/rocksdb/trace_replay/io_tracer.cc

@@ -12,18 +12,22 @@
 #include "db/db_impl/db_impl.h"
 #include "db/dbformat.h"
 #include "rocksdb/slice.h"
+#include "rocksdb/system_clock.h"
+#include "rocksdb/trace_reader_writer.h"
 #include "util/coding.h"
 #include "util/hash.h"
 #include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {
-IOTraceWriter::IOTraceWriter(Env* env, const TraceOptions& trace_options,
+IOTraceWriter::IOTraceWriter(SystemClock* clock,
+                             const TraceOptions& trace_options,
                              std::unique_ptr<TraceWriter>&& trace_writer)
-    : env_(env),
+    : clock_(clock),
       trace_options_(trace_options),
       trace_writer_(std::move(trace_writer)) {}
 
-Status IOTraceWriter::WriteIOOp(const IOTraceRecord& record) {
+Status IOTraceWriter::WriteIOOp(const IOTraceRecord& record,
+                                IODebugContext* dbg) {
   uint64_t trace_file_size = trace_writer_->GetFileSize();
   if (trace_file_size > trace_options_.max_trace_file_size) {
     return Status::OK();
@@ -31,32 +35,63 @@ Status IOTraceWriter::WriteIOOp(const IOTraceRecord& record) {
   Trace trace;
   trace.ts = record.access_timestamp;
   trace.type = record.trace_type;
+  PutFixed64(&trace.payload, record.io_op_data);
   Slice file_operation(record.file_operation);
   PutLengthPrefixedSlice(&trace.payload, file_operation);
   PutFixed64(&trace.payload, record.latency);
   Slice io_status(record.io_status);
   PutLengthPrefixedSlice(&trace.payload, io_status);
-  /* Write remaining options based on trace_type set by file operation */
-  switch (record.trace_type) {
-    case TraceType::kIOGeneral:
-      break;
-    case TraceType::kIOFileNameAndFileSize:
-      PutFixed64(&trace.payload, record.file_size);
-      FALLTHROUGH_INTENDED;
-    case TraceType::kIOFileName: {
-      Slice file_name(record.file_name);
-      PutLengthPrefixedSlice(&trace.payload, file_name);
-      break;
+  Slice file_name(record.file_name);
+  PutLengthPrefixedSlice(&trace.payload, file_name);
+
+  // Each bit in io_op_data stores which corresponding info from IOTraceOp will
+  // be added in the trace. Foreg, if bit at position 1 is set then
+  // IOTraceOp::kIOLen (length) will be logged in the record (Since
+  // IOTraceOp::kIOLen = 1 in the enum). So find all the set positions in
+  // io_op_data one by one and, update corresponsing info in the trace record,
+  // unset that bit to find other set bits until io_op_data = 0.
+  /* Write remaining options based on io_op_data set by file operation */
+  int64_t io_op_data = static_cast<int64_t>(record.io_op_data);
+  while (io_op_data) {
+    // Find the rightmost set bit.
+    uint32_t set_pos = static_cast<uint32_t>(log2(io_op_data & -io_op_data));
+    switch (set_pos) {
+      case IOTraceOp::kIOFileSize:
+        PutFixed64(&trace.payload, record.file_size);
+        break;
+      case IOTraceOp::kIOLen:
+        PutFixed64(&trace.payload, record.len);
+        break;
+      case IOTraceOp::kIOOffset:
+        PutFixed64(&trace.payload, record.offset);
+        break;
+      default:
+        assert(false);
+    }
+    // unset the rightmost bit.
+    io_op_data &= (io_op_data - 1);
+  }
+
+  int64_t trace_data = 0;
+  if (dbg) {
+    trace_data = static_cast<int64_t>(dbg->trace_data);
+  }
+  PutFixed64(&trace.payload, trace_data);
+  while (trace_data) {
+    // Find the rightmost set bit.
+    uint32_t set_pos = static_cast<uint32_t>(log2(trace_data & -trace_data));
+    switch (set_pos) {
+      case IODebugContext::TraceData::kRequestID: {
+        Slice request_id(dbg->request_id);
+        PutLengthPrefixedSlice(&trace.payload, request_id);
+      } break;
+      default:
+        assert(false);
     }
-    case TraceType::kIOLenAndOffset:
-      PutFixed64(&trace.payload, record.offset);
-      FALLTHROUGH_INTENDED;
-    case TraceType::kIOLen:
-      PutFixed64(&trace.payload, record.len);
-      break;
-    default:
-      assert(false);
+    // unset the rightmost bit.
+    trace_data &= (trace_data - 1);
   }
+
   std::string encoded_trace;
   TracerHelper::EncodeTrace(trace, &encoded_trace);
   return trace_writer_->Write(encoded_trace);
@@ -64,7 +99,7 @@ Status IOTraceWriter::WriteIOOp(const IOTraceRecord& record) {
 
 Status IOTraceWriter::WriteHeader() {
   Trace trace;
-  trace.ts = env_->NowMicros();
+  trace.ts = clock_->NowMicros();
   trace.type = TraceType::kTraceBegin;
   PutLengthPrefixedSlice(&trace.payload, kTraceMagic);
   PutFixed32(&trace.payload, kMajorVersion);
@@ -135,6 +170,10 @@ Status IOTraceReader::ReadIOOp(IOTraceRecord* record) {
   record->trace_type = trace.type;
   Slice enc_slice = Slice(trace.payload);
 
+  if (!GetFixed64(&enc_slice, &record->io_op_data)) {
+    return Status::Incomplete(
+        "Incomplete access record: Failed to read trace data.");
+  }
   Slice file_operation;
   if (!GetLengthPrefixedSlice(&enc_slice, &file_operation)) {
     return Status::Incomplete(
@@ -151,41 +190,75 @@ Status IOTraceReader::ReadIOOp(IOTraceRecord* record) {
         "Incomplete access record: Failed to read IO status.");
   }
   record->io_status = io_status.ToString();
-  /* Read remaining options based on trace_type set by file operation */
-  switch (record->trace_type) {
-    case TraceType::kIOGeneral:
-      break;
-    case TraceType::kIOFileNameAndFileSize:
-      if (!GetFixed64(&enc_slice, &record->file_size)) {
-        return Status::Incomplete(
-            "Incomplete access record: Failed to read file size.");
-      }
-      FALLTHROUGH_INTENDED;
-    case TraceType::kIOFileName: {
-      Slice file_name;
-      if (!GetLengthPrefixedSlice(&enc_slice, &file_name)) {
-        return Status::Incomplete(
-            "Incomplete access record: Failed to read file name.");
-      }
-      record->file_name = file_name.ToString();
-      break;
+  Slice file_name;
+  if (!GetLengthPrefixedSlice(&enc_slice, &file_name)) {
+    return Status::Incomplete(
+        "Incomplete access record: Failed to read file name.");
+  }
+  record->file_name = file_name.ToString();
+
+  // Each bit in io_op_data stores which corresponding info from IOTraceOp will
+  // be added in the trace. Foreg, if bit at position 1 is set then
+  // IOTraceOp::kIOLen (length) will be logged in the record (Since
+  // IOTraceOp::kIOLen = 1 in the enum). So find all the set positions in
+  // io_op_data one by one and, update corresponsing info in the trace record,
+  // unset that bit to find other set bits until io_op_data = 0.
+  /* Read remaining options based on io_op_data set by file operation */
+  // Assuming 63 bits will be used at max.
+  int64_t io_op_data = static_cast<int64_t>(record->io_op_data);
+  while (io_op_data) {
+    // Find the rightmost set bit.
+    uint32_t set_pos = static_cast<uint32_t>(log2(io_op_data & -io_op_data));
+    switch (set_pos) {
+      case IOTraceOp::kIOFileSize:
+        if (!GetFixed64(&enc_slice, &record->file_size)) {
+          return Status::Incomplete(
+              "Incomplete access record: Failed to read file size.");
+        }
+        break;
+      case IOTraceOp::kIOLen:
+        if (!GetFixed64(&enc_slice, &record->len)) {
+          return Status::Incomplete(
+              "Incomplete access record: Failed to read length.");
+        }
+        break;
+      case IOTraceOp::kIOOffset:
+        if (!GetFixed64(&enc_slice, &record->offset)) {
+          return Status::Incomplete(
+              "Incomplete access record: Failed to read offset.");
+        }
+        break;
+      default:
+        assert(false);
     }
-    case TraceType::kIOLenAndOffset:
-      if (!GetFixed64(&enc_slice, &record->offset)) {
-        return Status::Incomplete(
-            "Incomplete access record: Failed to read offset.");
-      }
-      FALLTHROUGH_INTENDED;
-    case TraceType::kIOLen: {
-      if (!GetFixed64(&enc_slice, &record->len)) {
-        return Status::Incomplete(
-            "Incomplete access record: Failed to read length.");
-      }
-      break;
+    // unset the rightmost bit.
+    io_op_data &= (io_op_data - 1);
+  }
+
+  if (!GetFixed64(&enc_slice, &record->trace_data)) {
+    return Status::Incomplete(
+        "Incomplete access record: Failed to read trace op.");
+  }
+  int64_t trace_data = static_cast<int64_t>(record->trace_data);
+  while (trace_data) {
+    // Find the rightmost set bit.
+    uint32_t set_pos = static_cast<uint32_t>(log2(trace_data & -trace_data));
+    switch (set_pos) {
+      case IODebugContext::TraceData::kRequestID: {
+        Slice request_id;
+        if (!GetLengthPrefixedSlice(&enc_slice, &request_id)) {
+          return Status::Incomplete(
+              "Incomplete access record: Failed to request id.");
+        }
+        record->request_id = request_id.ToString();
+      } break;
+      default:
+        assert(false);
     }
-    default:
-      assert(false);
+    // unset the rightmost bit.
+    trace_data &= (trace_data - 1);
   }
+
   return Status::OK();
 }
 
@@ -193,14 +266,16 @@ IOTracer::IOTracer() : tracing_enabled(false) { writer_.store(nullptr); }
 
 IOTracer::~IOTracer() { EndIOTrace(); }
 
-Status IOTracer::StartIOTrace(Env* env, const TraceOptions& trace_options,
+Status IOTracer::StartIOTrace(SystemClock* clock,
+                              const TraceOptions& trace_options,
                               std::unique_ptr<TraceWriter>&& trace_writer) {
   InstrumentedMutexLock lock_guard(&trace_writer_mutex_);
   if (writer_.load()) {
     return Status::Busy();
   }
   trace_options_ = trace_options;
-  writer_.store(new IOTraceWriter(env, trace_options, std::move(trace_writer)));
+  writer_.store(
+      new IOTraceWriter(clock, trace_options, std::move(trace_writer)));
   tracing_enabled = true;
   return writer_.load()->WriteHeader();
 }
@@ -215,8 +290,7 @@ void IOTracer::EndIOTrace() {
   tracing_enabled = false;
 }
 
-// TODO: Return status and handle that in file_system_tracer.h
-void IOTracer::WriteIOOp(const IOTraceRecord& record) {
+void IOTracer::WriteIOOp(const IOTraceRecord& record, IODebugContext* dbg) {
   if (!writer_.load()) {
     return;
   }
@@ -224,6 +298,6 @@ void IOTracer::WriteIOOp(const IOTraceRecord& record) {
   if (!writer_.load()) {
     return;
   }
-  writer_.load()->WriteIOOp(record).PermitUncheckedError();
+  writer_.load()->WriteIOOp(record, dbg).PermitUncheckedError();
 }
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/trace_replay/io_tracer.h

@@ -9,44 +9,66 @@
 #include <fstream>
 
 #include "monitoring/instrumented_mutex.h"
-#include "rocksdb/env.h"
+#include "port/lang.h"
+#include "rocksdb/file_system.h"
 #include "rocksdb/options.h"
-#include "rocksdb/trace_reader_writer.h"
+#include "rocksdb/trace_record.h"
 #include "trace_replay/trace_replay.h"
 
 namespace ROCKSDB_NAMESPACE {
+class SystemClock;
+class TraceReader;
+class TraceWriter;
+
+/* In order to log new data in trace record for specified operations, do
+   following:
+   1. Add new data in IOTraceOP (say kIONewData= 3)
+   2. Log it in IOTraceWriter::WriteIOOp, and read that in
+   IOTraceReader::ReadIOOp and
+   IOTraceRecordParser::PrintHumanReadableIOTraceRecord in the switch case.
+   3. In the FileSystemTracer APIs where this data will be logged with, update
+   io_op_data |= (1 << IOTraceOp::kIONewData).
+*/
+enum IOTraceOp : char {
+  // The value of each enum represents the bitwise position for
+  // IOTraceRecord.io_op_data.
+  kIOFileSize = 0,
+  kIOLen = 1,
+  kIOOffset = 2,
+};
 
 struct IOTraceRecord {
   // Required fields for all accesses.
   uint64_t access_timestamp = 0;
   TraceType trace_type = TraceType::kTraceMax;
+  // Each bit in io_op_data stores which corresponding info from IOTraceOp will
+  // be added in the trace. Foreg, if bit at position 1 is set then
+  // IOTraceOp::kIOLen (length) will be logged in the record.
+  uint64_t io_op_data = 0;
   std::string file_operation;
   uint64_t latency = 0;
   std::string io_status;
-  // Required fields for read.
+  // Stores file name instead of full path.
   std::string file_name;
+
+  // Fields added to record based on IO operation.
   uint64_t len = 0;
   uint64_t offset = 0;
   uint64_t file_size = 0;
 
-  IOTraceRecord() {}
+  // Additional information passed in IODebugContext.
+  uint64_t trace_data = 0;
+  std::string request_id;
 
-  IOTraceRecord(const uint64_t& _access_timestamp, const TraceType& _trace_type,
-                const std::string& _file_operation, const uint64_t& _latency,
-                const std::string& _io_status, const std::string& _file_name)
-      : access_timestamp(_access_timestamp),
-        trace_type(_trace_type),
-        file_operation(_file_operation),
-        latency(_latency),
-        io_status(_io_status),
-        file_name(_file_name) {}
+  IOTraceRecord() {}
 
   IOTraceRecord(const uint64_t& _access_timestamp, const TraceType& _trace_type,
-                const std::string& _file_operation, const uint64_t& _latency,
-                const std::string& _io_status, const std::string& _file_name,
-                const uint64_t& _file_size)
+                const uint64_t& _io_op_data, const std::string& _file_operation,
+                const uint64_t& _latency, const std::string& _io_status,
+                const std::string& _file_name, const uint64_t& _file_size = 0)
       : access_timestamp(_access_timestamp),
         trace_type(_trace_type),
+        io_op_data(_io_op_data),
         file_operation(_file_operation),
         latency(_latency),
         io_status(_io_status),
@@ -54,14 +76,17 @@ struct IOTraceRecord {
         file_size(_file_size) {}
 
   IOTraceRecord(const uint64_t& _access_timestamp, const TraceType& _trace_type,
-                const std::string& _file_operation, const uint64_t& _latency,
-                const std::string& _io_status, const uint64_t& _len = 0,
-                const uint64_t& _offset = 0)
+                const uint64_t& _io_op_data, const std::string& _file_operation,
+                const uint64_t& _latency, const std::string& _io_status,
+                const std::string& _file_name, const uint64_t& _len,
+                const uint64_t& _offset)
       : access_timestamp(_access_timestamp),
         trace_type(_trace_type),
+        io_op_data(_io_op_data),
         file_operation(_file_operation),
         latency(_latency),
         io_status(_io_status),
+        file_name(_file_name),
         len(_len),
         offset(_offset) {}
 };
@@ -76,7 +101,7 @@ struct IOTraceHeader {
 // timestamp and type, followed by the trace payload.
 class IOTraceWriter {
  public:
-  IOTraceWriter(Env* env, const TraceOptions& trace_options,
+  IOTraceWriter(SystemClock* clock, const TraceOptions& trace_options,
                 std::unique_ptr<TraceWriter>&& trace_writer);
   ~IOTraceWriter() = default;
   // No copy and move.
@@ -85,14 +110,14 @@ class IOTraceWriter {
   IOTraceWriter(IOTraceWriter&&) = delete;
   IOTraceWriter& operator=(IOTraceWriter&&) = delete;
 
-  Status WriteIOOp(const IOTraceRecord& record);
+  Status WriteIOOp(const IOTraceRecord& record, IODebugContext* dbg);
 
   // Write a trace header at the beginning, typically on initiating a trace,
   // with some metadata like a magic number and RocksDB version.
   Status WriteHeader();
 
  private:
-  Env* env_;
+  SystemClock* clock_;
   TraceOptions trace_options_;
   std::unique_ptr<TraceWriter> trace_writer_;
 };
@@ -134,23 +159,9 @@ class IOTracer {
   // mutex and ignore the operation if writer_is null. So its ok if
   // tracing_enabled shows non updated value.
 
-#if defined(__clang__)
-#if defined(__has_feature) && __has_feature(thread_sanitizer)
-#define TSAN_SUPPRESSION __attribute__((no_sanitize("thread")))
-#endif  // __has_feature(thread_sanitizer)
-#else   // __clang__
-#ifdef __SANITIZE_THREAD__
-#define TSAN_SUPPRESSION __attribute__((no_sanitize("thread")))
-#endif  // __SANITIZE_THREAD__
-#endif  // __clang__
-
-#ifndef TSAN_SUPPRESSION
-#define TSAN_SUPPRESSION
-#endif  // TSAN_SUPPRESSION
-
   // Start writing IO operations to the trace_writer.
   TSAN_SUPPRESSION Status
-  StartIOTrace(Env* env, const TraceOptions& trace_options,
+  StartIOTrace(SystemClock* clock, const TraceOptions& trace_options,
                std::unique_ptr<TraceWriter>&& trace_writer);
 
   // Stop writing IO operations to the trace_writer.
@@ -158,7 +169,7 @@ class IOTracer {
 
   TSAN_SUPPRESSION bool is_tracing_enabled() const { return tracing_enabled; }
 
-  void WriteIOOp(const IOTraceRecord& record);
+  void WriteIOOp(const IOTraceRecord& record, IODebugContext* dbg);
 
  private:
   TraceOptions trace_options_;