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