@nxtedition/rocksdb 7.1.29 → 7.1.31

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

@@ -9,9 +9,11 @@
 
 #pragma once
 #include <assert.h>
+
 #include <atomic>
 #include <mutex>
 #include <thread>
+
 #include "port/port.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -28,9 +30,7 @@ namespace ROCKSDB_NAMESPACE {
 
 class MutexLock {
  public:
-  explicit MutexLock(port::Mutex *mu) : mu_(mu) {
-    this->mu_->Lock();
-  }
+  explicit MutexLock(port::Mutex *mu) : mu_(mu) { this->mu_->Lock(); }
   // No copying allowed
   MutexLock(const MutexLock &) = delete;
   void operator=(const MutexLock &) = delete;
@@ -48,9 +48,7 @@ class MutexLock {
 //
 class ReadLock {
  public:
-  explicit ReadLock(port::RWMutex *mu) : mu_(mu) {
-    this->mu_->ReadLock();
-  }
+  explicit ReadLock(port::RWMutex *mu) : mu_(mu) { this->mu_->ReadLock(); }
   // No copying allowed
   ReadLock(const ReadLock &) = delete;
   void operator=(const ReadLock &) = delete;
@@ -84,9 +82,7 @@ class ReadUnlock {
 //
 class WriteLock {
  public:
-  explicit WriteLock(port::RWMutex *mu) : mu_(mu) {
-    this->mu_->WriteLock();
-  }
+  explicit WriteLock(port::RWMutex *mu) : mu_(mu) { this->mu_->WriteLock(); }
   // No copying allowed
   WriteLock(const WriteLock &) = delete;
   void operator=(const WriteLock &) = delete;
@@ -152,13 +148,11 @@ class Striped {
  public:
   Striped(size_t stripes, std::function<uint64_t(const P &)> hash)
       : stripes_(stripes), hash_(hash) {
-
     locks_ = reinterpret_cast<LockData<T> *>(
         port::cacheline_aligned_alloc(sizeof(LockData<T>) * stripes));
     for (size_t i = 0; i < stripes; i++) {
       new (&locks_[i]) LockData<T>();
     }
-
   }
 
   virtual ~Striped() {

package/deps/rocksdb/rocksdb/util/random.cc

@@ -8,6 +8,7 @@
 
 #include <stdint.h>
 #include <string.h>
+
 #include <thread>
 #include <utility>
 

package/deps/rocksdb/rocksdb/util/random.h

@@ -85,9 +85,7 @@ class Random {
   // Skewed: pick "base" uniformly from range [0,max_log] and then
   // return "base" random bits.  The effect is to pick a number in the
   // range [0,2^max_log-1] with exponential bias towards smaller numbers.
-  uint32_t Skewed(int max_log) {
-    return Uniform(1 << Uniform(max_log + 1));
-  }
+  uint32_t Skewed(int max_log) { return Uniform(1 << Uniform(max_log + 1)); }
 
   // Returns a random string of length "len"
   std::string RandomString(int len);
@@ -153,7 +151,7 @@ class Random64 {
   std::mt19937_64 generator_;
 
  public:
-  explicit Random64(uint64_t s) : generator_(s) { }
+  explicit Random64(uint64_t s) : generator_(s) {}
 
   // Generates the next random number
   uint64_t Next() { return generator_(); }

package/deps/rocksdb/rocksdb/util/random_test.cc

@@ -7,11 +7,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
+#include "util/random.h"
+
 #include <cstring>
 #include <vector>
 
 #include "test_util/testharness.h"
-#include "util/random.h"
 
 using ROCKSDB_NAMESPACE::Random;
 

package/deps/rocksdb/rocksdb/util/ribbon_test.cc

@@ -836,9 +836,10 @@ TYPED_TEST(RibbonTypeParamTest, CompactnessAndBacktrackAndFpRate) {
       double single_failure_rate = 1.0 * total_single_failures / total_singles;
       fprintf(stderr, "Add'l single, failure rate: %g\n", single_failure_rate);
       // A rough bound (one sided) based on nothing in particular
-      double expected_single_failures =
-          1.0 * total_singles /
-          (sizeof(CoeffRow) == 16 ? 128 : TypeParam::kUseSmash ? 64 : 32);
+      double expected_single_failures = 1.0 * total_singles /
+                                        (sizeof(CoeffRow) == 16 ? 128
+                                         : TypeParam::kUseSmash ? 64
+                                                                : 32);
       EXPECT_LE(total_single_failures,
                 InfrequentPoissonUpperBound(expected_single_failures));
     }

package/deps/rocksdb/rocksdb/util/slice.cc

@@ -128,7 +128,7 @@ class CappedPrefixTransform : public SliceTransform {
 
 class NoopTransform : public SliceTransform {
  public:
-  explicit NoopTransform() { }
+  explicit NoopTransform() {}
 
   static const char* kClassName() { return "rocksdb.Noop"; }
   const char* Name() const override { return kClassName(); }

package/deps/rocksdb/rocksdb/util/slice_test.cc

@@ -32,8 +32,7 @@ void Multiplier(void* arg1, void* arg2) {
 
 class PinnableSliceTest : public testing::Test {
  public:
-  void AssertSameData(const std::string& expected,
-                      const PinnableSlice& slice) {
+  void AssertSameData(const std::string& expected, const PinnableSlice& slice) {
     std::string got;
     got.assign(slice.data(), slice.size());
     ASSERT_EQ(expected, got);

package/deps/rocksdb/rocksdb/util/status.cc

@@ -8,11 +8,13 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "rocksdb/status.h"
+
 #include <stdio.h>
 #ifdef OS_WIN
 #include <string.h>
 #endif
 #include <cstring>
+
 #include "port/port.h"
 
 namespace ROCKSDB_NAMESPACE {

package/deps/rocksdb/rocksdb/util/string_util.cc

@@ -8,6 +8,7 @@
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
+
 #include <algorithm>
 #include <cinttypes>
 #include <cmath>
@@ -15,6 +16,7 @@
 #include <string>
 #include <utility>
 #include <vector>
+
 #include "port/port.h"
 #include "port/sys_time.h"
 #include "rocksdb/slice.h"

package/deps/rocksdb/rocksdb/util/thread_list_test.cc

@@ -3,8 +3,8 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#include <mutex>
 #include <condition_variable>
+#include <mutex>
 
 #include "monitoring/thread_status_updater.h"
 #include "rocksdb/db.h"
@@ -17,16 +17,19 @@ namespace ROCKSDB_NAMESPACE {
 class SimulatedBackgroundTask {
  public:
   SimulatedBackgroundTask(
-      const void* db_key, const std::string& db_name,
-      const void* cf_key, const std::string& cf_name,
+      const void* db_key, const std::string& db_name, const void* cf_key,
+      const std::string& cf_name,
       const ThreadStatus::OperationType operation_type =
           ThreadStatus::OP_UNKNOWN,
-      const ThreadStatus::StateType state_type =
-          ThreadStatus::STATE_UNKNOWN)
-      : db_key_(db_key), db_name_(db_name),
-        cf_key_(cf_key), cf_name_(cf_name),
-        operation_type_(operation_type), state_type_(state_type),
-        should_run_(true), running_count_(0) {
+      const ThreadStatus::StateType state_type = ThreadStatus::STATE_UNKNOWN)
+      : db_key_(db_key),
+        db_name_(db_name),
+        cf_key_(cf_key),
+        cf_name_(cf_name),
+        operation_type_(operation_type),
+        state_type_(state_type),
+        should_run_(true),
+        running_count_(0) {
     Env::Default()->GetThreadStatusUpdater()->NewColumnFamilyInfo(
         db_key_, db_name_, cf_key_, cf_name_);
   }
@@ -92,24 +95,22 @@ class SimulatedBackgroundTask {
 
 class ThreadListTest : public testing::Test {
  public:
-  ThreadListTest() {
-  }
+  ThreadListTest() {}
 };
 
 TEST_F(ThreadListTest, GlobalTables) {
   // verify the global tables for operations and states are properly indexed.
   for (int type = 0; type != ThreadStatus::NUM_OP_TYPES; ++type) {
     ASSERT_EQ(global_operation_table[type].type, type);
-    ASSERT_EQ(global_operation_table[type].name,
-              ThreadStatus::GetOperationName(
-                  ThreadStatus::OperationType(type)));
+    ASSERT_EQ(
+        global_operation_table[type].name,
+        ThreadStatus::GetOperationName(ThreadStatus::OperationType(type)));
   }
 
   for (int type = 0; type != ThreadStatus::NUM_STATE_TYPES; ++type) {
     ASSERT_EQ(global_state_table[type].type, type);
     ASSERT_EQ(global_state_table[type].name,
-              ThreadStatus::GetStateName(
-                  ThreadStatus::StateType(type)));
+              ThreadStatus::GetStateName(ThreadStatus::StateType(type)));
   }
 
   for (int stage = 0; stage != ThreadStatus::NUM_OP_STAGES; ++stage) {
@@ -131,18 +132,18 @@ TEST_F(ThreadListTest, SimpleColumnFamilyInfoTest) {
   env->SetBackgroundThreads(kLowPriorityThreads, Env::LOW);
   // Wait 1 second so that threads start
   Env::Default()->SleepForMicroseconds(kDelayMicros);
-  SimulatedBackgroundTask running_task(
-      reinterpret_cast<void*>(1234), "running",
-      reinterpret_cast<void*>(5678), "pikachu");
+  SimulatedBackgroundTask running_task(reinterpret_cast<void*>(1234), "running",
+                                       reinterpret_cast<void*>(5678),
+                                       "pikachu");
 
   for (int test = 0; test < kSimulatedHighPriThreads; ++test) {
-    env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask,
-        &running_task, Env::Priority::HIGH);
+    env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask, &running_task,
+                  Env::Priority::HIGH);
   }
 
   for (int test = 0; test < kSimulatedLowPriThreads; ++test) {
-    env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask,
-        &running_task, Env::Priority::LOW);
+    env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask, &running_task,
+                  Env::Priority::LOW);
   }
   running_task.WaitUntilScheduled(kSimulatedHighPriThreads +
                                   kSimulatedLowPriThreads);
@@ -168,14 +169,10 @@ TEST_F(ThreadListTest, SimpleColumnFamilyInfoTest) {
   ASSERT_EQ(0, env->ReserveThreads(kHighPriorityThreads, Env::Priority::HIGH));
   ASSERT_EQ(0, env->ReserveThreads(kLowPriorityThreads, Env::Priority::LOW));
 
-  ASSERT_EQ(
-      running_count[ThreadStatus::HIGH_PRIORITY],
-      kSimulatedHighPriThreads);
-  ASSERT_EQ(
-      running_count[ThreadStatus::LOW_PRIORITY],
-      kSimulatedLowPriThreads);
-  ASSERT_EQ(
-      running_count[ThreadStatus::USER], 0);
+  ASSERT_EQ(running_count[ThreadStatus::HIGH_PRIORITY],
+            kSimulatedHighPriThreads);
+  ASSERT_EQ(running_count[ThreadStatus::LOW_PRIORITY], kSimulatedLowPriThreads);
+  ASSERT_EQ(running_count[ThreadStatus::USER], 0);
 
   running_task.FinishAllTasks();
   running_task.WaitUntilDone();
@@ -197,37 +194,33 @@ TEST_F(ThreadListTest, SimpleColumnFamilyInfoTest) {
     }
   }
 
-  ASSERT_EQ(
-      running_count[ThreadStatus::HIGH_PRIORITY], 0);
-  ASSERT_EQ(
-      running_count[ThreadStatus::LOW_PRIORITY], 0);
-  ASSERT_EQ(
-      running_count[ThreadStatus::USER], 0);
+  ASSERT_EQ(running_count[ThreadStatus::HIGH_PRIORITY], 0);
+  ASSERT_EQ(running_count[ThreadStatus::LOW_PRIORITY], 0);
+  ASSERT_EQ(running_count[ThreadStatus::USER], 0);
 }
 
 namespace {
-  void UpdateStatusCounts(
-      const std::vector<ThreadStatus>& thread_list,
-      int operation_counts[], int state_counts[]) {
-    for (auto thread_status : thread_list) {
-      operation_counts[thread_status.operation_type]++;
-      state_counts[thread_status.state_type]++;
-    }
+void UpdateStatusCounts(const std::vector<ThreadStatus>& thread_list,
+                        int operation_counts[], int state_counts[]) {
+  for (auto thread_status : thread_list) {
+    operation_counts[thread_status.operation_type]++;
+    state_counts[thread_status.state_type]++;
   }
+}
 
-  void VerifyAndResetCounts(
-      const int correct_counts[], int collected_counts[], int size) {
-    for (int i = 0; i < size; ++i) {
-      ASSERT_EQ(collected_counts[i], correct_counts[i]);
-      collected_counts[i] = 0;
-    }
+void VerifyAndResetCounts(const int correct_counts[], int collected_counts[],
+                          int size) {
+  for (int i = 0; i < size; ++i) {
+    ASSERT_EQ(collected_counts[i], correct_counts[i]);
+    collected_counts[i] = 0;
   }
+}
 
-  void UpdateCount(
-      int operation_counts[], int from_event, int to_event, int amount) {
-    operation_counts[from_event] -= amount;
-    operation_counts[to_event] += amount;
-  }
+void UpdateCount(int operation_counts[], int from_event, int to_event,
+                 int amount) {
+  operation_counts[from_event] -= amount;
+  operation_counts[to_event] += amount;
+}
 }  // namespace
 
 TEST_F(ThreadListTest, SimpleEventTest) {
@@ -236,62 +229,57 @@ TEST_F(ThreadListTest, SimpleEventTest) {
   // simulated tasks
   const int kFlushWriteTasks = 3;
   SimulatedBackgroundTask flush_write_task(
-      reinterpret_cast<void*>(1234), "running",
-      reinterpret_cast<void*>(5678), "pikachu",
-      ThreadStatus::OP_FLUSH);
+      reinterpret_cast<void*>(1234), "running", reinterpret_cast<void*>(5678),
+      "pikachu", ThreadStatus::OP_FLUSH);
 
   const int kCompactionWriteTasks = 4;
   SimulatedBackgroundTask compaction_write_task(
-      reinterpret_cast<void*>(1234), "running",
-      reinterpret_cast<void*>(5678), "pikachu",
-      ThreadStatus::OP_COMPACTION);
+      reinterpret_cast<void*>(1234), "running", reinterpret_cast<void*>(5678),
+      "pikachu", ThreadStatus::OP_COMPACTION);
 
   const int kCompactionReadTasks = 5;
   SimulatedBackgroundTask compaction_read_task(
-      reinterpret_cast<void*>(1234), "running",
-      reinterpret_cast<void*>(5678), "pikachu",
-      ThreadStatus::OP_COMPACTION);
+      reinterpret_cast<void*>(1234), "running", reinterpret_cast<void*>(5678),
+      "pikachu", ThreadStatus::OP_COMPACTION);
 
   const int kCompactionWaitTasks = 6;
   SimulatedBackgroundTask compaction_wait_task(
-      reinterpret_cast<void*>(1234), "running",
-      reinterpret_cast<void*>(5678), "pikachu",
-      ThreadStatus::OP_COMPACTION);
+      reinterpret_cast<void*>(1234), "running", reinterpret_cast<void*>(5678),
+      "pikachu", ThreadStatus::OP_COMPACTION);
 
   // setup right answers
   int correct_operation_counts[ThreadStatus::NUM_OP_TYPES] = {0};
-  correct_operation_counts[ThreadStatus::OP_FLUSH] =
-      kFlushWriteTasks;
+  correct_operation_counts[ThreadStatus::OP_FLUSH] = kFlushWriteTasks;
   correct_operation_counts[ThreadStatus::OP_COMPACTION] =
       kCompactionWriteTasks + kCompactionReadTasks + kCompactionWaitTasks;
 
-  env->SetBackgroundThreads(
-      correct_operation_counts[ThreadStatus::OP_FLUSH], Env::HIGH);
+  env->SetBackgroundThreads(correct_operation_counts[ThreadStatus::OP_FLUSH],
+                            Env::HIGH);
   env->SetBackgroundThreads(
       correct_operation_counts[ThreadStatus::OP_COMPACTION], Env::LOW);
 
   // schedule the simulated tasks
   for (int t = 0; t < kFlushWriteTasks; ++t) {
-    env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask,
-        &flush_write_task, Env::Priority::HIGH);
+    env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask, &flush_write_task,
+                  Env::Priority::HIGH);
   }
   flush_write_task.WaitUntilScheduled(kFlushWriteTasks);
 
   for (int t = 0; t < kCompactionWriteTasks; ++t) {
     env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask,
-        &compaction_write_task, Env::Priority::LOW);
+                  &compaction_write_task, Env::Priority::LOW);
   }
   compaction_write_task.WaitUntilScheduled(kCompactionWriteTasks);
 
   for (int t = 0; t < kCompactionReadTasks; ++t) {
     env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask,
-        &compaction_read_task, Env::Priority::LOW);
+                  &compaction_read_task, Env::Priority::LOW);
   }
   compaction_read_task.WaitUntilScheduled(kCompactionReadTasks);
 
   for (int t = 0; t < kCompactionWaitTasks; ++t) {
     env->Schedule(&SimulatedBackgroundTask::DoSimulatedTask,
-        &compaction_wait_task, Env::Priority::LOW);
+                  &compaction_wait_task, Env::Priority::LOW);
   }
   compaction_wait_task.WaitUntilScheduled(kCompactionWaitTasks);
 

package/deps/rocksdb/rocksdb/util/thread_local.cc

@@ -8,10 +8,12 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "util/thread_local.h"
-#include "util/mutexlock.h"
-#include "port/likely.h"
+
 #include <stdlib.h>
 
+#include "port/likely.h"
+#include "util/mutexlock.h"
+
 namespace ROCKSDB_NAMESPACE {
 
 struct Entry {
@@ -39,10 +41,7 @@ class StaticMeta;
 //     ---------------------------------------------------
 struct ThreadData {
   explicit ThreadData(ThreadLocalPtr::StaticMeta* _inst)
-    : entries(),
-      next(nullptr),
-      prev(nullptr),
-      inst(_inst) {}
+      : entries(), next(nullptr), prev(nullptr), inst(_inst) {}
   std::vector<Entry> entries;
   ThreadData* next;
   ThreadData* prev;
@@ -50,7 +49,7 @@ struct ThreadData {
 };
 
 class ThreadLocalPtr::StaticMeta {
-public:
+ public:
   StaticMeta();
 
   // Return the next available Id
@@ -107,7 +106,7 @@ public:
   // should be used.  One example is OnThreadExit() function.
   port::Mutex* MemberMutex() { return &mutex_; }
 
-private:
+ private:
   // Get UnrefHandler for id with acquiring mutex
   // REQUIRES: mutex locked
   UnrefHandler GetHandler(uint32_t id);
@@ -173,7 +172,7 @@ namespace wintlscleanup {
 
 // This is set to OnThreadExit in StaticMeta singleton constructor
 UnrefHandler thread_local_inclass_routine = nullptr;
-pthread_key_t thread_local_key = pthread_key_t (-1);
+pthread_key_t thread_local_key = pthread_key_t(-1);
 
 // Static callback function to call with each thread termination.
 void NTAPI WinOnThreadExit(PVOID module, DWORD reason, PVOID reserved) {
@@ -189,7 +188,7 @@ void NTAPI WinOnThreadExit(PVOID module, DWORD reason, PVOID reserved) {
   }
 }
 
-}  // wintlscleanup
+}  // namespace wintlscleanup
 
 // extern "C" suppresses C++ name mangling so we know the symbol name for the
 // linker /INCLUDE:symbol pragma above.
@@ -298,9 +297,7 @@ void ThreadLocalPtr::StaticMeta::OnThreadExit(void* ptr) {
 }
 
 ThreadLocalPtr::StaticMeta::StaticMeta()
-  : next_instance_id_(0),
-    head_(this),
-    pthread_key_(0) {
+    : next_instance_id_(0), head_(this), pthread_key_(0) {
   if (pthread_key_create(&pthread_key_, &OnThreadExit) != 0) {
     abort();
   }
@@ -345,8 +342,7 @@ void ThreadLocalPtr::StaticMeta::AddThreadData(ThreadData* d) {
   head_.prev = d;
 }
 
-void ThreadLocalPtr::StaticMeta::RemoveThreadData(
-    ThreadData* d) {
+void ThreadLocalPtr::StaticMeta::RemoveThreadData(ThreadData* d) {
   Mutex()->AssertHeld();
   d->next->prev = d->prev;
   d->prev->next = d->next;
@@ -406,7 +402,7 @@ void* ThreadLocalPtr::StaticMeta::Swap(uint32_t id, void* ptr) {
 }
 
 bool ThreadLocalPtr::StaticMeta::CompareAndSwap(uint32_t id, void* ptr,
-    void*& expected) {
+                                                void*& expected) {
   auto* tls = GetThreadLocal();
   if (UNLIKELY(id >= tls->entries.size())) {
     // Need mutex to protect entries access within ReclaimId
@@ -418,7 +414,7 @@ bool ThreadLocalPtr::StaticMeta::CompareAndSwap(uint32_t id, void* ptr,
 }
 
 void ThreadLocalPtr::StaticMeta::Scrape(uint32_t id, autovector<void*>* ptrs,
-    void* const replacement) {
+                                        void* const replacement) {
   MutexLock l(Mutex());
   for (ThreadData* t = head_.next; t != &head_; t = t->next) {
     if (id < t->entries.size()) {
@@ -443,9 +439,7 @@ void ThreadLocalPtr::StaticMeta::Fold(uint32_t id, FoldFunc func, void* res) {
   }
 }
 
-uint32_t ThreadLocalPtr::TEST_PeekId() {
-  return Instance()->PeekId();
-}
+uint32_t ThreadLocalPtr::TEST_PeekId() { return Instance()->PeekId(); }
 
 void ThreadLocalPtr::StaticMeta::SetHandler(uint32_t id, UnrefHandler handler) {
   MutexLock l(Mutex());
@@ -504,21 +498,13 @@ ThreadLocalPtr::ThreadLocalPtr(UnrefHandler handler)
   }
 }
 
-ThreadLocalPtr::~ThreadLocalPtr() {
-  Instance()->ReclaimId(id_);
-}
+ThreadLocalPtr::~ThreadLocalPtr() { Instance()->ReclaimId(id_); }
 
-void* ThreadLocalPtr::Get() const {
-  return Instance()->Get(id_);
-}
+void* ThreadLocalPtr::Get() const { return Instance()->Get(id_); }
 
-void ThreadLocalPtr::Reset(void* ptr) {
-  Instance()->Reset(id_, ptr);
-}
+void ThreadLocalPtr::Reset(void* ptr) { Instance()->Reset(id_, ptr); }
 
-void* ThreadLocalPtr::Swap(void* ptr) {
-  return Instance()->Swap(id_, ptr);
-}
+void* ThreadLocalPtr::Swap(void* ptr) { return Instance()->Swap(id_, ptr); }
 
 bool ThreadLocalPtr::CompareAndSwap(void* ptr, void*& expected) {
   return Instance()->CompareAndSwap(id_, ptr, expected);

package/deps/rocksdb/rocksdb/util/thread_local.h

@@ -15,8 +15,8 @@
 #include <unordered_map>
 #include <vector>
 
-#include "util/autovector.h"
 #include "port/port.h"
+#include "util/autovector.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -91,8 +91,7 @@ class ThreadLocalPtr {
 
   class StaticMeta;
 
-private:
-
+ private:
   static StaticMeta* Instance();
 
   const uint32_t id_;