From 6f6120f66c9c20d824d7fcbf11309c7868e3e02e Mon Sep 17 00:00:00 2001 From: yi wang Date: Mon, 6 Sep 2021 18:51:43 +0800 Subject: [PATCH] enhancement metric report, support LatencyHistLoggedGuard (#117) * enhancement metric report, support LatencyHistLoggedGuard --- CMakeLists.txt | 2 + db/db_impl.cc | 32 ++++---- db/metrics_reporter.cc | 67 ++++++++++++++++ db/metrics_reporter_test.cc | 78 +++++++++++++++++++ include/rocksdb/metrics_reporter.h | 49 ++++++++---- utilities/trace/bytedance_metrics_reporter.cc | 60 +++++++------- utilities/trace/bytedance_metrics_reporter.h | 71 +++++++++++------ utilities/trace/stats.h | 6 +- 8 files changed, 274 insertions(+), 91 deletions(-) create mode 100644 db/metrics_reporter.cc create mode 100644 db/metrics_reporter_test.cc diff --git a/CMakeLists.txt b/CMakeLists.txt index 6acf4231d..b99f6a9a5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -581,6 +581,7 @@ set(SOURCES db/memtable_list.cc db/merge_helper.cc db/merge_operator.cc + db/metrics_reporter.cc db/periodic_work_scheduler.cc db/range_del_aggregator.cc db/range_tombstone_fragmenter.cc @@ -994,6 +995,7 @@ if(WITH_TESTS) db/memtable_list_test.cc db/merge_helper_test.cc db/merge_test.cc + db/metrics_reporter_test.cc db/options_file_test.cc db/perf_context_test.cc db/periodic_work_scheduler_test.cc diff --git a/db/db_impl.cc b/db/db_impl.cc index 023296646..2449d79c9 100644 --- a/db/db_impl.cc +++ b/db/db_impl.cc @@ -281,55 +281,55 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname, write_qps_reporter_(*metrics_reporter_factory_->BuildCountReporter( write_qps_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())), + immutable_db_options_.info_log.get(), env_)), read_qps_reporter_(*metrics_reporter_factory_->BuildCountReporter( read_qps_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())), + immutable_db_options_.info_log.get(), env_)), newiterator_qps_reporter_(*metrics_reporter_factory_->BuildCountReporter( newiterator_qps_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())), + immutable_db_options_.info_log.get(), env_)), seek_qps_reporter_(*metrics_reporter_factory_->BuildCountReporter( seek_qps_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())), + immutable_db_options_.info_log.get(), env_)), next_qps_reporter_(*metrics_reporter_factory_->BuildCountReporter( next_qps_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())), + immutable_db_options_.info_log.get(), env_)), seekforprev_qps_reporter_(*metrics_reporter_factory_->BuildCountReporter( seekforprev_qps_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())), + immutable_db_options_.info_log.get(), env_)), prev_qps_reporter_(*metrics_reporter_factory_->BuildCountReporter( prev_qps_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())), + immutable_db_options_.info_log.get(), env_)), write_latency_reporter_(*metrics_reporter_factory_->BuildHistReporter( write_latency_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())), + immutable_db_options_.info_log.get(), env_)), read_latency_reporter_(*metrics_reporter_factory_->BuildHistReporter( read_latency_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())), + immutable_db_options_.info_log.get(), env_)), newiterator_latency_reporter_( *metrics_reporter_factory_->BuildHistReporter( newiterator_latency_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())), + immutable_db_options_.info_log.get(), env_)), seek_latency_reporter_(*metrics_reporter_factory_->BuildHistReporter( seek_latency_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())), + immutable_db_options_.info_log.get(), env_)), next_latency_reporter_(*metrics_reporter_factory_->BuildHistReporter( next_latency_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())), + immutable_db_options_.info_log.get(), env_)), seekforprev_latency_reporter_( *metrics_reporter_factory_->BuildHistReporter( seekforprev_latency_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())), + immutable_db_options_.info_log.get(), env_)), prev_latency_reporter_(*metrics_reporter_factory_->BuildHistReporter( prev_latency_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())), + immutable_db_options_.info_log.get(), env_)), write_throughput_reporter_(*metrics_reporter_factory_->BuildCountReporter( write_throughput_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())), + immutable_db_options_.info_log.get(), env_)), write_batch_size_reporter_(*metrics_reporter_factory_->BuildHistReporter( write_batch_size_metric_name, bytedance_tags_, - immutable_db_options_.info_log.get())) { + immutable_db_options_.info_log.get(), env_)) { // !batch_per_trx_ implies seq_per_batch_ because it is only unset for // WriteUnprepared, which should use seq_per_batch_. assert(batch_per_txn_ || seq_per_batch_); diff --git a/db/metrics_reporter.cc b/db/metrics_reporter.cc new file mode 100644 index 000000000..95132a3d4 --- /dev/null +++ b/db/metrics_reporter.cc @@ -0,0 +1,67 @@ +#include "rocksdb/metrics_reporter.h" + +#include + +#include +#include + +#include "rocksdb/env.h" +#include "util/logging.h" + +#define REPORT_DEBUG_STACKTRACE 1 +#if REPORT_DEBUG_STACKTRACE +#include +#endif + +namespace TERARKDB_NAMESPACE { + +LatencyHistGuard::LatencyHistGuard(HistReporterHandle* handle) + : handle_(handle), begin_time_ns_(handle_->GetEnv()->NowNanos()) { + assert(handle_ != nullptr); +} + +LatencyHistGuard::~LatencyHistGuard() { + auto us = (handle_->GetEnv()->NowNanos() - begin_time_ns_) / 1000; + handle_->AddRecord(us); +} + +LatencyHistLoggedGuard::LatencyHistLoggedGuard(HistReporterHandle* handle, + uint64_t threshold_us) + : handle_(handle), + begin_time_ns_(handle_->GetEnv()->NowNanos()), + log_threshold_us_(threshold_us) { + assert(handle_ != nullptr); +#if REPORT_DEBUG_STACKTRACE + auto stacktrace = new boost::stacktrace::stacktrace(); + start_stacktrace_ = stacktrace; +#endif +} + +LatencyHistLoggedGuard::~LatencyHistLoggedGuard() { + auto us = (handle_->GetEnv()->NowNanos() - begin_time_ns_) / 1000; + handle_->AddRecord(us); + if (us >= log_threshold_us_ && handle_->GetLogger() != nullptr) { +#if REPORT_DEBUG_STACKTRACE + auto stacktrace = + static_cast(start_stacktrace_); + ROCKS_LOG_WARN( + handle_->GetLogger(), + "[name:%s] [tags:%s]: %" PRIu64 "us\n%s----------\n%s-----------\n", + handle_->GetName(), handle_->GetTag(), us, + boost::stacktrace::to_string(*stacktrace).c_str(), + boost::stacktrace::to_string(boost::stacktrace::stacktrace()).c_str()); +#else + ROCKS_LOG_WARN(handle_->GetLogger(), "[name:%s] [tags:%s]: %" PRIu64 "us\n", + handle_->GetName(), handle_->GetTag(), + static_cast(us)); +#endif + } + +#if REPORT_DEBUG_STACKTRACE + auto stacktrace = + static_cast(start_stacktrace_); + start_stacktrace_ = nullptr; + delete stacktrace; +#endif +} +} // namespace TERARKDB_NAMESPACE \ No newline at end of file diff --git a/db/metrics_reporter_test.cc b/db/metrics_reporter_test.cc new file mode 100644 index 000000000..61f717ccb --- /dev/null +++ b/db/metrics_reporter_test.cc @@ -0,0 +1,78 @@ +#include "rocksdb/metrics_reporter.h" + +#include + +#include "port/stack_trace.h" +#include "rocksdb/env.h" +#include "rocksdb/terark_namespace.h" +#include "util/logging.h" +#include "util/mock_time_env.h" +#include "util/testharness.h" + +namespace TERARKDB_NAMESPACE { + +class TestLogger : public Logger { + public: + TestLogger(int* count) : count_(count) {} + + using Logger::Logv; + virtual void Logv(const char* /*format*/, va_list /*ap*/) override { + ++*count_; + }; + + private: + int* count_; +}; +class TestHistReporterHandle : public HistReporterHandle { + public: + TestHistReporterHandle(Env* const env) + : name_("name"), tags_("tags"), count(0), log_(&count), env_(env) {} + Env* GetEnv() { return env_; } + + ~TestHistReporterHandle() {} + + public: + void AddRecord(size_t val) override { stat_.push_back(val); } + + Logger* GetLogger() override { return &log_; } + const char* GetTag() { return tags_.c_str(); } + const char* GetName() { return name_.c_str(); } + int LoggerCount() { return count; } + + private: + const std::string name_; + const std::string tags_; + int count; + TestLogger log_; + Env* env_; + std::vector stat_; +}; + +class MockMetricsReporterTest : public testing::Test { + public: + MockMetricsReporterTest() : env_(Env::Default()), handler_(&env_) {} + + protected: + MockTimeEnv env_; + TestHistReporterHandle handler_; +}; + +TEST_F(MockMetricsReporterTest, Basic) { + ASSERT_EQ(handler_.LoggerCount(), 0); + { + LatencyHistLoggedGuard g(&handler_, 100); + env_.MockSleepForMicroseconds(100); + } + ASSERT_EQ(handler_.LoggerCount(), 1); + { + LatencyHistLoggedGuard g(&handler_, 100); + env_.MockSleepForMicroseconds(99); + } + ASSERT_EQ(handler_.LoggerCount(), 1); +} +} // namespace TERARKDB_NAMESPACE +int main(int argc, char** argv) { + TERARKDB_NAMESPACE::port::InstallStackTraceHandler(); + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} \ No newline at end of file diff --git a/include/rocksdb/metrics_reporter.h b/include/rocksdb/metrics_reporter.h index e9d7ffedb..c94e19286 100644 --- a/include/rocksdb/metrics_reporter.h +++ b/include/rocksdb/metrics_reporter.h @@ -1,17 +1,26 @@ #pragma once -#include +#include + #include #include -#include "rocksdb/env.h" #include "rocksdb/terark_namespace.h" namespace TERARKDB_NAMESPACE { + +class Env; +class Logger; + class HistReporterHandle { public: HistReporterHandle() = default; + virtual Logger* GetLogger() { return nullptr; } + virtual const char* GetTag() { return ""; } + virtual const char* GetName() { return ""; } + virtual Env* GetEnv() { return nullptr; } + virtual ~HistReporterHandle() = default; public: @@ -20,22 +29,26 @@ class HistReporterHandle { class LatencyHistGuard { public: - explicit LatencyHistGuard(HistReporterHandle* handle) - : handle_(handle), - begin_time_(std::chrono::high_resolution_clock::now()) {} - - ~LatencyHistGuard() { - if (handle_ != nullptr) { - auto us = std::chrono::duration_cast( - std::chrono::high_resolution_clock::now() - begin_time_) - .count(); - handle_->AddRecord(us); - } - } + explicit LatencyHistGuard(HistReporterHandle* handle); + + ~LatencyHistGuard(); + + private: + HistReporterHandle* handle_; + uint64_t begin_time_ns_; +}; + +class LatencyHistLoggedGuard { + public: + explicit LatencyHistLoggedGuard(HistReporterHandle* handle, + uint64_t threshold_us = 500 * 1000); + ~LatencyHistLoggedGuard(); private: HistReporterHandle* handle_; - decltype(std::chrono::high_resolution_clock::now()) begin_time_; + uint64_t begin_time_ns_; + uint64_t log_threshold_us_; + void* start_stacktrace_; }; class CountReporterHandle { @@ -57,10 +70,12 @@ class MetricsReporterFactory { public: virtual HistReporterHandle* BuildHistReporter(const std::string& name, const std::string& tags, - Logger* log) = 0; + Logger* log, + Env* const env) = 0; virtual CountReporterHandle* BuildCountReporter(const std::string& name, const std::string& tags, - Logger* log) = 0; + Logger* log, + Env* const env) = 0; }; } // namespace TERARKDB_NAMESPACE \ No newline at end of file diff --git a/utilities/trace/bytedance_metrics_reporter.cc b/utilities/trace/bytedance_metrics_reporter.cc index 439badcfd..c80b976a6 100644 --- a/utilities/trace/bytedance_metrics_reporter.cc +++ b/utilities/trace/bytedance_metrics_reporter.cc @@ -2,7 +2,6 @@ #include #include - #ifdef TERARKDB_ENABLE_METRICS #include "metrics.h" #endif @@ -12,6 +11,8 @@ namespace TERARKDB_NAMESPACE { +const int kNanosInMilli = 1000000; + #ifdef TERARKDB_ENABLE_METRICS static std::mutex metrics_mtx; static std::atomic metrics_init{false}; @@ -50,8 +51,8 @@ static int GetThreadID() { } #else namespace { -static ByteDanceHistReporterHandle dummy_hist_("", "", nullptr); -static ByteDanceCountReporterHandle dummy_count_("", "", nullptr); +static ByteDanceHistReporterHandle dummy_hist_("", "", nullptr, nullptr); +static ByteDanceCountReporterHandle dummy_count_("", "", nullptr, nullptr); } // namespace #endif @@ -65,22 +66,18 @@ void ByteDanceHistReporterHandle::AddRecord(size_t val) { auto& tls_stat = *tls_stat_ptr; tls_stat.AppendRecord(val); - auto curr_time = std::chrono::high_resolution_clock::now(); - auto diff_ms = std::chrono::duration_cast( - curr_time - tls_stat.last_report_time) - .count(); + auto curr_time_ns = env_->NowNanos(); + auto diff_ms = (curr_time_ns - tls_stat.last_report_time_ns_) / kNanosInMilli; if (diff_ms > 1000 && !merge_lock_.load(std::memory_order_relaxed) && !merge_lock_.exchange(true, std::memory_order_acquire)) { stats_.Merge(tls_stat); - diff_ms = std::chrono::duration_cast( - curr_time - stats_.last_report_time) - .count(); + diff_ms = (curr_time_ns - stats_.last_report_time_ns_) / kNanosInMilli; if (diff_ms > 5000) { auto result = stats_.GetResult({0.50, 0.99, 0.999}); stats_.Reset(); - stats_.last_report_time = curr_time; + stats_.last_report_time_ns_ = curr_time_ns; merge_lock_.store(false, std::memory_order_release); cpputil::metrics2::Metrics::emit_store(name_ + "_p50", result[0], tags_); @@ -89,9 +86,7 @@ void ByteDanceHistReporterHandle::AddRecord(size_t val) { cpputil::metrics2::Metrics::emit_store(name_ + "_avg", result[3], tags_); cpputil::metrics2::Metrics::emit_store(name_ + "_max", result[4], tags_); - diff_ms = std::chrono::duration_cast( - curr_time - last_log_time_) - .count(); + diff_ms = (curr_time_ns - last_log_time_ns_) / kNanosInMilli; if (diff_ms > 10 * 60 * 1000) { ROCKS_LOG_INFO(log_, "name:%s P50, tags:%s, val:%zu", name_.c_str(), tags_.c_str(), result[0]); @@ -103,14 +98,14 @@ void ByteDanceHistReporterHandle::AddRecord(size_t val) { tags_.c_str(), result[3]); ROCKS_LOG_INFO(log_, "name:%s Max, tags:%s, val:%zu", name_.c_str(), tags_.c_str(), result[4]); - last_log_time_ = curr_time; + last_log_time_ns_ = curr_time_ns; } } else { merge_lock_.store(false, std::memory_order_release); } tls_stat.Reset(); - tls_stat.last_report_time = curr_time; + tls_stat.last_report_time_ns_ = curr_time_ns; } } #else @@ -125,7 +120,7 @@ HistStats<>* ByteDanceHistReporterHandle::GetThreadLocalStats() { } auto& s = stats_arr_[id]; if (s == nullptr) { - s = new HistStats<>; + s = new HistStats<>(env_->NowNanos()); } return s; #else @@ -138,27 +133,22 @@ void ByteDanceCountReporterHandle::AddCount(size_t n) { count_.fetch_add(n, std::memory_order_relaxed); if (!reporter_lock_.load(std::memory_order_relaxed)) { if (!reporter_lock_.exchange(true, std::memory_order_acquire)) { - auto curr_time = std::chrono::high_resolution_clock::now(); - auto diff_ms = std::chrono::duration_cast( - curr_time - last_report_time_) - .count(); - + auto curr_time_ns = env_->NowNanos(); + auto diff_ms = (curr_time_ns - last_report_time_ns_) / kNanosInMilli; if (diff_ms > 1000) { size_t curr_count = count_.load(std::memory_order_relaxed); size_t qps = (curr_count - last_report_count_) / (static_cast(diff_ms) / 1000); cpputil::metrics2::Metrics::emit_store(name_, qps, tags_); - last_report_time_ = curr_time; + last_report_time_ns_ = curr_time_ns; last_report_count_ = curr_count; - diff_ms = std::chrono::duration_cast( - curr_time - last_log_time_) - .count(); + diff_ms = (curr_time_ns - last_log_time_ns_) / kNanosInMilli; if (diff_ms > 10 * 60 * 1000) { ROCKS_LOG_INFO(log_, "name:%s, tags:%s, val:%zu", name_.c_str(), tags_.c_str(), qps); - last_log_time_ = curr_time; + last_log_time_ns_ = curr_time_ns; } } reporter_lock_.store(false, std::memory_order_release); @@ -203,14 +193,16 @@ void ByteDanceMetricsReporterFactory::InitNamespace(const std::string&) {} #ifdef TERARKDB_ENABLE_METRICS ByteDanceHistReporterHandle* ByteDanceMetricsReporterFactory::BuildHistReporter( - const std::string& name, const std::string& tags, Logger* log) { + const std::string& name, const std::string& tags, Logger* log, + Env* const env) { std::lock_guard guard(metrics_mtx); - hist_reporters_.emplace_back(name, tags, log); + hist_reporters_.emplace_back(name, tags, log, env); return &hist_reporters_.back(); } #else ByteDanceHistReporterHandle* ByteDanceMetricsReporterFactory::BuildHistReporter( - const std::string& /*name*/, const std::string& /*tags*/, Logger* /*log*/) { + const std::string& /*name*/, const std::string& /*tags*/, Logger* /*log*/, + Env* const /*env*/) { return &dummy_hist_; } #endif @@ -219,16 +211,18 @@ ByteDanceHistReporterHandle* ByteDanceMetricsReporterFactory::BuildHistReporter( ByteDanceCountReporterHandle* ByteDanceMetricsReporterFactory::BuildCountReporter(const std::string& name, const std::string& tags, - Logger* log) { + Logger* log, + Env* const env) { std::lock_guard guard(metrics_mtx); - count_reporters_.emplace_back(name, tags, log); + count_reporters_.emplace_back(name, tags, log, env); return &count_reporters_.back(); } #else ByteDanceCountReporterHandle* ByteDanceMetricsReporterFactory::BuildCountReporter(const std::string& /*name*/, const std::string& /*tags*/, - Logger* /*log*/) { + Logger* /*log*/, + Env* const /*env*/) { return &dummy_count_; } #endif diff --git a/utilities/trace/bytedance_metrics_reporter.h b/utilities/trace/bytedance_metrics_reporter.h index e8fb33da1..e58674b36 100644 --- a/utilities/trace/bytedance_metrics_reporter.h +++ b/utilities/trace/bytedance_metrics_reporter.h @@ -1,25 +1,27 @@ #include -#include -#include +#include #include "rocksdb/env.h" #include "rocksdb/metrics_reporter.h" #include "rocksdb/terark_namespace.h" #include "stats.h" - namespace TERARKDB_NAMESPACE { class ByteDanceHistReporterHandle : public HistReporterHandle { public: #ifdef TERARKDB_ENABLE_METRICS ByteDanceHistReporterHandle(const std::string& name, const std::string& tags, - Logger* log) + Logger* log, Env* const env) : name_(name), tags_(tags), - last_log_time_(std::chrono::high_resolution_clock::now()), - log_(log) {} + env_(env), + last_log_time_ns_(env_->NowNanos()), + log_(log), + stats_(env_->NowNanos()) {} + virtual Env* GetEnv() override { return env_; } #else ByteDanceHistReporterHandle(const std::string& /*name*/, - const std::string& /*tags*/, Logger* /*log*/) {} + const std::string& /*tags*/, Logger* /*log*/, + Env* const /*env*/) {} #endif ~ByteDanceHistReporterHandle() override { @@ -33,6 +35,28 @@ class ByteDanceHistReporterHandle : public HistReporterHandle { public: void AddRecord(size_t val) override; + Logger* GetLogger() override { +#ifdef TERARKDB_ENABLE_METRICS + return log_; +#else + return nullptr; +#endif + } + const char* GetTag() { +#ifdef TERARKDB_ENABLE_METRICS + return tags_.c_str(); +#else + return ""; +#endif + } + const char* GetName() { +#ifdef TERARKDB_ENABLE_METRICS + return name_.c_str(); +#else + return ""; +#endif + } + private: #ifdef TERARKDB_ENABLE_METRICS enum { @@ -41,8 +65,9 @@ class ByteDanceHistReporterHandle : public HistReporterHandle { const std::string& name_; const std::string& tags_; + Env* env_; - std::chrono::high_resolution_clock::time_point last_log_time_; + uint64_t last_log_time_ns_; Logger* log_; std::array*, kMaxThreadNum> stats_arr_{}; @@ -58,15 +83,17 @@ class ByteDanceCountReporterHandle : public CountReporterHandle { public: #ifdef TERARKDB_ENABLE_METRICS ByteDanceCountReporterHandle(const std::string& name, const std::string& tags, - Logger* log) + Logger* log, Env* const env) : name_(name), tags_(tags), - last_report_time_(std::chrono::high_resolution_clock::now()), - last_log_time_(std::chrono::high_resolution_clock::now()), + env_(env), + last_report_time_ns_(env_->NowNanos()), + last_log_time_ns_(env_->NowNanos()), log_(log) {} #else ByteDanceCountReporterHandle(const std::string& /*name*/, - const std::string& /*tags*/, Logger* /*log*/) {} + const std::string& /*tags*/, Logger* /*log*/, + Env* const /*env*/) {} #endif ~ByteDanceCountReporterHandle() override = default; @@ -80,15 +107,13 @@ class ByteDanceCountReporterHandle : public CountReporterHandle { const std::string& name_; const std::string& tags_; - - std::chrono::high_resolution_clock::time_point last_report_time_; + Env* const env_; + uint64_t last_report_time_ns_; size_t last_report_count_ = 0; - std::chrono::high_resolution_clock::time_point last_log_time_; + uint64_t last_log_time_ns_; Logger* log_; - char _padding_[64 /* x86 cache line size */ - 8 * 7]; - std::atomic count_{0}; #endif }; @@ -97,23 +122,25 @@ class ByteDanceMetricsReporterFactory : public MetricsReporterFactory { public: ByteDanceMetricsReporterFactory(); - ByteDanceMetricsReporterFactory(const std::string& ns); + explicit ByteDanceMetricsReporterFactory(const std::string& ns); ~ByteDanceMetricsReporterFactory() override = default; public: ByteDanceHistReporterHandle* BuildHistReporter(const std::string& name, const std::string& tags, - Logger* log) override; + Logger* log, + Env* const env) override; ByteDanceCountReporterHandle* BuildCountReporter(const std::string& name, const std::string& tags, - Logger* log) override; + Logger* log, + Env* const env) override; private: #ifdef TERARKDB_ENABLE_METRICS - std::list hist_reporters_; - std::list count_reporters_; + std::deque hist_reporters_; + std::deque count_reporters_; #endif void InitNamespace(const std::string& ns); diff --git a/utilities/trace/stats.h b/utilities/trace/stats.h index cd678684b..b7768e02d 100644 --- a/utilities/trace/stats.h +++ b/utilities/trace/stats.h @@ -2,7 +2,6 @@ #include #include -#include #include #include #include @@ -14,7 +13,8 @@ namespace TERARKDB_NAMESPACE { template // 10ms class HistStats { public: - HistStats() : last_report_time(std::chrono::high_resolution_clock::now()) {} + explicit HistStats(uint64_t last_report_time_ns) + : last_report_time_ns_(last_report_time_ns) {} void AppendRecord(size_t us) { if (us < buckets_.size()) { @@ -82,7 +82,7 @@ class HistStats { } } - std::chrono::high_resolution_clock::time_point last_report_time; + uint64_t last_report_time_ns_; private: std::array buckets_{}; -- GitLab