blob: 73d62af7b0bb3581e0712ecd9ad2325a137485fb [file] [log] [blame]
// Copyright 2011 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef NINJA_METRICS_H_
#define NINJA_METRICS_H_
#include <atomic>
#include <mutex>
#include <string>
#include <vector>
using namespace std;
#include "util.h" // For int64_t.
/// The Metrics module is used for the debug mode that dumps timing stats of
/// various actions. To use, see METRIC_RECORD below.
/// A single metrics we're tracking, like "depfile load time".
struct Metric {
Metric(const std::string& name) : name_(name) {}
void AddResult(int count, int64_t time_us) {
thread_local size_t this_slot = GetThreadSlotIndex();
Slot& slot = slots_[this_slot];
slot.count += count;
slot.time += time_us;
}
const std::string& name() const { return name_; }
int count() const {
int result = 0;
for (const Slot& slot : slots_) {
result += slot.count;
}
return result;
}
int64_t time() const {
int64_t result = 0;
for (const Slot& slot : slots_) {
result += slot.time;
}
return result;
}
private:
/// Try to give each thread a different slot to reduce thread contention.
struct NINJA_ALIGNAS_CACHE_LINE Slot {
/// Number of times we've hit the code path.
std::atomic<int> count {};
/// Total time (in micros) we've spent on the code path.
std::atomic<int64_t> time {};
};
std::string name_;
std::vector<Slot> slots_ { GetThreadSlotCount() };
};
/// A scoped object for recording a metric across the body of a function.
/// Used by the METRIC_RECORD macro. Inline the metric_ null check to minimize
/// the effect on the typical case where metrics are disabled.
struct ScopedMetric {
explicit ScopedMetric(Metric* metric) : metric_(metric) {
if (metric_ == nullptr) {
return;
}
RecordStart();
}
~ScopedMetric() {
if (metric_ == nullptr) {
return;
}
RecordResult();
}
private:
void RecordStart();
void RecordResult();
Metric* metric_;
/// Timestamp when the measurement started.
/// Value is platform-dependent.
int64_t start_;
};
/// The singleton that stores metrics and prints the report.
struct Metrics {
Metric* NewMetric(const string& name);
/// Print a summary report to stdout.
void Report();
private:
std::mutex mutex_;
vector<Metric*> metrics_;
};
/// Get the current time as relative to some epoch.
/// Epoch varies between platforms; only useful for measuring elapsed time.
int64_t GetTimeMillis();
/// A simple stopwatch which returns the time
/// in seconds since Restart() was called.
struct Stopwatch {
public:
Stopwatch() : started_(0) {}
/// Seconds since Restart() call.
double Elapsed() const {
return 1e-6 * static_cast<double>(Now() - started_);
}
void Restart() { started_ = Now(); }
private:
uint64_t started_;
uint64_t Now() const;
};
/// The primary interface to metrics. Use METRIC_RECORD("foobar") at the top
/// of a function to get timing stats recorded for each call of the function.
#define METRIC_RECORD(name) \
static Metric* metrics_h_metric = \
g_metrics ? g_metrics->NewMetric(name) : NULL; \
ScopedMetric metrics_h_scoped(metrics_h_metric);
extern Metrics* g_metrics;
void DumpMemoryUsage();
#endif // NINJA_METRICS_H_