output_timings.hh

Go to the documentation of this file.

#pragma once
 
// standard library
#include <chrono>
#include <cstddef>
#include <string>
 
namespace DiFfRG
{
  struct FrameTimings {
    double contributor = 0.;      
    double potential_solves = 0.; 
    double fe_attach = 0.;
    double build_patches = 0.;   
    double data_filter = 0.;     
    double hdf5_write = 0.;      
    double hdf5_open_close = 0.; 
    double hdf5_queue_wait = 0.;
    double fe_flush = 0.;
    double csv = 0.;   
    double total = 0.; 
 
    std::size_t potential_solve_count = 0;
    std::size_t hdf5_open_count = 0; 
 
    FrameTimings &operator+=(const FrameTimings &other);
  };
 
  class OutputTimings
  {
  public:
    void add(const FrameTimings &frame);
 
    void set_writer_totals(const FrameTimings &totals, bool asynchronous);
 
    std::string format() const;
 
    std::size_t frames() const noexcept { return n_frames; }
    const FrameTimings &totals() const noexcept { return sum; }
    const FrameTimings &maxima() const noexcept { return max; }
 
  private:
    std::size_t n_frames = 0;
    FrameTimings sum;
    FrameTimings max;
    FrameTimings writer;
    bool writer_asynchronous = false;
  };
 
  class ScopedTimer
  {
  public:
    explicit ScopedTimer(double &sink) : sink(&sink), start(std::chrono::steady_clock::now()) {}
    explicit ScopedTimer(double *sink) : sink(sink), start(std::chrono::steady_clock::now()) {}
    ~ScopedTimer() { stop(); }
 
    ScopedTimer(const ScopedTimer &) = delete;
    ScopedTimer &operator=(const ScopedTimer &) = delete;
 
    void stop()
    {
      if (sink == nullptr) return;
      *sink += std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
      sink = nullptr;
    }
 
  private:
    double *sink;
    std::chrono::steady_clock::time_point start;
  };
} // namespace DiFfRG