Timer.h

// Copyright (C) 2008-2015 Anders Logg, Jan Blechta, Paul T. Kühner and Garth N.
// Wells
//
// This file is part of DOLFINx (https://www.fenicsproject.org)
//
// SPDX-License-Identifier:    LGPL-3.0-or-later
 
#pragma once
 
#include "TimeLogger.h"
#include <chrono>
#include <optional>
#include <stdexcept>
#include <string>
#include <utility>
 
namespace dolfinx::common
{
template <typename T = std::chrono::high_resolution_clock>
class Timer
{
public:
  Timer(std::optional<std::string> task = std::nullopt) : _task(std::move(task))
  {
  }
 
  // Copy constructor (deleted). Both copies would register `_task` when
  // destroyed, counting it twice.
  Timer(const Timer& timer) = delete;

  Timer(Timer&& timer) noexcept
      : _task(std::exchange(timer._task, std::nullopt)), _acc(timer._acc),
        _start_time(std::exchange(timer._start_time, std::nullopt))
  {
  }

  ~Timer()
  {
    if (_start_time.has_value() and _task.has_value())
    {
      _acc += T::now() - *_start_time;
      try
      {
        TimeLogger::instance().register_timing(*_task, _acc);
      }
      catch (...)
      {
        // Destructor is noexcept; discard the timing rather than terminate.
      }
    }
  }
 
  // Copy assignment (deleted)
  Timer& operator=(const Timer& timer) = delete;

  Timer& operator=(Timer&& timer) noexcept
  {
    _task = std::exchange(timer._task, std::nullopt);
    _acc = timer._acc;
    _start_time = std::exchange(timer._start_time, std::nullopt);
    return *this;
  }

  void start()
  {
    _acc = T::duration::zero();
    _start_time = T::now();
  }

  template <typename Period = std::ratio<1>>
  std::chrono::duration<double, Period> elapsed() const
  {
    if (_start_time.has_value()) // Timer is running
      return T::now() - *_start_time + _acc;
    else // Timer is stopped
      return _acc;
  }

  template <typename Period = std::ratio<1>>
  std::chrono::duration<double, Period> stop()
  {
    if (_start_time.has_value()) // Timer is running
    {
      _acc += T::now() - *_start_time;
      _start_time = std::nullopt;
    }
 
    return _acc;
  }

  void resume()
  {
    if (!_start_time.has_value())
      _start_time = T::now();
  }

  void flush()
  {
    if (_start_time.has_value())
      throw std::runtime_error("Timer must be stopped before flushing.");
 
    if (_task.has_value())
    {
      TimeLogger::instance().register_timing(*_task, _acc);
      _task = std::nullopt;
    }
  }
 
private:
  // Name of task to register in logger
  std::optional<std::string> _task;
 
  // Elapsed time offset
  typename T::duration _acc = T::duration::zero();
 
  // Store start time (std::nullopt if timer has been stopped)
  std::optional<typename T::time_point> _start_time = T::now();
};
} // namespace dolfinx::common