timer.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 2015 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/thread_management.h>
#include <deal.II/base/utilities.h>

#ifdef DEAL_II_WITH_MPI
#  include <mpi.h>
#endif

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

DEAL_II_NAMESPACE_OPEN

class Timer
{
public:
  Timer ();

#ifdef DEAL_II_WITH_MPI

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

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

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


#endif

  void start ();

  double stop ();

  void reset ();

  void restart();

  double operator() () const;

  double wall_time () const;

  double get_lap_time () const;

private:

  double              start_time;


  double              start_time_children;

  double              start_wall_time;

  double              cumulative_time;

  double              cumulative_wall_time;

  double              last_lap_time;

  bool                running;

  MPI_Comm            mpi_communicator;

#ifdef DEAL_II_WITH_MPI

  bool sync_wall_time;

  Utilities::MPI::MinMaxAvg mpi_data;
#endif
};



//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;
    bool in;
  };

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

  enum OutputType
  {
    cpu_times,
    wall_times,
    cpu_and_wall_times
  };

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

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

#ifdef DEAL_II_WITH_MPI

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

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




#endif

  ~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());

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



#ifdef DEAL_II_WITH_MPI

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



template <class StreamType>
inline
void
Timer::print_data(StreamType &stream) const
{
  unsigned int my_id = ::Utilities::MPI::this_mpi_process(mpi_communicator);
  if (my_id==0)
    stream << mpi_data.max << " wall,"
           << " max @" << mpi_data.max_index
           << ", min=" << mpi_data.min << " @" << mpi_data.min_index
           << ", avg=" << mpi_data.avg
           << std::endl;
}

#endif



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_), in(true)
{
  timer.enter_section(section_name);
}

inline
TimerOutput::Scope::~Scope()
{
  stop();
}

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

  timer.exit_section();
}


DEAL_II_NAMESPACE_CLOSE

#endif