diff --git a/monitoring/histogram.cc b/monitoring/histogram.cc index 4d00219c9..61bc6c140 100644 --- a/monitoring/histogram.cc +++ b/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 diff --git a/monitoring/histogram.h b/monitoring/histogram.h index 41af01442..15fee2b4f 100644 --- a/monitoring/histogram.h +++ b/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 -#include -#include #include #include +#include +#include + +#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; diff --git a/monitoring/histogram_test.cc b/monitoring/histogram_test.cc index 834884cbd..19e9f15d0 100644 --- a/monitoring/histogram_test.cc +++ b/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 clock = - std::make_shared(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 clock = + std::make_shared(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); diff --git a/monitoring/histogram_windowing.cc b/monitoring/histogram_windowing.cc index f31bbe06a..c41ae8a03 100644 --- a/monitoring/histogram_windowing.cc +++ b/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 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(window_index); size_t other_windex = static_cast(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(next_window)]; + HistogramStat& stats_to_drop = + window_stats_[static_cast(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(); } diff --git a/monitoring/histogram_windowing.h b/monitoring/histogram_windowing.h index f8da07b36..9a862671f 100644 --- a/monitoring/histogram_windowing.h +++ b/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); } diff --git a/monitoring/in_memory_stats_history.cc b/monitoring/in_memory_stats_history.cc index dba791e2b..568d8ec13 100644 --- a/monitoring/in_memory_stats_history.cc +++ b/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 { diff --git a/monitoring/instrumented_mutex.h b/monitoring/instrumented_mutex.h index f2b0564bb..e5aae34df 100644 --- a/monitoring/instrumented_mutex.h +++ b/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(); diff --git a/monitoring/iostats_context.cc b/monitoring/iostats_context.cc index 2acc555dc..04e98914d 100644 --- a/monitoring/iostats_context.cc +++ b/monitoring/iostats_context.cc @@ -4,6 +4,7 @@ // (found in the LICENSE.Apache file in the root directory). #include + #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 diff --git a/monitoring/iostats_context_test.cc b/monitoring/iostats_context_test.cc index ea40822ff..5fce33406 100644 --- a/monitoring/iostats_context_test.cc +++ b/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 { diff --git a/monitoring/perf_context.cc b/monitoring/perf_context.cc index 33c711873..9068ede01 100644 --- a/monitoring/perf_context.cc +++ b/monitoring/perf_context.cc @@ -5,6 +5,7 @@ // #include + #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; diff --git a/monitoring/perf_level.cc b/monitoring/perf_level.cc index 9190af302..e3507624b 100644 --- a/monitoring/perf_level.cc +++ b/monitoring/perf_level.cc @@ -5,6 +5,7 @@ // #include + #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 diff --git a/monitoring/perf_level_imp.h b/monitoring/perf_level_imp.h index 68540e125..28bd185cd 100644 --- a/monitoring/perf_level_imp.h +++ b/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 { diff --git a/monitoring/perf_step_timer.h b/monitoring/perf_step_timer.h index fb049f725..8deb31252 100644 --- a/monitoring/perf_step_timer.h +++ b/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) { diff --git a/monitoring/persistent_stats_history.cc b/monitoring/persistent_stats_history.cc index 9bde38b3a..f4c022148 100644 --- a/monitoring/persistent_stats_history.cc +++ b/monitoring/persistent_stats_history.cc @@ -11,6 +11,7 @@ #include #include #include + #include "db/db_impl/db_impl.h" #include "util/string_util.h" diff --git a/monitoring/statistics.cc b/monitoring/statistics.cc index cbb96b295..958fc65fb 100644 --- a/monitoring/statistics.cc +++ b/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_); diff --git a/monitoring/statistics.h b/monitoring/statistics.h index 20661777f..e0dc29d28 100644 --- a/monitoring/statistics.h +++ b/monitoring/statistics.h @@ -4,8 +4,6 @@ // (found in the LICENSE.Apache file in the root directory). // #pragma once -#include "rocksdb/statistics.h" - #include #include #include @@ -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 per_core_stats_; diff --git a/monitoring/thread_status_updater.h b/monitoring/thread_status_updater.h index 792d4208f..762c73ae2 100644 --- a/monitoring/thread_status_updater.h +++ b/monitoring/thread_status_updater.h @@ -36,9 +36,9 @@ #include #include +#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* thread_list); + Status GetThreadList(std::vector* 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& handles, - bool check_exist); + const std::vector& 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> db_key_map_; + std::unordered_map> db_key_map_; #else static ThreadStatusData* thread_status_data_; diff --git a/monitoring/thread_status_util.h b/monitoring/thread_status_util.h index 70ef4e2eb..0137d2682 100644 --- a/monitoring/thread_status_util.h +++ b/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 diff --git a/monitoring/thread_status_util_debug.cc b/monitoring/thread_status_util_debug.cc index c493ddca5..f7a94355d 100644 --- a/monitoring/thread_status_util_debug.cc +++ b/monitoring/thread_status_util_debug.cc @@ -15,8 +15,8 @@ namespace ROCKSDB_NAMESPACE { // the delay for debugging purpose. static std::atomic 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); }