Timer.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/Timer.h"
#include <chrono>
#include <ostream>
#include <sstream>
 
namespace Mantid::Kernel {
 
Timer::Timer() : m_start(std::chrono::high_resolution_clock::now()) {}
 
float Timer::elapsed(bool reset) {
  float retval = elapsed_no_reset();
  if (reset)
    this->reset();
  return retval;
}
 
float Timer::elapsed_no_reset() const {
  const auto now = std::chrono::high_resolution_clock::now();
  std::chrono::duration<float> duration = now - m_start;
 
  return duration.count();
}
 
void Timer::reset() { m_start = std::chrono::high_resolution_clock::now(); }
 
std::string Timer::str() const {
  std::stringstream buffer;
  buffer << this->elapsed_no_reset() << " sec";
  return buffer.str();
}
 
std::ostream &operator<<(std::ostream &out, const Timer &obj) {
  out << obj.str();
  return out;
}
 
//------------------------------------------------------------------------
CodeBlockTimer::CodeBlockTimer(const std::string &name, std::ostream &out)
    : m_name(name), m_out(out), m_start(std::chrono::system_clock::now()) {}
 
CodeBlockTimer::~CodeBlockTimer() {
  const auto stop = std::chrono::system_clock::now();
  const std::chrono::duration<double> elapsed = stop - m_start;
  m_out << "Elapsed time (sec) in \"" << m_name << "\": " << elapsed.count() << '\n';
}
 
//------------------------------------------------------------------------
CodeBlockMultipleTimer::CodeBlockMultipleTimer(CodeBlockMultipleTimer::TimeAccumulator &accumulator)
    : m_accumulator(accumulator), m_start(std::chrono::system_clock::now()) {}
 
CodeBlockMultipleTimer::~CodeBlockMultipleTimer() {
  const auto stop = std::chrono::system_clock::now();
  const std::chrono::duration<double> elapsed = stop - m_start;
  m_accumulator.increment(elapsed.count());
}
 
//------------------------------------------------------------------------
CodeBlockMultipleTimer::TimeAccumulator::TimeAccumulator(const std::string &name) : m_name(name) {}
 
void CodeBlockMultipleTimer::TimeAccumulator::reset() {
  m_elapsed_sec = 0.0;
  m_number_of_entrances = 0;
}
 
void CodeBlockMultipleTimer::TimeAccumulator::increment(const double time_sec) {
  m_elapsed_sec += time_sec;
  m_number_of_entrances++;
}
 
double CodeBlockMultipleTimer::TimeAccumulator::getElapsed() const { return m_elapsed_sec; }
 
size_t CodeBlockMultipleTimer::TimeAccumulator::getNumberOfEntrances() const { return m_number_of_entrances; }
 
std::string CodeBlockMultipleTimer::TimeAccumulator::toString() const {
  std::ostringstream out;
  out << "Elapsed time (sec) in \"" << m_name << "\": " << m_elapsed_sec
      << "; Number of entrances: " << m_number_of_entrances;
  return out.str();
}
 
MANTID_KERNEL_DLL std::ostream &operator<<(std::ostream &out, const CodeBlockMultipleTimer::TimeAccumulator &ta) {
  out << ta.toString();
  return out;
}
} // namespace Mantid::Kernel