Benchmark.h

Go to the documentation of this file.

#include <chrono>
#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>

#ifndef BENCHMARK_H
#define BENCHMARK_H

using t_clock = std::chrono::high_resolution_clock;

class Stopwatch;

class Benchmark {
  friend class Stopwatch;

private:
  struct Measurement {
    t_clock::duration time;
    unsigned int nCalls = 0;
  };

public:
  Stopwatch MakeStopwatch(std::string name);
  std::unique_ptr<Stopwatch> MakeStopwatchPtr(std::string name);

  void Print() {
    std::cout << "Timers results:" << '\n';
    for (const auto &measurement : m_timers) {
      std::cout << measurement.first << ": "
                << std::chrono::duration_cast<std::chrono::milliseconds>(measurement.second.time).count() << " ms ("
                << std::chrono::duration_cast<std::chrono::milliseconds>(measurement.second.time).count() /
                       measurement.second.nCalls
                << " per " << measurement.second.nCalls << " calls)" << '\n';
    }
  };

private:
  void UpdateTimer(std::string &&timerName, t_clock::duration time) {
    // Usually we wouldn't do this, but this is actually what we want: operator[] inserts if the key is not in the map,
    // then we add the duration
    auto &measurement = m_timers[timerName];
    measurement.time += time;
    measurement.nCalls++;
  };

  std::unordered_map<std::string, Measurement> m_timers;
};

class Stopwatch {
public:
  Stopwatch(std::string name, Benchmark *bench) : m_name(std::move(name)), m_bench(bench), m_start(t_clock::now()) {}
  ~Stopwatch() { m_bench->UpdateTimer(std::move(m_name), t_clock::duration(t_clock::now() - m_start)); }

private:
  std::string m_name;

  Benchmark *m_bench;

  t_clock::time_point m_start;
};

inline Stopwatch Benchmark::MakeStopwatch(std::string name) { return Stopwatch(std::move(name), this); }
inline std::unique_ptr<Stopwatch> Benchmark::MakeStopwatchPtr(std::string name) {
  return std::make_unique<Stopwatch>(std::move(name), this);
}

#endif