clang format files under monitoring/ (#10857)

Summary:
Ran find . -iname '*.h' -o -iname '*.cc' | xargs clang-format -i under monitoring/.

Pull Request resolved: https://github.com/facebook/rocksdb/pull/10857

Test Plan: existing CI.

Reviewed By: siying

Differential Revision: D40652600

Pulled By: cbi42

fbshipit-source-id: 2af2467c33995b093e07b7512b8c32ed4144968e

monitoring/histogram.cc

@@ -52,11 +52,10 @@ size_t HistogramBucketMapper::IndexForValue(const uint64_t value) const {
 }
 
 namespace {
-  const HistogramBucketMapper bucketMapper;
+const HistogramBucketMapper bucketMapper;
 }
 
-HistogramStat::HistogramStat()
-  : num_buckets_(bucketMapper.BucketCount()) {
+HistogramStat::HistogramStat() : num_buckets_(bucketMapper.BucketCount()) {
   assert(num_buckets_ == sizeof(buckets_) / sizeof(*buckets_));
   Clear();
 }
@@ -109,12 +108,14 @@ void HistogramStat::Merge(const HistogramStat& other) {
   uint64_t old_min = min();
   uint64_t other_min = other.min();
   while (other_min < old_min &&
-         !min_.compare_exchange_weak(old_min, other_min)) {}
+         !min_.compare_exchange_weak(old_min, other_min)) {
+  }
 
   uint64_t old_max = max();
   uint64_t other_max = other.max();
   while (other_max > old_max &&
-         !max_.compare_exchange_weak(old_max, other_max)) {}
+         !max_.compare_exchange_weak(old_max, other_max)) {
+  }
 
   num_.fetch_add(other.num(), std::memory_order_relaxed);
   sum_.fetch_add(other.sum(), std::memory_order_relaxed);
@@ -124,9 +125,7 @@ void HistogramStat::Merge(const HistogramStat& other) {
   }
 }
 
