Timer.h

Go to the documentation of this file.

// Timer.h: Accurate timer
//
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef LOFAR_COMMON_TIMER_H
#define LOFAR_COMMON_TIMER_H
 
#include "PrettyUnits.h"
 
#include <chrono>
#include <iomanip>
#include <iostream>
#include <string>
 
#if defined __ia64__ && defined __INTEL_COMPILER
#include <ia64regs.h>
#endif
 
namespace dp3 {
namespace common {
 
 
template <class Clock>
class BaseTimer {
 public:
  explicit BaseTimer(const std::string& name = std::string())
      : name_(name), count_(0), duration_(std::chrono::seconds{0}) {}
 
  void start() { start_ = Clock::now(); }
  void stop() {
    duration_ += Clock::now() - start_;
    ++count_;
  }
 
  void reset() {
    count_ = 0;
    duration_ = std::chrono::seconds{0};
  }
 
  std::ostream& print(std::ostream& str) const {
    if (name_.empty()) {
      str << "timer: ";
    } else {
      str << std::left << std::setw(25) << name_ << ": " << std::right;
    }
    if (count_ == 0) {
      str << "not used";
    } else {
      const double total = getElapsed();
      // clang-format off
      str << "avg = " << PrettyTime(total / count_)
          << ", total = " << PrettyTime(total)
          << ", count = " << std::setw(9) << count_;
      // clang-format on
    }
    return str;
  }
 
  double getElapsed() const {
    return std::chrono::duration<double>{duration_}.count();
  }
 
  double getAverage() const { return getElapsed() / getCount(); }
 
  uint64_t getCount() const { return count_; }
 
  BaseTimer& operator+=(const BaseTimer& other) {
    duration_ += other.duration_;
    count_ += other.count_;
 
    return *this;
  }
 
  class StartStop {
   public:
    StartStop(BaseTimer<Clock>& timer) : timer_(timer) { timer_.start(); }
    ~StartStop() { timer_.stop(); }
 
    StartStop(const StartStop&) = delete;
    StartStop& operator=(const StartStop&) = delete;
 
   private:
    BaseTimer<Clock>& timer_;
  };
 
 private:
  std::string name_;
 
  uint64_t count_;
 
  typename Clock::duration duration_;
 
  typename Clock::time_point start_;
};
 
using NSTimer = BaseTimer<std::chrono::steady_clock>;
 
template <class T, class Clock = std::chrono::steady_clock>
#if __cplusplus > 201703L
requires requires(T& t, double d) {
  t += d;
}
#endif
class ScopedMicroSecondAccumulator {
 public:
  explicit ScopedMicroSecondAccumulator(T& accumulator)
      : accumulator_(accumulator) {
    timer_.start();
  }
  ScopedMicroSecondAccumulator(const ScopedMicroSecondAccumulator&) = delete;
 
  ~ScopedMicroSecondAccumulator() {
    timer_.stop();
    accumulator_ += timer_.getElapsed() * 1e6;
  }
 
 private:
  BaseTimer<Clock> timer_;
  T& accumulator_;
};
 
}  // namespace common
}  // namespace dp3
 
#endif