// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
-// This source code is licensed under the BSD-style license found in the
-// LICENSE file in the root directory of this source tree. An additional grant
-// of patent rights can be found in the PATENTS file in the same directory.
+// This source code is licensed under both the GPLv2 (found in the
+// COPYING file in the root directory) and Apache 2.0 License
+// (found in the LICENSE.Apache file in the root directory).
//
#include "monitoring/statistics.h"
return std::make_shared<StatisticsImpl>(nullptr, false);
}
-StatisticsImpl::StatisticsImpl(
- std::shared_ptr<Statistics> stats,
- bool enable_internal_stats)
- : stats_shared_(stats),
- stats_(stats.get()),
- enable_internal_stats_(enable_internal_stats) {
-}
+StatisticsImpl::StatisticsImpl(std::shared_ptr<Statistics> stats,
+ bool enable_internal_stats)
+ : stats_(std::move(stats)), enable_internal_stats_(enable_internal_stats) {}
StatisticsImpl::~StatisticsImpl() {}
enable_internal_stats_ ?
tickerType < INTERNAL_TICKER_ENUM_MAX :
tickerType < TICKER_ENUM_MAX);
- uint64_t thread_local_sum = 0;
- tickers_[tickerType].thread_value->Fold(
- [](void* curr_ptr, void* res) {
- auto* sum_ptr = static_cast<uint64_t*>(res);
- *sum_ptr += static_cast<std::atomic_uint_fast64_t*>(curr_ptr)->load(
- std::memory_order_relaxed);
- },
- &thread_local_sum);
- return thread_local_sum +
- tickers_[tickerType].merged_sum.load(std::memory_order_relaxed);
-}
-
-std::unique_ptr<HistogramImpl>
-StatisticsImpl::HistogramInfo::getMergedHistogram() const {
- std::unique_ptr<HistogramImpl> res_hist(new HistogramImpl());
- {
- MutexLock lock(&merge_lock);
- res_hist->Merge(merged_hist);
+ uint64_t res = 0;
+ for (size_t core_idx = 0; core_idx < per_core_stats_.Size(); ++core_idx) {
+ res += per_core_stats_.AccessAtCore(core_idx)->tickers_[tickerType];
}
- thread_value->Fold(
- [](void* curr_ptr, void* res) {
- auto tmp_res_hist = static_cast<HistogramImpl*>(res);
- auto curr_hist = static_cast<HistogramImpl*>(curr_ptr);
- tmp_res_hist->Merge(*curr_hist);
- },
- res_hist.get());
- return res_hist;
+ return res;
}
void StatisticsImpl::histogramData(uint32_t histogramType,
HistogramData* const data) const {
MutexLock lock(&aggregate_lock_);
- histogramDataLocked(histogramType, data);
+ getHistogramImplLocked(histogramType)->Data(data);
}
-void StatisticsImpl::histogramDataLocked(uint32_t histogramType,
- HistogramData* const data) const {
+std::unique_ptr<HistogramImpl> StatisticsImpl::getHistogramImplLocked(
+ uint32_t histogramType) const {
assert(
enable_internal_stats_ ?
histogramType < INTERNAL_HISTOGRAM_ENUM_MAX :
histogramType < HISTOGRAM_ENUM_MAX);
- histograms_[histogramType].getMergedHistogram()->Data(data);
+ std::unique_ptr<HistogramImpl> res_hist(new HistogramImpl());
+ for (size_t core_idx = 0; core_idx < per_core_stats_.Size(); ++core_idx) {
+ res_hist->Merge(
+ per_core_stats_.AccessAtCore(core_idx)->histograms_[histogramType]);
+ }
+ return res_hist;
}
std::string StatisticsImpl::getHistogramString(uint32_t histogramType) const {
MutexLock lock(&aggregate_lock_);
- assert(enable_internal_stats_ ? histogramType < INTERNAL_HISTOGRAM_ENUM_MAX
- : histogramType < HISTOGRAM_ENUM_MAX);
- return histograms_[histogramType].getMergedHistogram()->ToString();
-}
-
-StatisticsImpl::ThreadTickerInfo* StatisticsImpl::getThreadTickerInfo(
- uint32_t tickerType) {
- auto info_ptr =
- static_cast<ThreadTickerInfo*>(tickers_[tickerType].thread_value->Get());
- if (info_ptr == nullptr) {
- info_ptr =
- new ThreadTickerInfo(0 /* value */, &tickers_[tickerType].merged_sum);
- tickers_[tickerType].thread_value->Reset(info_ptr);
- }
- return info_ptr;
-}
-
-StatisticsImpl::ThreadHistogramInfo* StatisticsImpl::getThreadHistogramInfo(
- uint32_t histogram_type) {
- auto info_ptr = static_cast<ThreadHistogramInfo*>(
- histograms_[histogram_type].thread_value->Get());
- if (info_ptr == nullptr) {
- info_ptr = new ThreadHistogramInfo(&histograms_[histogram_type].merged_hist,
- &histograms_[histogram_type].merge_lock);
- histograms_[histogram_type].thread_value->Reset(info_ptr);
- }
- return info_ptr;
+ return getHistogramImplLocked(histogramType)->ToString();
}
void StatisticsImpl::setTickerCount(uint32_t tickerType, uint64_t count) {
void StatisticsImpl::setTickerCountLocked(uint32_t tickerType, uint64_t count) {
assert(enable_internal_stats_ ? tickerType < INTERNAL_TICKER_ENUM_MAX
: tickerType < TICKER_ENUM_MAX);
- if (tickerType < TICKER_ENUM_MAX || enable_internal_stats_) {
- tickers_[tickerType].thread_value->Fold(
- [](void* curr_ptr, void* res) {
- static_cast<std::atomic<uint64_t>*>(curr_ptr)->store(
- 0, std::memory_order_relaxed);
- },
- nullptr /* res */);
- tickers_[tickerType].merged_sum.store(count, std::memory_order_relaxed);
+ for (size_t core_idx = 0; core_idx < per_core_stats_.Size(); ++core_idx) {
+ if (core_idx == 0) {
+ per_core_stats_.AccessAtCore(core_idx)->tickers_[tickerType] = count;
+ } else {
+ per_core_stats_.AccessAtCore(core_idx)->tickers_[tickerType] = 0;
+ }
}
}
MutexLock lock(&aggregate_lock_);
assert(enable_internal_stats_ ? tickerType < INTERNAL_TICKER_ENUM_MAX
: tickerType < TICKER_ENUM_MAX);
- if (tickerType < TICKER_ENUM_MAX || enable_internal_stats_) {
- tickers_[tickerType].thread_value->Fold(
- [](void* curr_ptr, void* res) {
- auto* sum_ptr = static_cast<uint64_t*>(res);
- *sum_ptr += static_cast<std::atomic<uint64_t>*>(curr_ptr)->exchange(
- 0, std::memory_order_relaxed);
- },
- &sum);
- sum += tickers_[tickerType].merged_sum.exchange(
- 0, std::memory_order_relaxed);
+ for (size_t core_idx = 0; core_idx < per_core_stats_.Size(); ++core_idx) {
+ sum +=
+ per_core_stats_.AccessAtCore(core_idx)->tickers_[tickerType].exchange(
+ 0, std::memory_order_relaxed);
}
}
if (stats_ && tickerType < TICKER_ENUM_MAX) {
enable_internal_stats_ ?
tickerType < INTERNAL_TICKER_ENUM_MAX :
tickerType < TICKER_ENUM_MAX);
- if (tickerType < TICKER_ENUM_MAX || enable_internal_stats_) {
- auto info_ptr = getThreadTickerInfo(tickerType);
- info_ptr->value.fetch_add(count, std::memory_order_relaxed);
- }
+ per_core_stats_.Access()->tickers_[tickerType].fetch_add(
+ count, std::memory_order_relaxed);
if (stats_ && tickerType < TICKER_ENUM_MAX) {
stats_->recordTick(tickerType, count);
}
enable_internal_stats_ ?
histogramType < INTERNAL_HISTOGRAM_ENUM_MAX :
histogramType < HISTOGRAM_ENUM_MAX);
- if (histogramType < HISTOGRAM_ENUM_MAX || enable_internal_stats_) {
- getThreadHistogramInfo(histogramType)->value.Add(value);
- }
+ per_core_stats_.Access()->histograms_[histogramType].Add(value);
if (stats_ && histogramType < HISTOGRAM_ENUM_MAX) {
stats_->measureTime(histogramType, value);
}
setTickerCountLocked(i, 0);
}
for (uint32_t i = 0; i < HISTOGRAM_ENUM_MAX; ++i) {
- histograms_[i].thread_value->Fold(
- [](void* curr_ptr, void* res) {
- static_cast<HistogramImpl*>(curr_ptr)->Clear();
- },
- nullptr /* res */);
+ for (size_t core_idx = 0; core_idx < per_core_stats_.Size(); ++core_idx) {
+ per_core_stats_.AccessAtCore(core_idx)->histograms_[i].Clear();
+ }
}
return Status::OK();
}
if (h.first < HISTOGRAM_ENUM_MAX || enable_internal_stats_) {
char buffer[kTmpStrBufferSize];
HistogramData hData;
- histogramDataLocked(h.first, &hData);
- snprintf(
+ getHistogramImplLocked(h.first)->Data(&hData);
+ // don't handle failures - buffer should always be big enough and arguments
+ // should be provided correctly
+ int ret = snprintf(
buffer, kTmpStrBufferSize,
- "%s statistics Percentiles :=> 50 : %f 95 : %f 99 : %f 100 : %f\n",
- h.second.c_str(), hData.median, hData.percentile95,
- hData.percentile99, hData.max);
+ "%s P50 : %f P95 : %f P99 : %f P100 : %f COUNT : %" PRIu64 " SUM : %"
+ PRIu64 "\n", h.second.c_str(), hData.median, hData.percentile95,
+ hData.percentile99, hData.max, hData.count, hData.sum);
+ if (ret < 0 || ret >= kTmpStrBufferSize) {
+ assert(false);
+ continue;
+ }
res.append(buffer);
}
}
projects / ceph.git / blobdiff