Benchmark.h

Go to the documentation of this file.

#ifndef BENCHMARK_H
#define BENCHMARK_H
 
#include <chrono>
#include <iostream>
#include <string>
#include <unordered_map>
 
#include "fmt/chrono.h"
#include "spdlog/spdlog.h"
 
using t_clock = std::chrono::high_resolution_clock;
 
namespace NAIA {
class Stopwatch;
 
class Benchmark {
  friend class Stopwatch;
 
private:
  struct Measurement {
    std::chrono::duration<double, std::milli> time;
    unsigned int nCalls = 0;
  };
 
public:
  inline Stopwatch MakeStopwatch(std::string name);
 
  void Print(std::shared_ptr<spdlog::logger> logger) {
 
    logger->debug("Timers results:");
    for (const auto &measurement : m_timers) {
      logger->debug("{0: >30}: {1}", measurement.first, measurement.second.time);
      if (measurement.second.nCalls > 0) {
        logger->debug("{0: >30}  {1} per call", "", measurement.second.time / measurement.second.nCalls);
      }
    }
  };
 
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;
  std::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(m_name, t_clock::duration(t_clock::now() - m_start)); };
 
private:
  std::string m_name;
 
  Benchmark *m_bench;
 
  t_clock::time_point m_start;
};
 
Stopwatch Benchmark::MakeStopwatch(std::string name) { return Stopwatch(std::move(name), this); };
} // namespace NAIA
#endif