2016-02-09 23:12:00 +00:00
|
|
|
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
2013-10-16 21:59:46 +00:00
|
|
|
// 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.
|
|
|
|
//
|
2013-10-05 05:32:05 +00:00
|
|
|
#pragma once
|
2013-08-23 15:38:13 +00:00
|
|
|
#include "rocksdb/env.h"
|
2014-01-17 20:46:06 +00:00
|
|
|
#include "util/statistics.h"
|
2013-02-15 19:53:17 +00:00
|
|
|
|
2013-10-04 04:49:15 +00:00
|
|
|
namespace rocksdb {
|
2013-05-17 17:55:34 +00:00
|
|
|
// Auto-scoped.
|
2014-07-28 19:22:37 +00:00
|
|
|
// Records the measure time into the corresponding histogram if statistics
|
|
|
|
// is not nullptr. It is also saved into *elapsed if the pointer is not nullptr.
|
2013-02-15 19:53:17 +00:00
|
|
|
class StopWatch {
|
|
|
|
public:
|
2014-07-28 19:05:36 +00:00
|
|
|
StopWatch(Env * const env, Statistics* statistics,
|
2014-07-28 19:22:37 +00:00
|
|
|
const uint32_t hist_type,
|
|
|
|
uint64_t* elapsed = nullptr)
|
2014-07-28 19:05:36 +00:00
|
|
|
: env_(env),
|
2013-05-17 17:55:34 +00:00
|
|
|
statistics_(statistics),
|
2014-07-28 19:05:36 +00:00
|
|
|
hist_type_(hist_type),
|
2014-07-28 19:22:37 +00:00
|
|
|
elapsed_(elapsed),
|
|
|
|
stats_enabled_(statistics && statistics->HistEnabledForType(hist_type)),
|
|
|
|
start_time_((stats_enabled_ || elapsed != nullptr) ?
|
|
|
|
env->NowMicros() : 0) {
|
2014-07-28 19:05:36 +00:00
|
|
|
}
|
2013-02-15 19:53:17 +00:00
|
|
|
|
|
|
|
|
2014-07-28 19:05:36 +00:00
|
|
|
~StopWatch() {
|
2014-07-28 19:22:37 +00:00
|
|
|
if (elapsed_) {
|
|
|
|
*elapsed_ = env_->NowMicros() - start_time_;
|
|
|
|
}
|
|
|
|
if (stats_enabled_) {
|
|
|
|
statistics_->measureTime(hist_type_,
|
|
|
|
(elapsed_ != nullptr) ? *elapsed_ :
|
|
|
|
(env_->NowMicros() - start_time_));
|
2014-07-28 19:05:36 +00:00
|
|
|
}
|
|
|
|
}
|
2013-02-15 19:53:17 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
Env* const env_;
|
2013-11-22 22:14:05 +00:00
|
|
|
Statistics* statistics_;
|
2014-07-28 19:05:36 +00:00
|
|
|
const uint32_t hist_type_;
|
2014-07-28 19:22:37 +00:00
|
|
|
uint64_t* elapsed_;
|
|
|
|
bool stats_enabled_;
|
2014-07-28 19:05:36 +00:00
|
|
|
const uint64_t start_time_;
|
2013-02-15 19:53:17 +00:00
|
|
|
};
|
[RocksDB] Added nano second stopwatch and new perf counters to track block read cost
Summary: The pupose of this diff is to expose per user-call level precise timing of block read, so that we can answer questions like: a Get() costs me 100ms, is that somehow related to loading blocks from file system, or sth else? We will answer that with EXACTLY how many blocks have been read, how much time was spent on transfering the bytes from os, how much time was spent on checksum verification and how much time was spent on block decompression, just for that one Get. A nano second stopwatch was introduced to track time with higher precision. The cost/precision of the stopwatch is also measured in unit-test. On my dev box, retrieving one time instance costs about 30ns, on average. The deviation of timing results is good enough to track 100ns-1us level events. And the overhead could be safely ignored for 100us level events (10000 instances/s), for example, a viewstate thrift call.
Test Plan: perf_context_test, also testing with viewstate shadow traffic.
Reviewers: dhruba
Reviewed By: dhruba
CC: leveldb, xjin
Differential Revision: https://reviews.facebook.net/D12351
2013-06-04 06:09:15 +00:00
|
|
|
|
|
|
|
// a nano second precision stopwatch
|
|
|
|
class StopWatchNano {
|
|
|
|
public:
|
2013-11-22 22:14:05 +00:00
|
|
|
explicit StopWatchNano(Env* const env, bool auto_start = false)
|
[RocksDB] Added nano second stopwatch and new perf counters to track block read cost
Summary: The pupose of this diff is to expose per user-call level precise timing of block read, so that we can answer questions like: a Get() costs me 100ms, is that somehow related to loading blocks from file system, or sth else? We will answer that with EXACTLY how many blocks have been read, how much time was spent on transfering the bytes from os, how much time was spent on checksum verification and how much time was spent on block decompression, just for that one Get. A nano second stopwatch was introduced to track time with higher precision. The cost/precision of the stopwatch is also measured in unit-test. On my dev box, retrieving one time instance costs about 30ns, on average. The deviation of timing results is good enough to track 100ns-1us level events. And the overhead could be safely ignored for 100us level events (10000 instances/s), for example, a viewstate thrift call.
Test Plan: perf_context_test, also testing with viewstate shadow traffic.
Reviewers: dhruba
Reviewed By: dhruba
CC: leveldb, xjin
Differential Revision: https://reviews.facebook.net/D12351
2013-06-04 06:09:15 +00:00
|
|
|
: env_(env), start_(0) {
|
|
|
|
if (auto_start) {
|
|
|
|
Start();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Start() { start_ = env_->NowNanos(); }
|
|
|
|
|
|
|
|
uint64_t ElapsedNanos(bool reset = false) {
|
|
|
|
auto now = env_->NowNanos();
|
|
|
|
auto elapsed = now - start_;
|
|
|
|
if (reset) {
|
|
|
|
start_ = now;
|
|
|
|
}
|
|
|
|
return elapsed;
|
|
|
|
}
|
|
|
|
|
Compaction filter on merge operands
Summary:
Since Andres' internship is over, I took over https://reviews.facebook.net/D42555 and rebased and simplified it a bit.
The behavior in this diff is a bit simpler than in D42555:
* only merge operators are passed through FilterMergeValue(). If fitler function returns true, the merge operator is ignored
* compaction filter is *not* called on: 1) results of merge operations and 2) base values that are getting merged with merge operands (the second case was also true in previous diff)
Do we also need a compaction filter to get called on merge results?
Test Plan: make && make check
Reviewers: lovro, tnovak, rven, yhchiang, sdong
Reviewed By: sdong
Subscribers: noetzli, kolmike, leveldb, dhruba, sdong
Differential Revision: https://reviews.facebook.net/D47847
2015-10-07 16:30:03 +00:00
|
|
|
uint64_t ElapsedNanosSafe(bool reset = false) {
|
|
|
|
return (env_ != nullptr) ? ElapsedNanos(reset) : 0U;
|
|
|
|
}
|
|
|
|
|
[RocksDB] Added nano second stopwatch and new perf counters to track block read cost
Summary: The pupose of this diff is to expose per user-call level precise timing of block read, so that we can answer questions like: a Get() costs me 100ms, is that somehow related to loading blocks from file system, or sth else? We will answer that with EXACTLY how many blocks have been read, how much time was spent on transfering the bytes from os, how much time was spent on checksum verification and how much time was spent on block decompression, just for that one Get. A nano second stopwatch was introduced to track time with higher precision. The cost/precision of the stopwatch is also measured in unit-test. On my dev box, retrieving one time instance costs about 30ns, on average. The deviation of timing results is good enough to track 100ns-1us level events. And the overhead could be safely ignored for 100us level events (10000 instances/s), for example, a viewstate thrift call.
Test Plan: perf_context_test, also testing with viewstate shadow traffic.
Reviewers: dhruba
Reviewed By: dhruba
CC: leveldb, xjin
Differential Revision: https://reviews.facebook.net/D12351
2013-06-04 06:09:15 +00:00
|
|
|
private:
|
|
|
|
Env* const env_;
|
|
|
|
uint64_t start_;
|
|
|
|
};
|
|
|
|
|
2013-10-04 04:49:15 +00:00
|
|
|
} // namespace rocksdb
|