return static_cast<uint64_t>(t.tv_sec) * 1000000000LL + t.tv_nsec;
}
+bool Benchmark::header_printed_;
+
std::vector<Benchmark*>& Benchmark::List() {
static std::vector<Benchmark*> list;
return list;
}
int Benchmark::MaxNameColumnWidth() {
- int max = 20;
+ size_t max = 20;
for (auto& benchmark : List()) {
max = std::max(max, benchmark->NameColumnWidth());
}
- return max;
+ return static_cast<int>(max);
}
-bool Benchmark::RunAll(std::vector<regex_t*>& regs) {
- bool ran_benchmark = false;
+size_t Benchmark::RunAll(std::vector<regex_t*>& regs) {
+ size_t benchmarks_run = 0;
+ header_printed_ = false;
for (auto& benchmark : List()) {
- if (benchmark->ShouldRun(regs)) {
- if (!ran_benchmark) {
- printf("%-*s %10s %10s\n", MaxNameColumnWidth(), "", "iterations", "ns/op");
- ran_benchmark = true;
- }
- benchmark->RunAll();
- }
+ benchmarks_run += benchmark->RunAllArgs(regs);
+ }
+ return benchmarks_run;
+}
+
+void Benchmark::PrintHeader() {
+ if (!header_printed_) {
+ printf("%-*s %10s %10s\n", MaxNameColumnWidth(), "", "iterations", "ns/op");
+ header_printed_ = true;
}
- return ran_benchmark;
}
-bool Benchmark::ShouldRun(std::vector<regex_t*>& regs) {
+template <typename T>
+bool BenchmarkT<T>::ShouldRun(std::vector<regex_t*>& regs, T arg) {
if (regs.empty()) {
return true;
}
for (const auto& re : regs) {
- if (regexec(re, Name().c_str(), 0, NULL, 0) != REG_NOMATCH) {
+ if (regexec(re, GetNameStr(arg).c_str(), 0, NULL, 0) != REG_NOMATCH) {
return true;
}
}
virtual std::string Name() = 0;
- virtual void RunAll() = 0;
-
- bool ShouldRun(std::vector<regex_t*>&);
+ virtual size_t RunAllArgs(std::vector<regex_t*>&) = 0;
void SetBenchmarkBytesProcessed(uint64_t bytes) { bytes_processed_ += bytes; }
void StopBenchmarkTiming();
void StartBenchmarkTiming();
// Run all of the benchmarks that have registered.
- static bool RunAll(std::vector<regex_t*>&);
+ static size_t RunAll(std::vector<regex_t*>&);
static std::vector<Benchmark*>& List();
static int MaxNameColumnWidth();
protected:
- virtual int NameColumnWidth() = 0;
+ virtual size_t NameColumnWidth() = 0;
uint64_t bytes_processed_;
uint64_t total_time_ns_;
uint64_t start_time_ns_;
+
+ static bool header_printed_;
+
+ static void PrintHeader();
};
template <typename T>
virtual ~BenchmarkT() {}
protected:
+ bool ShouldRun(std::vector<regex_t*>&, T arg);
void RunWithArg(T arg);
virtual void RunIterations(int, T) = 0;
virtual std::string GetNameStr(T) = 0;
virtual ~BenchmarkWithoutArg() {}
protected:
- virtual void RunAll() override {
- RunWithArg(nullptr);
+ virtual size_t RunAllArgs(std::vector<regex_t*>& regs) override {
+ size_t benchmarks_run = 0;
+ if (BenchmarkT<void*>::ShouldRun(regs, nullptr)) {
+ PrintHeader();
+ RunWithArg(nullptr);
+ benchmarks_run++;
+ }
+ return benchmarks_run;
}
virtual void RunIterations(int iters, void*) override {
virtual void Run(int) = 0;
- virtual int NameColumnWidth() override {
- return (int)Name().size();
+ virtual size_t NameColumnWidth() override {
+ return Name().size();
}
virtual std::string GetNameStr(void *) override;
}
protected:
- virtual int NameColumnWidth() override {
- int max = 0;
- for (const auto arg : args_) {
- max = std::max(max, (int)GetNameStr(arg).size());
+ virtual size_t NameColumnWidth() override {
+ size_t max = 0;
+ for (const auto& arg : args_) {
+ max = std::max(max, GetNameStr(arg).size());
}
return max;
}
std::string GetNameStr(T arg) override;
- virtual void RunAll() override {
- for (T arg : args_) {
- BenchmarkT<T>::RunWithArg(arg);
+ virtual size_t RunAllArgs(std::vector<regex_t*>& regs) override {
+ size_t benchmarks_run = 0;
+ for (T& arg : args_) {
+ if (BenchmarkT<T>::ShouldRun(regs, arg)) {
+ Benchmark::PrintHeader();
+ BenchmarkT<T>::RunWithArg(arg);
+ benchmarks_run++;
+ }
}
+ return benchmarks_run;
}
virtual void RunIterations(int iters, T arg) override {