#include <sstream>
#include "monitoring/histogram.h"
+#include "rocksdb/system_clock.h"
+#include "rocksdb/trace_record.h"
#include "util/gflags_compat.h"
#include "util/string_util.h"
}
std::map<uint64_t, std::map<std::string, std::map<uint64_t, double>>>
cs_name_timeline;
- uint64_t start_time = port::kMaxUint64;
+ uint64_t start_time = std::numeric_limits<uint64_t>::max();
uint64_t end_time = 0;
const std::map<uint64_t, uint64_t>& trace_num_misses =
adjust_time_unit(miss_ratio_stats_.num_misses_timeline(), time_unit);
auto it = trace_num_accesses.find(time);
assert(it != trace_num_accesses.end());
uint64_t access = it->second;
- cs_name_timeline[port::kMaxUint64]["trace"][time] = percent(miss, access);
+ cs_name_timeline[std::numeric_limits<uint64_t>::max()]["trace"][time] =
+ percent(miss, access);
}
for (auto const& config_caches : cache_simulator_->sim_caches()) {
const CacheConfiguration& config = config_caches.first;
}
std::map<uint64_t, std::map<std::string, std::map<uint64_t, uint64_t>>>
cs_name_timeline;
- uint64_t start_time = port::kMaxUint64;
+ uint64_t start_time = std::numeric_limits<uint64_t>::max();
uint64_t end_time = 0;
const std::map<uint64_t, uint64_t>& trace_num_misses =
adjust_time_unit(miss_ratio_stats_.num_misses_timeline(), time_unit);
start_time = std::min(start_time, time);
end_time = std::max(end_time, time);
uint64_t miss = num_miss.second;
- cs_name_timeline[port::kMaxUint64]["trace"][time] = miss;
+ cs_name_timeline[std::numeric_limits<uint64_t>::max()]["trace"][time] =
+ miss;
}
for (auto const& config_caches : cache_simulator_->sim_caches()) {
const CacheConfiguration& config = config_caches.first;
for (auto const& percent : percent_buckets) {
label_bucket_naccesses[label_str][percent] = 0;
size_t end_index = 0;
- if (percent == port::kMaxUint64) {
+ if (percent == std::numeric_limits<uint64_t>::max()) {
end_index = label_naccesses.size();
} else {
end_index = percent * label_naccesses.size() / 100;
uint64_t time_unit,
bool user_access_only) const {
std::set<std::string> labels = ParseLabelStr(label_str);
- uint64_t start_time = port::kMaxUint64;
+ uint64_t start_time = std::numeric_limits<uint64_t>::max();
uint64_t end_time = 0;
std::map<std::string, std::map<uint64_t, uint64_t>> label_access_timeline;
std::map<uint64_t, std::vector<std::string>> access_count_block_id_map;
kMicrosInSecond) /
block.num_accesses;
} else {
- avg_reuse_interval = port::kMaxUint64 - 1;
+ avg_reuse_interval = std::numeric_limits<uint64_t>::max() - 1;
}
if (labels.find(kGroupbyCaller) != labels.end()) {
for (auto const& timeline : block.caller_num_accesses_timeline) {
lifetime =
(block.last_access_time - block.first_access_time) / kMicrosInSecond;
} else {
- lifetime = port::kMaxUint64 - 1;
+ lifetime = std::numeric_limits<uint64_t>::max() - 1;
}
const std::string label = BuildLabel(
labels, cf_name, fd, level, type,
}
void BlockCacheTraceAnalyzer::WriteBlockReuseTimeline(
- const uint64_t reuse_window, bool user_access_only, TraceType block_type) const {
+ const uint64_t reuse_window, bool user_access_only,
+ TraceType block_type) const {
// A map from block key to an array of bools that states whether a block is
// accessed in a time window.
std::map<uint64_t, std::vector<bool>> block_accessed;
TraverseBlocks(block_callback);
// A cell is the number of blocks accessed in a reuse window.
- std::unique_ptr<uint64_t[]> reuse_table(new uint64_t[reuse_vector_size * reuse_vector_size]);
+ std::unique_ptr<uint64_t[]> reuse_table(
+ new uint64_t[reuse_vector_size * reuse_vector_size]);
for (uint64_t start_time = 0; start_time < reuse_vector_size; start_time++) {
// Initialize the reuse_table.
for (uint64_t i = 0; i < reuse_vector_size; i++) {
if (j < start_time) {
row += "100.0";
} else {
- row += std::to_string(percent(reuse_table[start_time * reuse_vector_size + j],
- reuse_table[start_time * reuse_vector_size + start_time]));
+ row += std::to_string(
+ percent(reuse_table[start_time * reuse_vector_size + j],
+ reuse_table[start_time * reuse_vector_size + start_time]));
}
}
out << row << std::endl;
}
Status BlockCacheTraceAnalyzer::Analyze() {
+ SystemClock* clock = env_->GetSystemClock().get();
std::unique_ptr<BlockCacheTraceReader> reader;
Status s = Status::OK();
if (is_human_readable_trace_file_) {
return s;
}
}
- uint64_t start = env_->NowMicros();
+ uint64_t start = clock->NowMicros();
uint64_t time_interval = 0;
while (s.ok()) {
BlockCacheTraceRecord access;
trace_end_timestamp_in_seconds_ = access.access_timestamp / kMicrosInSecond;
miss_ratio_stats_.UpdateMetrics(access.access_timestamp,
is_user_access(access.caller),
- access.is_cache_hit == Boolean::kFalse);
+ !access.is_cache_hit);
if (cache_simulator_) {
cache_simulator_->Access(access);
}
access_sequence_number_++;
- uint64_t now = env_->NowMicros();
+ uint64_t now = clock->NowMicros();
uint64_t duration = (now - start) / kMicrosInSecond;
if (duration > 10 * time_interval) {
uint64_t trace_duration =
time_interval++;
}
}
- uint64_t now = env_->NowMicros();
+ uint64_t now = clock->NowMicros();
uint64_t duration = (now - start) / kMicrosInSecond;
uint64_t trace_duration =
trace_end_timestamp_in_seconds_ - trace_start_timestamp_in_seconds_;
return;
}
// Use four decimal points.
- uint64_t percent_referenced_for_existing_keys = (uint64_t)(
- ((double)block.key_num_access_map.size() / (double)block.num_keys) *
- 10000.0);
+ uint64_t percent_referenced_for_existing_keys =
+ (uint64_t)(((double)block.key_num_access_map.size() /
+ (double)block.num_keys) *
+ 10000.0);
uint64_t percent_referenced_for_non_existing_keys =
(uint64_t)(((double)block.non_exist_key_num_access_map.size() /
(double)block.num_keys) *
getline(ss, bucket, ',');
buckets.push_back(ParseUint64(bucket));
}
- buckets.push_back(port::kMaxUint64);
+ buckets.push_back(std::numeric_limits<uint64_t>::max());
return buckets;
}
projects / ceph.git / blobdiff