timer.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------

#ifndef dealii_timer_h
#define dealii_timer_h

#include <deal.II/base/config.h>

#include <deal.II/base/conditional_ostream.h>
#include <deal.II/base/mpi.h>
#include <deal.II/base/thread_management.h>
#include <deal.II/base/utilities.h>

#include <chrono>
#include <list>
#include <map>
#include <string>

DEAL_II_NAMESPACE_OPEN

struct CPUClock
{
  using duration = std::chrono::microseconds;

  using rep = duration::rep;

  using period = duration::period;

  using time_point = std::chrono::time_point<CPUClock, duration>;

  static const bool is_steady = true;

  static time_point
  now() noexcept;
};

class Timer
{
public:
  Timer();

  Timer(MPI_Comm mpi_communicator, const bool sync_lap_times = false);

  DEAL_II_DEPRECATED
  const Utilities::MPI::MinMaxAvg &
  get_data() const;

  const Utilities::MPI::MinMaxAvg &
  get_last_lap_wall_time_data() const;

  DEAL_II_DEPRECATED
  const Utilities::MPI::MinMaxAvg &
  get_total_data() const;

  const Utilities::MPI::MinMaxAvg &
  get_accumulated_wall_time_data() const;

  template <class StreamType>
  DEAL_II_DEPRECATED void
  print_data(StreamType &stream) const;

  template <class StreamType>
  void
  print_last_lap_wall_time_data(StreamType &stream) const;

  template <class StreamType>
  DEAL_II_DEPRECATED void
  print_total_data(StreamType &stream) const;

  template <class StreamType>
  void
  print_accumulated_wall_time_data(StreamType &stream) const;

  void
  start();

  double
  stop();

  void
  reset();

  void
  restart();

  DEAL_II_DEPRECATED
  double
  operator()() const;

  double
  wall_time() const;

  double
  last_wall_time() const;

  double
  cpu_time() const;

  double
  last_cpu_time() const;

  DEAL_II_DEPRECATED
  double
  get_lap_time() const;

private:
  template <class clock_type_>
  struct ClockMeasurements
  {
    using clock_type = clock_type_;

    using time_point_type = typename clock_type::time_point;

    using duration_type = typename clock_type::duration;

    time_point_type current_lap_start_time;

    duration_type accumulated_time;

    duration_type last_lap_time;

    ClockMeasurements();

    void
    reset();
  };

  using wall_clock_type = std::chrono::steady_clock;

  using cpu_clock_type = CPUClock;

  ClockMeasurements<wall_clock_type> wall_times;

  ClockMeasurements<cpu_clock_type> cpu_times;

  bool running;

  MPI_Comm mpi_communicator;

  bool sync_lap_times;

  Utilities::MPI::MinMaxAvg last_lap_wall_time_data;

  Utilities::MPI::MinMaxAvg accumulated_wall_time_data;
};



// TODO: The following class is not thread-safe
class TimerOutput
{
public:
  class Scope
  {
  public:
    Scope(::TimerOutput &timer_, const std::string &section_name);

    ~Scope();

    void
    stop();

  private:
    ::TimerOutput &timer;

    const std::string section_name;

    bool in;
  };

  enum OutputFrequency
  {
    every_call,
    summary,
    every_call_and_summary,
    never
  };

  enum OutputData
  {
    total_cpu_time,
    total_wall_time,
    n_calls
  };

  enum OutputType
  {
    cpu_times,
    wall_times,
    cpu_and_wall_times,
    cpu_and_wall_times_grouped
  };

  TimerOutput(std::ostream &        stream,
              const OutputFrequency output_frequency,
              const OutputType      output_type);

  TimerOutput(ConditionalOStream &  stream,
              const OutputFrequency output_frequency,
              const OutputType      output_type);

  TimerOutput(MPI_Comm              mpi_comm,
              std::ostream &        stream,
              const OutputFrequency output_frequency,
              const OutputType      output_type);

  TimerOutput(MPI_Comm              mpi_comm,
              ConditionalOStream &  stream,
              const OutputFrequency output_frequency,
              const OutputType      output_type);

  ~TimerOutput();

  void
  enter_subsection(const std::string &section_name);

  void
  enter_section(const std::string &section_name);

  // TODO: make some of these functions DEPRECATED (I would keep
  // enter/exit_section)

  void
  leave_subsection(const std::string &section_name = std::string());

  void
  exit_section(const std::string &section_name = std::string());

  std::map<std::string, double>
  get_summary_data(const OutputData kind) const;

  void
  print_summary() const;

  void
  disable_output();

  void
  enable_output();

  void
  reset();

private:
  OutputFrequency output_frequency;

  OutputType output_type;


  Timer timer_all;

  struct Section
  {
    Timer        timer;
    double       total_cpu_time;
    double       total_wall_time;
    unsigned int n_calls;
  };

  std::map<std::string, Section> sections;

  ConditionalOStream out_stream;

  bool output_is_enabled;

  std::list<std::string> active_sections;

  MPI_Comm mpi_communicator;

  Threads::Mutex mutex;
};



/* ---------------- inline functions ----------------- */


inline void
Timer::restart()
{
  reset();
  start();
}



inline const Utilities::MPI::MinMaxAvg &
Timer::get_data() const
{
  return last_lap_wall_time_data;
}



inline const Utilities::MPI::MinMaxAvg &
Timer::get_last_lap_wall_time_data() const
{
  return last_lap_wall_time_data;
}



inline const Utilities::MPI::MinMaxAvg &
Timer::get_total_data() const
{
  return accumulated_wall_time_data;
}



inline const Utilities::MPI::MinMaxAvg &
Timer::get_accumulated_wall_time_data() const
{
  return accumulated_wall_time_data;
}



template <class StreamType>
inline void
Timer::print_data(StreamType &stream) const
{
  print_last_lap_wall_time_data(stream);
}



template <class StreamType>
inline void
Timer::print_last_lap_wall_time_data(StreamType &stream) const
{
  const Utilities::MPI::MinMaxAvg &statistic = get_last_lap_wall_time_data();
  stream << statistic.max << " wall,"
         << " max @" << statistic.max_index << ", min=" << statistic.min << " @"
         << statistic.min_index << ", avg=" << statistic.avg << std::endl;
}



template <class StreamType>
inline void
Timer::print_total_data(StreamType &stream) const
{
  print_accumulated_wall_time_data(stream);
}



template <class StreamType>
inline void
Timer::print_accumulated_wall_time_data(StreamType &stream) const
{
  const Utilities::MPI::MinMaxAvg statistic = get_accumulated_wall_time_data();
  stream << statistic.max << " wall,"
         << " max @" << statistic.max_index << ", min=" << statistic.min << " @"
         << statistic.min_index << ", avg=" << statistic.avg << std::endl;
}



inline void
TimerOutput::enter_section(const std::string &section_name)
{
  enter_subsection(section_name);
}



inline void
TimerOutput::exit_section(const std::string &section_name)
{
  leave_subsection(section_name);
}

inline TimerOutput::Scope::Scope(::TimerOutput &timer_,
                                 const std::string &  section_name_)
  : timer(timer_)
  , section_name(section_name_)
  , in(true)
{
  timer.enter_section(section_name);
}



inline void
TimerOutput::Scope::stop()
{
  if (!in)
    return;
  in = false;

  timer.exit_section(section_name);
}


DEAL_II_NAMESPACE_CLOSE

#endif