@nxtedition/rocksdb 6.0.1 → 7.0.0-alpha.1

package/deps/rocksdb/rocksdb/microbench/db_basic_bench.cc

@@ -15,6 +15,7 @@
 #include "table/block_based/block.h"
 #include "table/block_based/block_builder.h"
 #include "util/random.h"
+#include "utilities/merge_operators.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -32,7 +33,11 @@ class KeyGenerator {
     if (is_sequential_) {
       assert(next_sequential_key_ < max_key_);
       k = (next_sequential_key_ % max_key_) * MULTIPLIER + offset;
-      next_sequential_key_++;
+      if (next_sequential_key_ + 1 == max_key_) {
+        next_sequential_key_ = 0;
+      } else {
+        next_sequential_key_++;
+      }
     } else {
       k = (rnd_->Next() % max_key_) * MULTIPLIER + offset;
     }
@@ -118,7 +123,8 @@ class KeyGenerator {
   }
 };
 
-static void SetupDB(benchmark::State& state, Options& options, DB** dpptr,
+static void SetupDB(benchmark::State& state, Options& options,
+                    std::unique_ptr<DB>* db,
                     const std::string& test_name = "") {
   options.create_if_missing = true;
   auto env = Env::Default();
@@ -132,15 +138,17 @@ static void SetupDB(benchmark::State& state, Options& options, DB** dpptr,
       db_path + kFilePathSeparator + test_name + std::to_string(getpid());
   DestroyDB(db_name, options);
 
-  s = DB::Open(options, db_name, dpptr);
+  DB* db_ptr = nullptr;
+  s = DB::Open(options, db_name, &db_ptr);
   if (!s.ok()) {
     state.SkipWithError(s.ToString().c_str());
     return;
   }
+  db->reset(db_ptr);
 }
 
-static void TeardownDB(benchmark::State& state, DB* db, const Options& options,
-                       KeyGenerator& kg) {
+static void TeardownDB(benchmark::State& state, const std::unique_ptr<DB>& db,
+                       const Options& options, KeyGenerator& kg) {
   char min_buff[256], max_buff[256];
   const Range r(kg.MinKey(min_buff), kg.MaxKey(max_buff));
   uint64_t size;
@@ -160,7 +168,7 @@ static void TeardownDB(benchmark::State& state, DB* db, const Options& options,
 
 static void DBOpen(benchmark::State& state) {
   // create DB
-  DB* db = nullptr;
+  std::unique_ptr<DB> db;
   Options options;
   SetupDB(state, options, &db, "DBOpen");
 
@@ -172,12 +180,17 @@ static void DBOpen(benchmark::State& state) {
   auto rnd = Random(123);
 
   for (auto _ : state) {
-    Status s = DB::Open(options, db_name, &db);
-    if (!s.ok()) {
-      state.SkipWithError(s.ToString().c_str());
+    {
+      DB* db_ptr = nullptr;
+      Status s = DB::Open(options, db_name, &db_ptr);
+      if (!s.ok()) {
+        state.SkipWithError(s.ToString().c_str());
+      }
+      db.reset(db_ptr);
     }
     state.PauseTiming();
     auto wo = WriteOptions();
+    Status s;
     for (int i = 0; i < 2; i++) {
       for (int j = 0; j < 100; j++) {
         s = db->Put(wo, rnd.RandomString(10), rnd.RandomString(100));
@@ -204,7 +217,7 @@ BENCHMARK(DBOpen)->Iterations(200);  // specify iteration number as the db size
 
 static void DBClose(benchmark::State& state) {
   // create DB
-  DB* db;
+  std::unique_ptr<DB> db;
   Options options;
   SetupDB(state, options, &db, "DBClose");
 
@@ -217,11 +230,16 @@ static void DBClose(benchmark::State& state) {
 
   for (auto _ : state) {
     state.PauseTiming();
-    Status s = DB::Open(options, db_name, &db);
-    if (!s.ok()) {
-      state.SkipWithError(s.ToString().c_str());
+    {
+      DB* db_ptr = nullptr;
+      Status s = DB::Open(options, db_name, &db_ptr);
+      if (!s.ok()) {
+        state.SkipWithError(s.ToString().c_str());
+      }
+      db.reset(db_ptr);
     }
     auto wo = WriteOptions();
+    Status s;
     for (int i = 0; i < 2; i++) {
       for (int j = 0; j < 100; j++) {
         s = db->Put(wo, rnd.RandomString(10), rnd.RandomString(100));
@@ -255,7 +273,7 @@ static void DBPut(benchmark::State& state) {
   uint64_t key_num = max_data / per_key_size;
 
   // setup DB
-  static DB* db = nullptr;
+  static std::unique_ptr<DB> db = nullptr;
   Options options;
   if (enable_statistics) {
     options.statistics = CreateDBStatistics();
@@ -284,7 +302,7 @@ static void DBPut(benchmark::State& state) {
   }
 
   if (state.thread_index() == 0) {
-    auto db_full = static_cast_with_check<DBImpl>(db);
+    auto db_full = static_cast_with_check<DBImpl>(db.get());
     Status s = db_full->WaitForCompact(true);
     if (!s.ok()) {
       state.SkipWithError(s.ToString().c_str());
@@ -332,7 +350,7 @@ static void ManualCompaction(benchmark::State& state) {
   uint64_t key_num = max_data / per_key_size;
 
   // setup DB
-  static DB* db;
+  static std::unique_ptr<DB> db;
   Options options;
   if (enable_statistics) {
     options.statistics = CreateDBStatistics();
@@ -391,7 +409,7 @@ static void ManualCompaction(benchmark::State& state) {
   }
 
   if (state.thread_index() == 0) {
-    auto db_full = static_cast_with_check<DBImpl>(db);
+    auto db_full = static_cast_with_check<DBImpl>(db.get());
     s = db_full->WaitForCompact(true);
     if (!s.ok()) {
       state.SkipWithError(s.ToString().c_str());
@@ -453,7 +471,7 @@ static void ManualFlush(benchmark::State& state) {
   bool enable_statistics = true;
 
   // setup DB
-  static DB* db;
+  static std::unique_ptr<DB> db;
   Options options;
   if (enable_statistics) {
     options.statistics = CreateDBStatistics();
@@ -489,7 +507,7 @@ static void ManualFlush(benchmark::State& state) {
   }
 
   if (state.thread_index() == 0) {
-    auto db_full = static_cast_with_check<DBImpl>(db);
+    auto db_full = static_cast_with_check<DBImpl>(db.get());
     Status s = db_full->WaitForCompact(true);
     if (!s.ok()) {
       state.SkipWithError(s.ToString().c_str());
@@ -525,21 +543,30 @@ static void DBGet(benchmark::State& state) {
   bool enable_statistics = state.range(3);
   bool negative_query = state.range(4);
   bool enable_filter = state.range(5);
+  bool mmap = state.range(6);
   uint64_t key_num = max_data / per_key_size;
 
   // setup DB
-  static DB* db;
+  static std::unique_ptr<DB> db;
   Options options;
   if (enable_statistics) {
     options.statistics = CreateDBStatistics();
   }
+  if (mmap) {
+    options.allow_mmap_reads = true;
+    options.compression = kNoCompression;
+  }
   options.compaction_style = compaction_style;
 
+  BlockBasedTableOptions table_options;
   if (enable_filter) {
-    BlockBasedTableOptions table_options;
     table_options.filter_policy.reset(NewBloomFilterPolicy(10, false));
-    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
   }
+  if (mmap) {
+    table_options.no_block_cache = true;
+    table_options.block_restart_interval = 1;
+  }
+  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
 
   auto rnd = Random(301 + state.thread_index());
   KeyGenerator kg(&rnd, key_num);
@@ -564,7 +591,7 @@ static void DBGet(benchmark::State& state) {
       state.SkipWithError(s.ToString().c_str());
     }
 
-    auto db_full = static_cast_with_check<DBImpl>(db);
+    auto db_full = static_cast_with_check<DBImpl>(db.get());
     s = db_full->WaitForCompact(true);
     if (!s.ok()) {
       state.SkipWithError(s.ToString().c_str());
@@ -573,6 +600,9 @@ static void DBGet(benchmark::State& state) {
   }
 
   auto ro = ReadOptions();
+  if (mmap) {
+    ro.verify_checksums = false;
+  }
   size_t not_found = 0;
   if (negative_query) {
     for (auto _ : state) {
@@ -616,8 +646,10 @@ static void DBGetArguments(benchmark::internal::Benchmark* b) {
         for (bool enable_statistics : {false, true}) {
           for (bool negative_query : {false, true}) {
             for (bool enable_filter : {false, true}) {
-              b->Args({comp_style, max_data, per_key_size, enable_statistics,
-                       negative_query, enable_filter});
+              for (bool mmap : {false, true}) {
+                b->Args({comp_style, max_data, per_key_size, enable_statistics,
+                         negative_query, enable_filter, mmap});
+              }
             }
           }
         }
@@ -625,16 +657,16 @@ static void DBGetArguments(benchmark::internal::Benchmark* b) {
     }
   }
   b->ArgNames({"comp_style", "max_data", "per_key_size", "enable_statistics",
-               "negative_query", "enable_filter"});
+               "negative_query", "enable_filter", "mmap"});
 }
 
-static constexpr uint64_t kDBGetNum = 10l << 10;
+static constexpr uint64_t kDBGetNum = 1l << 20;
 BENCHMARK(DBGet)->Threads(1)->Iterations(kDBGetNum)->Apply(DBGetArguments);
 BENCHMARK(DBGet)->Threads(8)->Iterations(kDBGetNum / 8)->Apply(DBGetArguments);
 
 static void SimpleGetWithPerfContext(benchmark::State& state) {
   // setup DB
-  static DB* db;
+  static std::unique_ptr<DB> db;
   std::string db_name;
   Options options;
   options.create_if_missing = true;
@@ -654,10 +686,14 @@ static void SimpleGetWithPerfContext(benchmark::State& state) {
     db_name = db_path + "/simple_get_" + std::to_string(getpid());
     DestroyDB(db_name, options);
 
-    s = DB::Open(options, db_name, &db);
-    if (!s.ok()) {
-      state.SkipWithError(s.ToString().c_str());
-      return;
+    {
+      DB* db_ptr = nullptr;
+      s = DB::Open(options, db_name, &db_ptr);
+      if (!s.ok()) {
+        state.SkipWithError(s.ToString().c_str());
+        return;
+      }
+      db.reset(db_ptr);
     }
     // load db
     auto wo = WriteOptions();
@@ -668,7 +704,7 @@ static void SimpleGetWithPerfContext(benchmark::State& state) {
         state.SkipWithError(s.ToString().c_str());
       }
     }
-    auto db_full = static_cast_with_check<DBImpl>(db);
+    auto db_full = static_cast_with_check<DBImpl>(db.get());
     s = db_full->WaitForCompact(true);
     if (!s.ok()) {
       state.SkipWithError(s.ToString().c_str());
@@ -755,6 +791,191 @@ static void SimpleGetWithPerfContext(benchmark::State& state) {
 
 BENCHMARK(SimpleGetWithPerfContext)->Iterations(1000000);
 
+static void DBGetMergeOperandsInMemtable(benchmark::State& state) {
+  const uint64_t kDataLen = 16 << 20;  // 16MB
+  const uint64_t kValueLen = 64;
+  const uint64_t kNumEntries = kDataLen / kValueLen;
+  const uint64_t kNumEntriesPerKey = state.range(0);
+  const uint64_t kNumKeys = kNumEntries / kNumEntriesPerKey;
+
+  // setup DB
+  static std::unique_ptr<DB> db;
+
+  Options options;
+  options.merge_operator = MergeOperators::CreateStringAppendOperator();
+  // Make memtable large enough that automatic flush will not be triggered.
+  options.write_buffer_size = 2 * kDataLen;
+
+  KeyGenerator sequential_key_gen(kNumKeys);
+  auto rnd = Random(301 + state.thread_index());
+
+  if (state.thread_index() == 0) {
+    SetupDB(state, options, &db, "DBGetMergeOperandsInMemtable");
+
+    // load db
+    auto write_opts = WriteOptions();
+    write_opts.disableWAL = true;
+    for (uint64_t i = 0; i < kNumEntries; i++) {
+      Status s = db->Merge(write_opts, sequential_key_gen.Next(),
+                           rnd.RandomString(static_cast<int>(kValueLen)));
+      if (!s.ok()) {
+        state.SkipWithError(s.ToString().c_str());
+      }
+    }
+  }
+
+  KeyGenerator random_key_gen(kNumKeys);
+  std::vector<PinnableSlice> value_operands;
+  value_operands.resize(kNumEntriesPerKey);
+  GetMergeOperandsOptions get_merge_ops_opts;
+  get_merge_ops_opts.expected_max_number_of_operands =
+      static_cast<int>(kNumEntriesPerKey);
+  for (auto _ : state) {
+    int num_value_operands = 0;
+    Status s = db->GetMergeOperands(
+        ReadOptions(), db->DefaultColumnFamily(), random_key_gen.Next(),
+        value_operands.data(), &get_merge_ops_opts, &num_value_operands);
+    if (!s.ok()) {
+      state.SkipWithError(s.ToString().c_str());
+    }
+    if (num_value_operands != static_cast<int>(kNumEntriesPerKey)) {
+      state.SkipWithError("Unexpected number of merge operands found for key");
+    }
+  }
+
+  if (state.thread_index() == 0) {
+    TeardownDB(state, db, options, random_key_gen);
+  }
+}
+
+static void DBGetMergeOperandsInSstFile(benchmark::State& state) {
+  const uint64_t kDataLen = 16 << 20;  // 16MB
+  const uint64_t kValueLen = 64;
+  const uint64_t kNumEntries = kDataLen / kValueLen;
+  const uint64_t kNumEntriesPerKey = state.range(0);
+  const uint64_t kNumKeys = kNumEntries / kNumEntriesPerKey;
+  const bool kMmap = state.range(1);
+
+  // setup DB
+  static std::unique_ptr<DB> db;
+
+  BlockBasedTableOptions table_options;
+  if (kMmap) {
+    table_options.no_block_cache = true;
+  } else {
+    // Make block cache large enough that eviction will not be triggered.
+    table_options.block_cache = NewLRUCache(2 * kDataLen);
+  }
+
+  Options options;
+  if (kMmap) {
+    options.allow_mmap_reads = true;
+  }
+  options.compression = kNoCompression;
+  options.merge_operator = MergeOperators::CreateStringAppendOperator();
+  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  // Make memtable large enough that automatic flush will not be triggered.
+  options.write_buffer_size = 2 * kDataLen;
+
+  KeyGenerator sequential_key_gen(kNumKeys);
+  auto rnd = Random(301 + state.thread_index());
+
+  if (state.thread_index() == 0) {
+    SetupDB(state, options, &db, "DBGetMergeOperandsInBlockCache");
+
+    // load db
+    //
+    // Take a snapshot after each cycle of merges to ensure flush cannot
+    // merge any entries.
+    std::vector<const Snapshot*> snapshots;
+    snapshots.resize(kNumEntriesPerKey);
+    auto write_opts = WriteOptions();
+    write_opts.disableWAL = true;
+    for (uint64_t i = 0; i < kNumEntriesPerKey; i++) {
+      for (uint64_t j = 0; j < kNumKeys; j++) {
+        Status s = db->Merge(write_opts, sequential_key_gen.Next(),
+                             rnd.RandomString(static_cast<int>(kValueLen)));
+        if (!s.ok()) {
+          state.SkipWithError(s.ToString().c_str());
+        }
+      }
+      snapshots[i] = db->GetSnapshot();
+    }
+
+    // Flush to an L0 file; read back to prime the cache/mapped memory.
+    db->Flush(FlushOptions());
+    for (uint64_t i = 0; i < kNumKeys; ++i) {
+      std::string value;
+      Status s = db->Get(ReadOptions(), sequential_key_gen.Next(), &value);
+      if (!s.ok()) {
+        state.SkipWithError(s.ToString().c_str());
+      }
+    }
+
+    if (state.thread_index() == 0) {
+      for (uint64_t i = 0; i < kNumEntriesPerKey; ++i) {
+        db->ReleaseSnapshot(snapshots[i]);
+      }
+    }
+  }
+
+  KeyGenerator random_key_gen(kNumKeys);
+  std::vector<PinnableSlice> value_operands;
+  value_operands.resize(kNumEntriesPerKey);
+  GetMergeOperandsOptions get_merge_ops_opts;
+  get_merge_ops_opts.expected_max_number_of_operands =
+      static_cast<int>(kNumEntriesPerKey);
+  for (auto _ : state) {
+    int num_value_operands = 0;
+    ReadOptions read_opts;
+    read_opts.verify_checksums = false;
+    Status s = db->GetMergeOperands(
+        read_opts, db->DefaultColumnFamily(), random_key_gen.Next(),
+        value_operands.data(), &get_merge_ops_opts, &num_value_operands);
+    if (!s.ok()) {
+      state.SkipWithError(s.ToString().c_str());
+    }
+    if (num_value_operands != static_cast<int>(kNumEntriesPerKey)) {
+      state.SkipWithError("Unexpected number of merge operands found for key");
+    }
+  }
+
+  if (state.thread_index() == 0) {
+    TeardownDB(state, db, options, random_key_gen);
+  }
+}
+
+static void DBGetMergeOperandsInMemtableArguments(
+    benchmark::internal::Benchmark* b) {
+  for (int entries_per_key : {1, 32, 1024}) {
+    b->Args({entries_per_key});
+  }
+  b->ArgNames({"entries_per_key"});
+}
+
+static void DBGetMergeOperandsInSstFileArguments(
+    benchmark::internal::Benchmark* b) {
+  for (int entries_per_key : {1, 32, 1024}) {
+    for (bool mmap : {false, true}) {
+      b->Args({entries_per_key, mmap});
+    }
+  }
+  b->ArgNames({"entries_per_key", "mmap"});
+}
+
+BENCHMARK(DBGetMergeOperandsInMemtable)
+    ->Threads(1)
+    ->Apply(DBGetMergeOperandsInMemtableArguments);
+BENCHMARK(DBGetMergeOperandsInMemtable)
+    ->Threads(8)
+    ->Apply(DBGetMergeOperandsInMemtableArguments);
+BENCHMARK(DBGetMergeOperandsInSstFile)
+    ->Threads(1)
+    ->Apply(DBGetMergeOperandsInSstFileArguments);
+BENCHMARK(DBGetMergeOperandsInSstFile)
+    ->Threads(8)
+    ->Apply(DBGetMergeOperandsInSstFileArguments);
+
 std::string GenerateKey(int primary_key, int secondary_key, int padding_size,
                         Random* rnd) {
   char buf[50];
@@ -844,7 +1065,7 @@ static void IteratorSeek(benchmark::State& state) {
   uint64_t key_num = max_data / per_key_size;
 
   // setup DB
-  static DB* db;
+  static std::unique_ptr<DB> db;
   Options options;
   if (enable_statistics) {
     options.statistics = CreateDBStatistics();
@@ -880,7 +1101,7 @@ static void IteratorSeek(benchmark::State& state) {
       state.SkipWithError(s.ToString().c_str());
     }
 
-    auto db_full = static_cast_with_check<DBImpl>(db);
+    auto db_full = static_cast_with_check<DBImpl>(db.get());
     s = db_full->WaitForCompact(true);
     if (!s.ok()) {
       state.SkipWithError(s.ToString().c_str());
@@ -947,7 +1168,7 @@ static void IteratorNext(benchmark::State& state) {
   uint64_t key_num = max_data / per_key_size;
 
   // setup DB
-  static DB* db;
+  static std::unique_ptr<DB> db;
   Options options;
   options.compaction_style = compaction_style;
 
@@ -973,7 +1194,7 @@ static void IteratorNext(benchmark::State& state) {
       state.SkipWithError(s.ToString().c_str());
     }
 
-    auto db_full = static_cast_with_check<DBImpl>(db);
+    auto db_full = static_cast_with_check<DBImpl>(db.get());
     s = db_full->WaitForCompact(true);
     if (!s.ok()) {
       state.SkipWithError(s.ToString().c_str());
@@ -1022,7 +1243,7 @@ BENCHMARK(IteratorNext)
 
 static void IteratorNextWithPerfContext(benchmark::State& state) {
   // setup DB
-  static DB* db;
+  static std::unique_ptr<DB> db;
   Options options;
 
   auto rnd = Random(301 + state.thread_index());
@@ -1039,7 +1260,7 @@ static void IteratorNextWithPerfContext(benchmark::State& state) {
         state.SkipWithError(s.ToString().c_str());
       }
     }
-    auto db_full = static_cast_with_check<DBImpl>(db);
+    auto db_full = static_cast_with_check<DBImpl>(db.get());
     Status s = db_full->WaitForCompact(true);
     if (!s.ok()) {
       state.SkipWithError(s.ToString().c_str());
@@ -1114,7 +1335,7 @@ static void IteratorPrev(benchmark::State& state) {
   uint64_t key_num = max_data / per_key_size;
 
   // setup DB
-  static DB* db;
+  static std::unique_ptr<DB> db;
   std::string db_name;
   Options options;
   options.compaction_style = compaction_style;
@@ -1141,7 +1362,7 @@ static void IteratorPrev(benchmark::State& state) {
       state.SkipWithError(s.ToString().c_str());
     }
 
-    auto db_full = static_cast_with_check<DBImpl>(db);
+    auto db_full = static_cast_with_check<DBImpl>(db.get());
     s = db_full->WaitForCompact(true);
     if (!s.ok()) {
       state.SkipWithError(s.ToString().c_str());
@@ -1198,7 +1419,7 @@ static void PrefixSeek(benchmark::State& state) {
   uint64_t key_num = max_data / per_key_size;
 
   // setup DB
-  static DB* db;
+  static std::unique_ptr<DB> db;
   Options options;
   if (enable_statistics) {
     options.statistics = CreateDBStatistics();
@@ -1235,7 +1456,7 @@ static void PrefixSeek(benchmark::State& state) {
       state.SkipWithError(s.ToString().c_str());
     }
 
-    auto db_full = static_cast_with_check<DBImpl>(db);
+    auto db_full = static_cast_with_check<DBImpl>(db.get());
     s = db_full->WaitForCompact(true);
     if (!s.ok()) {
       state.SkipWithError(s.ToString().c_str());
@@ -1311,7 +1532,7 @@ static void RandomAccessFileReaderRead(benchmark::State& state) {
   auto statistics_share = CreateDBStatistics();
   Statistics* statistics = enable_statistics ? statistics_share.get() : nullptr;
   for (int i = 0; i < kFileNum; i++) {
-    std::string fname = fname_base + ToString(i);
+    std::string fname = fname_base + std::to_string(i);
     std::string content = rand.RandomString(kDefaultPageSize);
     std::unique_ptr<WritableFile> tgt_file;
     env->NewWritableFile(fname, &tgt_file, EnvOptions());
@@ -1344,7 +1565,7 @@ static void RandomAccessFileReaderRead(benchmark::State& state) {
 
   // clean up
   for (int i = 0; i < kFileNum; i++) {
-    std::string fname = fname_base + ToString(i);
+    std::string fname = fname_base + std::to_string(i);
     env->DeleteFile(fname);  // ignore return, okay to fail cleanup
   }
 }

package/deps/rocksdb/rocksdb/monitoring/histogram.cc

@@ -26,7 +26,8 @@ HistogramBucketMapper::HistogramBucketMapper() {
   // size of array buckets_ in HistogramImpl
   bucketValues_ = {1, 2};
   double bucket_val = static_cast<double>(bucketValues_.back());
-  while ((bucket_val = 1.5 * bucket_val) <= static_cast<double>(port::kMaxUint64)) {
+  while ((bucket_val = 1.5 * bucket_val) <=
+         static_cast<double>(std::numeric_limits<uint64_t>::max())) {
     bucketValues_.push_back(static_cast<uint64_t>(bucket_val));
     // Extracts two most significant digits to make histogram buckets more
     // human-readable. E.g., 172 becomes 170.

package/deps/rocksdb/rocksdb/monitoring/iostats_context.cc

@@ -13,11 +13,8 @@ namespace ROCKSDB_NAMESPACE {
 // Should not be used because the counters are not thread-safe.
 // Put here just to make get_iostats_context() simple without ifdef.
 static IOStatsContext iostats_context;
-#elif defined(ROCKSDB_SUPPORT_THREAD_LOCAL)
-__thread IOStatsContext iostats_context;
 #else
-#error \
-    "No thread-local support. Disable iostats context with -DNIOSTATS_CONTEXT."
+thread_local IOStatsContext iostats_context;
 #endif
 
 IOStatsContext* get_iostats_context() {

package/deps/rocksdb/rocksdb/monitoring/iostats_context_imp.h

@@ -7,9 +7,9 @@
 #include "monitoring/perf_step_timer.h"
 #include "rocksdb/iostats_context.h"
 
-#if defined(ROCKSDB_SUPPORT_THREAD_LOCAL) && !defined(NIOSTATS_CONTEXT)
+#if !defined(NIOSTATS_CONTEXT)
 namespace ROCKSDB_NAMESPACE {
-extern __thread IOStatsContext iostats_context;
+extern thread_local IOStatsContext iostats_context;
 }  // namespace ROCKSDB_NAMESPACE
 
 // increment a specific counter by the specified value
@@ -40,7 +40,7 @@ extern __thread IOStatsContext iostats_context;
       PerfLevel::kEnableTimeAndCPUTimeExceptForMutex); \
   iostats_step_timer_##metric.Start();
 
-#else  // ROCKSDB_SUPPORT_THREAD_LOCAL && !NIOSTATS_CONTEXT
+#else  // !NIOSTATS_CONTEXT
 
 #define IOSTATS_ADD(metric, value)
 #define IOSTATS_ADD_IF_POSITIVE(metric, value)
@@ -53,4 +53,4 @@ extern __thread IOStatsContext iostats_context;
 #define IOSTATS_TIMER_GUARD(metric)
 #define IOSTATS_CPU_TIMER_GUARD(metric, clock) static_cast<void>(clock)
 
-#endif  // ROCKSDB_SUPPORT_THREAD_LOCAL && !NIOSTATS_CONTEXT
+#endif  // !NIOSTATS_CONTEXT

package/deps/rocksdb/rocksdb/monitoring/perf_context.cc

@@ -13,14 +13,8 @@ namespace ROCKSDB_NAMESPACE {
 // Should not be used because the counters are not thread-safe.
 // Put here just to make get_perf_context() simple without ifdef.
 PerfContext perf_context;
-#elif defined(ROCKSDB_SUPPORT_THREAD_LOCAL)
-#if defined(OS_SOLARIS)
-__thread PerfContext perf_context;
-#else   // OS_SOLARIS
-thread_local PerfContext perf_context;
-#endif  // OS_SOLARIS
 #else
-#error "No thread-local support. Disable perf context with -DNPERF_CONTEXT."
+thread_local PerfContext perf_context;
 #endif
 
 PerfContext* get_perf_context() {
@@ -28,7 +22,7 @@ PerfContext* get_perf_context() {
 }
 
 PerfContext::~PerfContext() {
-#if !defined(NPERF_CONTEXT) && defined(ROCKSDB_SUPPORT_THREAD_LOCAL) && !defined(OS_SOLARIS)
+#if !defined(NPERF_CONTEXT) && !defined(OS_SOLARIS)
   ClearPerLevelPerfContext();
 #endif
 }
@@ -120,6 +114,7 @@ PerfContext::PerfContext(const PerfContext& other) {
   iter_next_cpu_nanos = other.iter_next_cpu_nanos;
   iter_prev_cpu_nanos = other.iter_prev_cpu_nanos;
   iter_seek_cpu_nanos = other.iter_seek_cpu_nanos;
+  number_async_seek = other.number_async_seek;
   if (per_level_perf_context_enabled && level_to_perf_context != nullptr) {
     ClearPerLevelPerfContext();
   }
@@ -218,6 +213,7 @@ PerfContext::PerfContext(PerfContext&& other) noexcept {
   iter_next_cpu_nanos = other.iter_next_cpu_nanos;
   iter_prev_cpu_nanos = other.iter_prev_cpu_nanos;
   iter_seek_cpu_nanos = other.iter_seek_cpu_nanos;
+  number_async_seek = other.number_async_seek;
   if (per_level_perf_context_enabled && level_to_perf_context != nullptr) {
     ClearPerLevelPerfContext();
   }
@@ -318,6 +314,7 @@ PerfContext& PerfContext::operator=(const PerfContext& other) {
   iter_next_cpu_nanos = other.iter_next_cpu_nanos;
   iter_prev_cpu_nanos = other.iter_prev_cpu_nanos;
   iter_seek_cpu_nanos = other.iter_seek_cpu_nanos;
+  number_async_seek = other.number_async_seek;
   if (per_level_perf_context_enabled && level_to_perf_context != nullptr) {
     ClearPerLevelPerfContext();
   }
@@ -413,6 +410,7 @@ void PerfContext::Reset() {
   iter_next_cpu_nanos = 0;
   iter_prev_cpu_nanos = 0;
   iter_seek_cpu_nanos = 0;
+  number_async_seek = 0;
   if (per_level_perf_context_enabled && level_to_perf_context) {
     for (auto& kv : *level_to_perf_context) {
       kv.second.Reset();
@@ -532,6 +530,7 @@ std::string PerfContext::ToString(bool exclude_zero_counters) const {
   PERF_CONTEXT_OUTPUT(iter_next_cpu_nanos);
   PERF_CONTEXT_OUTPUT(iter_prev_cpu_nanos);
   PERF_CONTEXT_OUTPUT(iter_seek_cpu_nanos);
+  PERF_CONTEXT_OUTPUT(number_async_seek);
   PERF_CONTEXT_BY_LEVEL_OUTPUT_ONE_COUNTER(bloom_filter_useful);
   PERF_CONTEXT_BY_LEVEL_OUTPUT_ONE_COUNTER(bloom_filter_full_positive);
   PERF_CONTEXT_BY_LEVEL_OUTPUT_ONE_COUNTER(bloom_filter_full_true_positive);