-double HistogramStat::Median() const {
-  return Percentile(50.0);
-}
+double HistogramStat::Median() const { return Percentile(50.0); }
 
 double HistogramStat::Percentile(double p) const {
   double threshold = num() * (p / 100.0);
@@ -136,14 +135,14 @@ double HistogramStat::Percentile(double p) const {
     cumulative_sum += bucket_value;
     if (cumulative_sum >= threshold) {
       // Scale linearly within this bucket
-      uint64_t left_point = (b == 0) ? 0 : bucketMapper.BucketLimit(b-1);
+      uint64_t left_point = (b == 0) ? 0 : bucketMapper.BucketLimit(b - 1);
       uint64_t right_point = bucketMapper.BucketLimit(b);
       uint64_t left_sum = cumulative_sum - bucket_value;
       uint64_t right_sum = cumulative_sum;
       double pos = 0;
       uint64_t right_left_diff = right_sum - left_sum;
       if (right_left_diff != 0) {
-       pos = (threshold - left_sum) / right_left_diff;
+        pos = (threshold - left_sum) / right_left_diff;
       }
       double r = left_point + (right_point - left_point) * pos;
       uint64_t cur_min = min();
@@ -180,8 +179,7 @@ std::string HistogramStat::ToString() const {
   uint64_t cur_num = num();
   std::string r;
   char buf[1650];
-  snprintf(buf, sizeof(buf),
-           "Count: %" PRIu64 " Average: %.4f  StdDev: %.2f\n",
+  snprintf(buf, sizeof(buf), "Count: %" PRIu64 " Average: %.4f  StdDev: %.2f\n",
            cur_num, Average(), StandardDeviation());
   r.append(buf);
   snprintf(buf, sizeof(buf),
@@ -195,7 +193,7 @@ std::string HistogramStat::ToString() const {
            Percentile(99.99));
   r.append(buf);
   r.append("------------------------------------------------------\n");
-  if (cur_num == 0) return r;   // all buckets are empty
+  if (cur_num == 0) return r;  // all buckets are empty
   const double mult = 100.0 / cur_num;
   uint64_t cumulative_sum = 0;
   for (unsigned int b = 0; b < num_buckets_; b++) {
@@ -205,11 +203,11 @@ std::string HistogramStat::ToString() const {
     snprintf(buf, sizeof(buf),
              "%c %7" PRIu64 ", %7" PRIu64 " ] %8" PRIu64 " %7.3f%% %7.3f%% ",
              (b == 0) ? '[' : '(',
-             (b == 0) ? 0 : bucketMapper.BucketLimit(b-1),  // left
-              bucketMapper.BucketLimit(b),  // right
-              bucket_value,                   // count
-             (mult * bucket_value),           // percentage
-             (mult * cumulative_sum));       // cumulative percentage
+             (b == 0) ? 0 : bucketMapper.BucketLimit(b - 1),  // left
+             bucketMapper.BucketLimit(b),                     // right
+             bucket_value,                                    // count
+             (mult * bucket_value),                           // percentage
+             (mult * cumulative_sum));  // cumulative percentage
     r.append(buf);
 
     // Add hash marks based on percentage; 20 marks for 100%.
@@ -220,7 +218,7 @@ std::string HistogramStat::ToString() const {
   return r;
 }
 
-void HistogramStat::Data(HistogramData * const data) const {
+void HistogramStat::Data(HistogramData* const data) const {
   assert(data);
   data->median = Median();
   data->percentile95 = Percentile(95);
@@ -238,13 +236,9 @@ void HistogramImpl::Clear() {
   stats_.Clear();
 }
 
-bool HistogramImpl::Empty() const {
-  return stats_.Empty();
-}
+bool HistogramImpl::Empty() const { return stats_.Empty(); }
 
-void HistogramImpl::Add(uint64_t value) {
-  stats_.Add(value);
-}
+void HistogramImpl::Add(uint64_t value) { stats_.Add(value); }
 
 void HistogramImpl::Merge(const Histogram& other) {
   if (strcmp(Name(), other.Name()) == 0) {
@@ -257,28 +251,20 @@ void HistogramImpl::Merge(const HistogramImpl& other) {
   stats_.Merge(other.stats_);
 }
 
-double HistogramImpl::Median() const {
-  return stats_.Median();
-}
+double HistogramImpl::Median() const { return stats_.Median(); }
 
 double HistogramImpl::Percentile(double p) const {
   return stats_.Percentile(p);
 }
 
-double HistogramImpl::Average() const {
-  return stats_.Average();
-}
+double HistogramImpl::Average() const { return stats_.Average(); }
 
 double HistogramImpl::StandardDeviation() const {
- return stats_.StandardDeviation();
+  return stats_.StandardDeviation();
 }
 
-std::string HistogramImpl::ToString() const {
-  return stats_.ToString();
-}
+std::string HistogramImpl::ToString() const { return stats_.ToString(); }
 
-void HistogramImpl::Data(HistogramData * const data) const {
-  stats_.Data(data);
-}
+void HistogramImpl::Data(HistogramData* const data) const { stats_.Data(data); }
 
 }  // namespace ROCKSDB_NAMESPACE

monitoring/histogram.h

@@ -8,36 +8,29 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #pragma once
-#include "rocksdb/statistics.h"
-
 #include <cassert>
-#include <string>
-#include <vector>
 #include <map>
 #include <mutex>
+#include <string>
+#include <vector>
+
+#include "rocksdb/statistics.h"
 
 namespace ROCKSDB_NAMESPACE {
 
 class HistogramBucketMapper {
  public:
-
   HistogramBucketMapper();
 
   // converts a value to the bucket index.
   size_t IndexForValue(uint64_t value) const;
   // number of buckets required.
 
-  size_t BucketCount() const {
-    return bucketValues_.size();
-  }
+  size_t BucketCount() const { return bucketValues_.size(); }
 
-  uint64_t LastValue() const {
-    return maxBucketValue_;
-  }
+  uint64_t LastValue() const { return maxBucketValue_; }
 
-  uint64_t FirstValue() const {
-    return minBucketValue_;
-  }
+  uint64_t FirstValue() const { return minBucketValue_; }
 
   uint64_t BucketLimit(const size_t bucketNumber) const {
     assert(bucketNumber < BucketCount());
@@ -88,14 +81,14 @@ struct HistogramStat {
   std::atomic_uint_fast64_t num_;
   std::atomic_uint_fast64_t sum_;
   std::atomic_uint_fast64_t sum_squares_;
-  std::atomic_uint_fast64_t buckets_[109]; // 109==BucketMapper::BucketCount()
+  std::atomic_uint_fast64_t buckets_[109];  // 109==BucketMapper::BucketCount()
   const uint64_t num_buckets_;
 };
 
 class Histogram {
-public:
+ public:
   Histogram() {}
-  virtual ~Histogram() {};
+  virtual ~Histogram(){};
 
   virtual void Clear() = 0;
   virtual bool Empty() const = 0;

monitoring/histogram_test.cc

@@ -18,14 +18,14 @@ namespace ROCKSDB_NAMESPACE {
 class HistogramTest : public testing::Test {};
 
 namespace {
-  const double kIota = 0.1;
-  const HistogramBucketMapper bucketMapper;
-  std::shared_ptr<MockSystemClock> clock =
-      std::make_shared<MockSystemClock>(SystemClock::Default());
-}
-
-void PopulateHistogram(Histogram& histogram,
-             uint64_t low, uint64_t high, uint64_t loop = 1) {
+const double kIota = 0.1;
+const HistogramBucketMapper bucketMapper;
+std::shared_ptr<MockSystemClock> clock =
+    std::make_shared<MockSystemClock>(SystemClock::Default());
+}  // namespace
+
+void PopulateHistogram(Histogram& histogram, uint64_t low, uint64_t high,
+                       uint64_t loop = 1) {
   Random rnd(test::RandomSeed());
   for (; loop > 0; loop--) {
     for (uint64_t i = low; i <= high; i++) {
@@ -39,7 +39,7 @@ void PopulateHistogram(Histogram& histogram,
 }
 
 void BasicOperation(Histogram& histogram) {
-  PopulateHistogram(histogram, 1, 110, 10); // fill up to bucket [70, 110)
+  PopulateHistogram(histogram, 1, 110, 10);  // fill up to bucket [70, 110)
 
   HistogramData data;
   histogram.Data(&data);
@@ -47,8 +47,8 @@ void BasicOperation(Histogram& histogram) {
   ASSERT_LE(fabs(histogram.Percentile(100.0) - 110.0), kIota);
   ASSERT_LE(fabs(data.percentile99 - 108.9), kIota);  // 99 * 110 / 100
   ASSERT_LE(fabs(data.percentile95 - 104.5), kIota);  // 95 * 110 / 100
-  ASSERT_LE(fabs(data.median - 55.0), kIota);  // 50 * 110 / 100
-  ASSERT_EQ(data.average, 55.5);  // (1 + 110) / 2
+  ASSERT_LE(fabs(data.median - 55.0), kIota);         // 50 * 110 / 100
+  ASSERT_EQ(data.average, 55.5);                      // (1 + 110) / 2
 }
 
 void MergeHistogram(Histogram& histogram, Histogram& other) {
@@ -62,8 +62,8 @@ void MergeHistogram(Histogram& histogram, Histogram& other) {
   ASSERT_LE(fabs(histogram.Percentile(100.0) - 250.0), kIota);
   ASSERT_LE(fabs(data.percentile99 - 247.5), kIota);  // 99 * 250 / 100
   ASSERT_LE(fabs(data.percentile95 - 237.5), kIota);  // 95 * 250 / 100
-  ASSERT_LE(fabs(data.median - 125.0), kIota);  // 50 * 250 / 100
-  ASSERT_EQ(data.average, 125.5);  // (1 + 250) / 2
+  ASSERT_LE(fabs(data.median - 125.0), kIota);        // 50 * 250 / 100
+  ASSERT_EQ(data.average, 125.5);                     // (1 + 250) / 2
 }
 
 void EmptyHistogram(Histogram& histogram) {
@@ -139,8 +139,8 @@ TEST_F(HistogramTest, HistogramWindowingExpire) {
   int micros_per_window = 1000000;
   uint64_t min_num_per_window = 0;
 
-  HistogramWindowingImpl
-      histogramWindowing(num_windows, micros_per_window, min_num_per_window);
+  HistogramWindowingImpl histogramWindowing(num_windows, micros_per_window,
+                                            min_num_per_window);
   histogramWindowing.TEST_UpdateClock(clock);
   PopulateHistogram(histogramWindowing, 1, 1, 100);
   clock->SleepForMicroseconds(micros_per_window);
@@ -190,10 +190,10 @@ TEST_F(HistogramTest, HistogramWindowingMerge) {
   int micros_per_window = 1000000;
   uint64_t min_num_per_window = 0;
 
-  HistogramWindowingImpl
-      histogramWindowing(num_windows, micros_per_window, min_num_per_window);
-  HistogramWindowingImpl
-      otherWindowing(num_windows, micros_per_window, min_num_per_window);
+  HistogramWindowingImpl histogramWindowing(num_windows, micros_per_window,
+                                            min_num_per_window);
+  HistogramWindowingImpl otherWindowing(num_windows, micros_per_window,
+                                        min_num_per_window);
   histogramWindowing.TEST_UpdateClock(clock);
   otherWindowing.TEST_UpdateClock(clock);
 

monitoring/histogram_windowing.cc

@@ -23,11 +23,10 @@ HistogramWindowingImpl::HistogramWindowingImpl() {
   Clear();
 }
 
-HistogramWindowingImpl::HistogramWindowingImpl(
-    uint64_t num_windows,
-    uint64_t micros_per_window,
-    uint64_t min_num_per_window) :
-      num_windows_(num_windows),
+HistogramWindowingImpl::HistogramWindowingImpl(uint64_t num_windows,
+                                               uint64_t micros_per_window,
+                                               uint64_t min_num_per_window)
+    : num_windows_(num_windows),
       micros_per_window_(micros_per_window),
       min_num_per_window_(min_num_per_window) {
   clock_ = SystemClock::Default();
@@ -35,8 +34,7 @@ HistogramWindowingImpl::HistogramWindowingImpl(
   Clear();
 }
 
-HistogramWindowingImpl::~HistogramWindowingImpl() {
-}
+HistogramWindowingImpl::~HistogramWindowingImpl() {}
 
 void HistogramWindowingImpl::Clear() {
   std::lock_guard<std::mutex> lock(mutex_);
@@ -55,7 +53,7 @@ bool HistogramWindowingImpl::Empty() const { return stats_.Empty(); }
 // of any operation.
 // Each individual value is atomic, it is just that some samples can go
 // in the older bucket which is tolerable.
-void HistogramWindowingImpl::Add(uint64_t value){
+void HistogramWindowingImpl::Add(uint64_t value) {
   TimerTick();
 
   // Parent (global) member update
@@ -83,17 +81,15 @@ void HistogramWindowingImpl::Merge(const HistogramWindowingImpl& other) {
   uint64_t cur_window = current_window();
   uint64_t other_cur_window = other.current_window();
   // going backwards for alignment
-  for (unsigned int i = 0;
-                    i < std::min(num_windows_, other.num_windows_); i++) {
-    uint64_t window_index =
-        (cur_window + num_windows_ - i) % num_windows_;
+  for (unsigned int i = 0; i < std::min(num_windows_, other.num_windows_);
+       i++) {
+    uint64_t window_index = (cur_window + num_windows_ - i) % num_windows_;
     uint64_t other_window_index =
         (other_cur_window + other.num_windows_ - i) % other.num_windows_;
     size_t windex = static_cast<size_t>(window_index);
     size_t other_windex = static_cast<size_t>(other_window_index);
 
-    window_stats_[windex].Merge(
-      other.window_stats_[other_windex]);
+    window_stats_[windex].Merge(other.window_stats_[other_windex]);
   }
 }
 
@@ -101,9 +97,7 @@ std::string HistogramWindowingImpl::ToString() const {
   return stats_.ToString();
 }
 
-double HistogramWindowingImpl::Median() const {
-  return Percentile(50.0);
-}
+double HistogramWindowingImpl::Median() const { return Percentile(50.0); }
 
 double HistogramWindowingImpl::Percentile(double p) const {
   // Retry 3 times in total
@@ -118,15 +112,13 @@ double HistogramWindowingImpl::Percentile(double p) const {
   return 0.0;
 }
 
-double HistogramWindowingImpl::Average() const {
-  return stats_.Average();
-}
+double HistogramWindowingImpl::Average() const { return stats_.Average(); }
 
 double HistogramWindowingImpl::StandardDeviation() const {
   return stats_.StandardDeviation();
 }
 
-void HistogramWindowingImpl::Data(HistogramData * const data) const {
+void HistogramWindowingImpl::Data(HistogramData* const data) const {
   stats_.Data(data);
 }
 
@@ -149,17 +141,17 @@ void HistogramWindowingImpl::SwapHistoryBucket() {
     last_swap_time_.store(clock_->NowMicros(), std::memory_order_relaxed);
 
     uint64_t curr_window = current_window();
-    uint64_t next_window = (curr_window == num_windows_ - 1) ?
-                                                    0 : curr_window + 1;
+    uint64_t next_window =
+        (curr_window == num_windows_ - 1) ? 0 : curr_window + 1;
 
     // subtract next buckets from totals and swap to next buckets
-    HistogramStat& stats_to_drop = 
-      window_stats_[static_cast<size_t>(next_window)];
+    HistogramStat& stats_to_drop =
+        window_stats_[static_cast<size_t>(next_window)];
 
     if (!stats_to_drop.Empty()) {
-      for (size_t b = 0; b < stats_.num_buckets_; b++){
-        stats_.buckets_[b].fetch_sub(
-            stats_to_drop.bucket_at(b), std::memory_order_relaxed);
+      for (size_t b = 0; b < stats_.num_buckets_; b++) {
+        stats_.buckets_[b].fetch_sub(stats_to_drop.bucket_at(b),
+                                     std::memory_order_relaxed);
       }
 
       if (stats_.min() == stats_to_drop.min()) {
@@ -186,8 +178,8 @@ void HistogramWindowingImpl::SwapHistoryBucket() {
 
       stats_.num_.fetch_sub(stats_to_drop.num(), std::memory_order_relaxed);
       stats_.sum_.fetch_sub(stats_to_drop.sum(), std::memory_order_relaxed);
-      stats_.sum_squares_.fetch_sub(
-                  stats_to_drop.sum_squares(), std::memory_order_relaxed);
+      stats_.sum_squares_.fetch_sub(stats_to_drop.sum_squares(),
+                                    std::memory_order_relaxed);
 
       stats_to_drop.Clear();
     }

monitoring/histogram_windowing.h

@@ -14,12 +14,10 @@
 namespace ROCKSDB_NAMESPACE {
 class SystemClock;
 
-class HistogramWindowingImpl : public Histogram
-{
-public:
+class HistogramWindowingImpl : public Histogram {
+ public:
   HistogramWindowingImpl();
-  HistogramWindowingImpl(uint64_t num_windows,
-                         uint64_t micros_per_window,
+  HistogramWindowingImpl(uint64_t num_windows, uint64_t micros_per_window,
                          uint64_t min_num_per_window);
 
   HistogramWindowingImpl(const HistogramWindowingImpl&) = delete;
@@ -56,7 +54,7 @@ public:
   inline uint64_t current_window() const {
     return current_window_.load(std::memory_order_relaxed);
   }
-  inline uint64_t last_swap_time() const{
+  inline uint64_t last_swap_time() const {
     return last_swap_time_.load(std::memory_order_relaxed);
   }
 

monitoring/in_memory_stats_history.cc

@@ -7,6 +7,7 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "monitoring/in_memory_stats_history.h"
+
 #include "db/db_impl/db_impl.h"
 
 namespace ROCKSDB_NAMESPACE {

monitoring/instrumented_mutex.h

@@ -46,9 +46,7 @@ class InstrumentedMutex {
 
   void Unlock() { mutex_.Unlock(); }
 
-  void AssertHeld() {
-    mutex_.AssertHeld();
-  }
+  void AssertHeld() { mutex_.AssertHeld(); }
 
  private:
   void LockInternal();
@@ -76,9 +74,7 @@ class InstrumentedMutexLock {
     mutex_->Lock();
   }
 
-  ~InstrumentedMutexLock() {
-    mutex_->Unlock();
-  }
+  ~InstrumentedMutexLock() { mutex_->Unlock(); }
 
  private:
   InstrumentedMutex* const mutex_;
@@ -114,13 +110,9 @@ class InstrumentedCondVar {
 
   bool TimedWait(uint64_t abs_time_us);
 
-  void Signal() {
-    cond_.Signal();
-  }
+  void Signal() { cond_.Signal(); }
 
-  void SignalAll() {
-    cond_.SignalAll();
-  }
+  void SignalAll() { cond_.SignalAll(); }
 
  private:
   void WaitInternal();

monitoring/iostats_context.cc

@@ -4,6 +4,7 @@
 //  (found in the LICENSE.Apache file in the root directory).
 
 #include <sstream>
+
 #include "monitoring/iostats_context_imp.h"
 #include "rocksdb/env.h"
 
@@ -17,9 +18,7 @@ static IOStatsContext iostats_context;
 thread_local IOStatsContext iostats_context;
 #endif
 
-IOStatsContext* get_iostats_context() {
-  return &iostats_context;
-}
+IOStatsContext* get_iostats_context() { return &iostats_context; }
 
 void IOStatsContext::Reset() {
 #ifndef NIOSTATS_CONTEXT

monitoring/iostats_context_test.cc

@@ -4,6 +4,7 @@
 //  (found in the LICENSE.Apache file in the root directory).
 
 #include "rocksdb/iostats_context.h"
+
 #include "test_util/testharness.h"
 
 namespace ROCKSDB_NAMESPACE {

monitoring/perf_context.cc

@@ -5,6 +5,7 @@
 //
 
 #include <sstream>
+
 #include "monitoring/perf_context_imp.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -17,9 +18,7 @@ PerfContext perf_context;
 thread_local PerfContext perf_context;
 #endif
 
-PerfContext* get_perf_context() {
-  return &perf_context;
-}
+PerfContext* get_perf_context() { return &perf_context; }
 
 PerfContext::~PerfContext() {
 #if !defined(NPERF_CONTEXT) && !defined(OS_SOLARIS)
@@ -499,15 +498,14 @@ void PerfContext::Reset() {
     ss << #counter << " = " << counter << ", ";  \
   }
 
-#define PERF_CONTEXT_BY_LEVEL_OUTPUT_ONE_COUNTER(counter)         \
-  if (per_level_perf_context_enabled && \
-      level_to_perf_context) {                                    \
-    ss << #counter << " = ";                                      \
-    for (auto& kv : *level_to_perf_context) {                     \
-      if (!exclude_zero_counters || (kv.second.counter > 0)) {    \
-        ss << kv.second.counter << "@level" << kv.first << ", ";  \
-      }                                                           \
-    }                                                             \
+#define PERF_CONTEXT_BY_LEVEL_OUTPUT_ONE_COUNTER(counter)        \
+  if (per_level_perf_context_enabled && level_to_perf_context) { \
+    ss << #counter << " = ";                                     \
+    for (auto& kv : *level_to_perf_context) {                    \
+      if (!exclude_zero_counters || (kv.second.counter > 0)) {   \
+        ss << kv.second.counter << "@level" << kv.first << ", "; \
+      }                                                          \
+    }                                                            \
   }
 
 void PerfContextByLevel::Reset() {
@@ -638,11 +636,11 @@ void PerfContext::EnablePerLevelPerfContext() {
   per_level_perf_context_enabled = true;
 }
 
-void PerfContext::DisablePerLevelPerfContext(){
+void PerfContext::DisablePerLevelPerfContext() {
   per_level_perf_context_enabled = false;
 }
 
-void PerfContext::ClearPerLevelPerfContext(){
+void PerfContext::ClearPerLevelPerfContext() {
   if (level_to_perf_context != nullptr) {
     level_to_perf_context->clear();
     delete level_to_perf_context;

monitoring/perf_level.cc

@@ -5,6 +5,7 @@
 //
 
 #include <assert.h>
+
 #include "monitoring/perf_level_imp.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -17,8 +18,6 @@ void SetPerfLevel(PerfLevel level) {
   perf_level = level;
 }
 
-PerfLevel GetPerfLevel() {
-  return perf_level;
-}
+PerfLevel GetPerfLevel() { return perf_level; }
 
 }  // namespace ROCKSDB_NAMESPACE

monitoring/perf_level_imp.h

@@ -4,8 +4,8 @@
 //  (found in the LICENSE.Apache file in the root directory).
 //
 #pragma once
-#include "rocksdb/perf_level.h"
 #include "port/port.h"
+#include "rocksdb/perf_level.h"
 
 namespace ROCKSDB_NAMESPACE {
 

monitoring/perf_step_timer.h

@@ -26,9 +26,7 @@ class PerfStepTimer {
         metric_(metric),
         statistics_(statistics) {}
 
-  ~PerfStepTimer() {
-    Stop();
-  }
+  ~PerfStepTimer() { Stop(); }
 
   void Start() {
     if (perf_counter_enabled_ || statistics_ != nullptr) {

monitoring/persistent_stats_history.cc

@@ -11,6 +11,7 @@
 #include <cstring>
 #include <string>
 #include <utility>
+
 #include "db/db_impl/db_impl.h"
 #include "util/string_util.h"
 

monitoring/statistics.cc

@@ -469,7 +469,7 @@ namespace {
 // a buffer size used for temp string buffers
 const int kTmpStrBufferSize = 200;
 
-} // namespace
+}  // namespace
 
 std::string StatisticsImpl::ToString() const {
   MutexLock lock(&aggregate_lock_);

monitoring/statistics.h

@@ -4,8 +4,6 @@
 //  (found in the LICENSE.Apache file in the root directory).
 //
 #pragma once
-#include "rocksdb/statistics.h"
-
 #include <atomic>
 #include <map>
 #include <string>
@@ -14,6 +12,7 @@
 #include "monitoring/histogram.h"
 #include "port/likely.h"
 #include "port/port.h"
+#include "rocksdb/statistics.h"
 #include "util/core_local.h"
 #include "util/mutexlock.h"
 
@@ -94,14 +93,15 @@ class StatisticsImpl : public Statistics {
                   INTERNAL_HISTOGRAM_ENUM_MAX * sizeof(HistogramImpl)) %
                      CACHE_LINE_SIZE)] ROCKSDB_FIELD_UNUSED;
 #endif
-    void *operator new(size_t s) { return port::cacheline_aligned_alloc(s); }
-    void *operator new[](size_t s) { return port::cacheline_aligned_alloc(s); }
-    void operator delete(void *p) { port::cacheline_aligned_free(p); }
-    void operator delete[](void *p) { port::cacheline_aligned_free(p); }
+    void* operator new(size_t s) { return port::cacheline_aligned_alloc(s); }
+    void* operator new[](size_t s) { return port::cacheline_aligned_alloc(s); }
+    void operator delete(void* p) { port::cacheline_aligned_free(p); }
+    void operator delete[](void* p) { port::cacheline_aligned_free(p); }
   };
 
 #ifndef TEST_CACHE_LINE_SIZE
-  static_assert(sizeof(StatisticsData) % CACHE_LINE_SIZE == 0, "Expected " TOSTRING(CACHE_LINE_SIZE) "-byte aligned");
+  static_assert(sizeof(StatisticsData) % CACHE_LINE_SIZE == 0,
+                "Expected " TOSTRING(CACHE_LINE_SIZE) "-byte aligned");
 #endif
 
   CoreLocalArray<StatisticsData> per_core_stats_;

monitoring/thread_status_updater.h

@@ -36,9 +36,9 @@
 #include <unordered_set>
 #include <vector>
 
+#include "port/port.h"
 #include "rocksdb/status.h"
 #include "rocksdb/thread_status.h"
-#include "port/port.h"
 #include "util/thread_operation.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -49,11 +49,9 @@ class ColumnFamilyHandle;
 struct ConstantColumnFamilyInfo {
 #ifdef ROCKSDB_USING_THREAD_STATUS
  public:
-  ConstantColumnFamilyInfo(
-      const void* _db_key,
-      const std::string& _db_name,
-      const std::string& _cf_name) :
-      db_key(_db_key), db_name(_db_name), cf_name(_cf_name) {}
+  ConstantColumnFamilyInfo(const void* _db_key, const std::string& _db_name,
+                           const std::string& _cf_name)
+      : db_key(_db_key), db_name(_db_name), cf_name(_cf_name) {}
   const void* db_key;
   const std::string db_name;
   const std::string cf_name;
@@ -142,13 +140,11 @@ class ThreadStatusUpdater {
   //       will be set in std::memory_order_release.  This is to ensure
   //       whenever a thread operation is not OP_UNKNOWN, we will always
   //       have a consistent information on its properties.
-  void SetThreadOperationProperty(
-      int i, uint64_t value);
+  void SetThreadOperationProperty(int i, uint64_t value);
 
   // Increase the "i"th property of the current operation with
   // the specified delta.
-  void IncreaseThreadOperationProperty(
-      int i, uint64_t delta);
+  void IncreaseThreadOperationProperty(int i, uint64_t delta);
 
   // Update the thread operation stage of the current thread.
   ThreadStatus::OperationStage SetThreadOperationStage(
@@ -167,15 +163,13 @@ class ThreadStatusUpdater {
   void ClearThreadState();
 
   // Obtain the status of all active registered threads.
-  Status GetThreadList(
-      std::vector<ThreadStatus>* thread_list);
+  Status GetThreadList(std::vector<ThreadStatus>* thread_list);
 
   // Create an entry in the global ColumnFamilyInfo table for the
   // specified column family.  This function should be called only
   // when the current thread does not hold db_mutex.
-  void NewColumnFamilyInfo(
-      const void* db_key, const std::string& db_name,
-      const void* cf_key, const std::string& cf_name);
+  void NewColumnFamilyInfo(const void* db_key, const std::string& db_name,
+                           const void* cf_key, const std::string& cf_name);
 
   // Erase all ConstantColumnFamilyInfo that is associated with the
   // specified db instance.  This function should be called only when
@@ -190,8 +184,7 @@ class ThreadStatusUpdater {
   // Verifies whether the input ColumnFamilyHandles matches
   // the information stored in the current cf_info_map.
   void TEST_VerifyColumnFamilyInfoMap(
-      const std::vector<ColumnFamilyHandle*>& handles,
-      bool check_exist);
+      const std::vector<ColumnFamilyHandle*>& handles, bool check_exist);
 
  protected:
 #ifdef ROCKSDB_USING_THREAD_STATUS
@@ -204,9 +197,7 @@ class ThreadStatusUpdater {
 
   // Directly returns the pointer to thread_status_data_ without
   // checking whether enabling_tracking is true of not.
-  ThreadStatusData* Get() {
-    return thread_status_data_;
-  }
+  ThreadStatusData* Get() { return thread_status_data_; }
 
   // The mutex that protects cf_info_map and db_key_map.
   std::mutex thread_list_mutex_;
@@ -222,8 +213,7 @@ class ThreadStatusUpdater {
 
   // A db_key to cf_key map that allows erasing elements in cf_info_map
   // associated to the same db_key faster.
-  std::unordered_map<
-      const void*, std::unordered_set<const void*>> db_key_map_;
+  std::unordered_map<const void*, std::unordered_set<const void*>> db_key_map_;
 
 #else
   static ThreadStatusData* thread_status_data_;

monitoring/thread_status_util.h

@@ -30,8 +30,8 @@ class ColumnFamilyData;
 class ThreadStatusUtil {
  public:
   // Register the current thread for tracking.
-  static void RegisterThread(
-      const Env* env, ThreadStatus::ThreadType thread_type);
+  static void RegisterThread(const Env* env,
+                             ThreadStatus::ThreadType thread_type);
 
   // Unregister the current thread.
   static void UnregisterThread();
@@ -62,19 +62,17 @@ class ThreadStatusUtil {
   static ThreadStatus::OperationStage SetThreadOperationStage(
       ThreadStatus::OperationStage stage);
 
-  static void SetThreadOperationProperty(
-      int code, uint64_t value);
+  static void SetThreadOperationProperty(int code, uint64_t value);
 
-  static void IncreaseThreadOperationProperty(
-      int code, uint64_t delta);
+  static void IncreaseThreadOperationProperty(int code, uint64_t delta);
 
   static void SetThreadState(ThreadStatus::StateType type);
 
   static void ResetThreadStatus();
 
 #ifndef NDEBUG
-  static void TEST_SetStateDelay(
-      const ThreadStatus::StateType state, int micro);
+  static void TEST_SetStateDelay(const ThreadStatus::StateType state,
+                                 int micro);
   static void TEST_StateDelay(const ThreadStatus::StateType state);
 #endif
 
@@ -121,8 +119,7 @@ class ThreadStatusUtil {
 // and set the thread state to the previous state in its destructor.
 class AutoThreadOperationStageUpdater {
  public:
-  explicit AutoThreadOperationStageUpdater(
-      ThreadStatus::OperationStage stage);
+  explicit AutoThreadOperationStageUpdater(ThreadStatus::OperationStage stage);
   ~AutoThreadOperationStageUpdater();
 
 #ifdef ROCKSDB_USING_THREAD_STATUS

monitoring/thread_status_util_debug.cc

@@ -15,8 +15,8 @@ namespace ROCKSDB_NAMESPACE {
 // the delay for debugging purpose.
 static std::atomic<int> states_delay[ThreadStatus::NUM_STATE_TYPES];
 
-void ThreadStatusUtil::TEST_SetStateDelay(
-    const ThreadStatus::StateType state, int micro) {
+void ThreadStatusUtil::TEST_SetStateDelay(const ThreadStatus::StateType state,
+                                          int micro) {
   states_delay[state].store(micro, std::memory_order_relaxed);
 }