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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#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
{
  typedef std::chrono::microseconds duration;

  typedef duration::rep rep;

  typedef duration::period period;

  typedef std::chrono::time_point<CPUClock, duration> time_point;

  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
  {
    typedef clock_type_ clock_type;

    typedef typename clock_type::time_point time_point_type;

    typedef typename clock_type::duration duration_type;

    time_point_type current_lap_start_time;

    duration_type accumulated_time;

    duration_type last_lap_time;

    ClockMeasurements();

    void reset();
  };

  typedef std::chrono::steady_clock wall_clock_type;

  typedef CPUClock cpu_clock_type;

  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
  };

  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