CH_Timer.H

Go to the documentation of this file.

#ifdef CH_LANG_CC
/*
*      _______              __
*     / ___/ /  ___  __ _  / /  ___
*    / /__/ _ \/ _ \/  V \/ _ \/ _ \
*    \___/_//_/\___/_/_/_/_.__/\___/
*    Please refer to Copyright.txt, in Chombo's root directory.
*/
#endif

#ifndef _CH_TIMER_H_
#define _CH_TIMER_H_

#ifdef CH_AIX
#define FOUR_COUNTERS
#endif

#include <cstdio>
#include "REAL.H"
#include "MayDay.H"
#include "Vector.H"
#include "ClockTicks.H"
#ifdef CH_MPI
#include "mpi.h"
#endif

// if CH_NTIMER is defined, then we just have a stub class.
#ifndef CH_NTIMER

extern "C" {
  // these are for gettimeofday() wall-clock timing
#include <unistd.h>
#include <sys/time.h>

  // obviously, if you don't have PAPI installed on your system
  // (which requires kernel modification) then the counters wont
  // work, so don't compile with -DPAPI
#ifdef PAPI
#include <papi.h>
#endif
}


#ifndef TIMER_COUNTER
#define TIMER_COUNTER 0
#endif

#include <list>
#include <string>
#include "List.H"

#include <string>
#include <iostream>
#include "BaseNamespaceHeader.H"

using namespace std;


  class OldTimer {

  public:

    // Constructors

    OldTimer();                                                        // unmanaged
    OldTimer(const string& a_name,         const int a_tableID);       // root parent-only
    OldTimer(const string& a_name, OldTimer&, const int a_tableID);       // parent/child
    OldTimer(const string& a_name, OldTimer&);                            // child only
    OldTimer(const string& a_name, OldTimer&, const int a_tableID, bool); // diagnostic

    ~OldTimer();

    void setup();
    void start();
    void stop();
    void stop(Real& wc1);
    void clear();

    inline double getTimeStampWC();
    double wc_time() { return m_accumulated_WCtime; }
    double mflops();
    void writeTotalPct(const string& a_extra = "");

#ifdef PAPI
    long long int papi_counter0() { return m_accumulated_counter0; }
    long long int papi_counter1() { return m_accumulated_counter1; }
    double total_papi_counter0()  { return m_totalPapiCounter0; }
    double total_papi_counter1()  { return m_totalPapiCounter1; }
#ifdef FOUR_COUNTERS
    long long int papi_counter2() { return m_accumulated_counter2; }
    long long int papi_counter3() { return m_accumulated_counter3; }
    double total_papi_counter2()  { return m_totalPapiCounter2; }
    double total_papi_counter3()  { return m_totalPapiCounter3; }
#endif
#endif

    string        Name()    { return m_name;     }
    long long int Count()   { return m_count;    }
    int           tableID() { return m_tableID;  }

    static list<OldTimer*> *TimerList; // must be initialized somewhere

    static void TimerSummary(const int bert, const int ernie) {
      TimerSummary(); // backwards compatibilty...
    }

    static void TimerInit(const int rank);
    static void TimerSummary(void);
    static void TimerSummaryWithTITAfiles(void);

  private:

    // internally called...
    static void TimerSummary_(const int itita);
    static void writeParentTables(FILE *out, const double TimerCost);
    static void writeDiagnosticTables(FILE *out, const double TimerCost);

    //bool timer_on;    // State of timer, either on(true) or off(false)
    int m_tableID;  // the table ID -- where parent goes in the summary

    double m_accumulated_WCtime, m_last_WCtime_stamp;

    // wall-clock timer data
#ifndef CH_MPI
    struct timeval tv;   //  Values from call to gettimeofday
    struct timezone tz;
#endif

    int m_ID;
    string m_name;
    bool m_diagnostic;
    OldTimer& m_Parent;


    bool m_evenCountAcrossRanks;
    double m_avgWC, m_minWC, m_maxWC, m_avgCount;

#ifdef PAPI
    long long int m_accumulated_counter0;
    long long int m_accumulated_counter1;
    long long int m_previous_counter0;
    long long int m_previous_counter1;
    double m_totalPapiCounter0;
    double m_totalPapiCounter1;
#ifdef FOUR_COUNTERS
    long long int m_values[4];
    long long int m_accumulated_counter2;
    long long int m_accumulated_counter3;
    long long int m_previous_counter2;
    long long int m_previous_counter3;
    double m_totalPapiCounter2;
    double m_totalPapiCounter3;
#else
    long long int m_values[2];
#endif
#endif

    long long int m_count;
    long long int m_totalCount;
  };

#else // CH_NTIMER

// stub OldTimer class
using namespace std;

class OldTimer {

public:

  OldTimer(){}
  OldTimer(const string&, const int){}
  OldTimer(const string&, OldTimer&, const int){}
  OldTimer(const string&, OldTimer&){}
  OldTimer(const string&, OldTimer&, const int, bool){}

  ~OldTimer(){}

  void setup(){}
  void start(){}
  void stop(){}
  void stop(Real& wc1){}
  void clear(){}

  inline double getTimeStampWC(){return 0.0;}
  double wc_time() {return 0.0;}
  double mflops();
  void writeTotalPct(const string& a_extra = "");

#ifdef PAPI
  long long int papi_counter0() {return 0;}
  long long int papi_counter1() {return 0;}
  double total_papi_counter0()  {return 0.0;}
  double total_papi_counter1()  {return 0.0;}
#ifdef FOUR_COUNTERS
  long long int papi_counter2() {return 0;}
  long long int papi_counter3() {return 0;}
  double total_papi_counter2()  {return 0.0;}
  double total_papi_counter3()  {return 0.0;}
#endif
#endif

  string        Name()    { return NULL;   }
  long long int Count()   { return 0;   }
  int           tableID() { return 0;  }

  static void TimerSummary(const int bert, const int ernie) {
    TimerSummary(); // backwards compatibilty...
  }

  static void TimerInit(const int rank){}
  static void TimerSummary(void){}
  static void TimerSummaryWithTITAfiles(void){};

private:

  // internally called...
  static void TimerSummary_(const int itita){}
  static void writeParentTables(FILE *out, const double TimerCost){}
  static void writeDiagnosticTables(FILE *out, const double TimerCost){}
};

#endif // CH_NTIMER

#ifdef CH_NTIMER

#define CH_TIMER(name, tpointer)   (void)0
#define CH_TIME(name)    (void)0
#define CH_TIMELEAF(name)  (void)0
#define CH_TIMERS(name)    (void)0
#define CH_START(tpointer)  (void)0
#define CH_STOP(tpointer)  (void)0
#define CH_STOPV(tpointer, val) (void)0
#define CH_TIMER_REPORT()  (void)0
#define CH_TIMER_RESET()   (void)0
#define CH_TIMER_PRUNE(threshold)  (void)0

#else // CH_NTIMER


#define CH_TIMER(name, tpointer)                                        \
  const char* TimerTag_##tpointer = name ;                             \
  CH_XD::TraceTimer* tpointer = CH_XD::TraceTimer::getTimer(TimerTag_##tpointer)

#define CH_TIME(name)                                                   \
  const char* TimerTagA = name ;                                       \
  char CH_TimermutexA = 0;                                              \
  CH_XD::TraceTimer* ch_tpointer = CH_XD::TraceTimer::getTimer(TimerTagA); \
  CH_XD::AutoStart autostart(ch_tpointer, &CH_TimermutexA)

#define CH_TIMELEAF(name)                                                   \
  const char* TimerTagA = name ;                                       \
  CH_XD::TraceTimer* ch_tpointer = CH_XD::TraceTimer::getTimer(TimerTagA); \
  CH_XD::AutoStartLeaf autostart(ch_tpointer)

#define CH_TIMERS(name)                                                   \
  const char* TimerTagA = name ;                                       \
  char CH_TimermutexA = 0;                                              \
  char CH_Timermutex = 0;                                               \
  CH_XD::TraceTimer* ch_tpointer = CH_XD::TraceTimer::getTimer(TimerTagA); \
  CH_XD::AutoStart autostart(ch_tpointer, &CH_TimermutexA, &CH_Timermutex)


#define CH_START(tpointer) tpointer->start(&CH_Timermutex)

#define CH_STOP(tpointer) tpointer->stop(&CH_Timermutex)
#define CH_STOPV(tpointer, val ) val = tpointer->stop(&CH_Timermutex)

#define CH_TIMER_REPORT() CH_XD::TraceTimer::report()

#define CH_TIMER_RESET() CH_XD::TraceTimer::reset()

#define CH_TIMER_PRUNE(threshold) CH_XD::TraceTimer::PruneTimersParentChildPercent(threshold)

#endif  // CH_NTIMER


  class TraceTimer
  {
  public:
    virtual ~TraceTimer();
    void start(char* mutex);
    unsigned long long int stop(char* mutex);
    static void report(bool a_closeAfter=false);
    static void reset();


    void leafStart();
    void leafStop();

    unsigned long long int time() const
    {
      return m_accumulated_WCtime;
    }

    int rank() const
    {
      return m_rank;
    }
    long long int count() const
    {
      return m_count;
    }

    void prune();
    bool isPruned() const {return m_pruned;}

    static int initializer(); // don't use
    static TraceTimer* getTimer(const char* name); // don't use
    const std::vector<TraceTimer*>& children() const ;//don't use.

    static void PruneTimersParentChildPercent(double percent);
    static void sampleMemUsage() ;

    static const char* currentTimer()
    {
      return s_currentTimer[0]->m_name;
    }

  private:
    TraceTimer(const char* a_name, TraceTimer* parent, int thread_id);
    static std::vector<TraceTimer*> s_roots;
    static std::vector<TraceTimer*> s_currentTimer;
    static bool s_traceMemory;
    static long long int s_peak;
    static TraceTimer*   s_peakTimer;

    bool               m_pruned;
    TraceTimer*        m_parent;
    std::vector<TraceTimer*> m_children;
    const char*        m_name;
    long long int      m_count;
    unsigned long long int      m_accumulated_WCtime;
    unsigned long long int      m_last_WCtime_stamp;
    mutable int        m_rank;
    int                m_thread_id;
    long long int      m_memory;
    long long int      m_last_Memory_Stamp;
    long long int      m_peak;

    void reportTree(FILE* out, const TraceTimer& node, int depth);
    const TraceTimer* activeChild() const;

    void macroTest();
    void macroTest2();

    void currentize() const ;
    int  computeRank() const;
    static void reportFullTree(FILE* out, const TraceTimer& timer,
                               unsigned long long int totalTime, int depth);
    static void reportOneTree(FILE* out, const TraceTimer& timer);
    static void reportMemoryOneTree(FILE* out, const TraceTimer& timer);
    static void subReport(FILE* out, const char* header, unsigned long long int totalTime);
    static void reset(TraceTimer& timer);
    static void PruneTimersParentChildPercent(double threshold, TraceTimer* parent);

  };


  class AutoStartLeaf
  {
  public:
     AutoStartLeaf(TraceTimer* a_timer):m_timer(a_timer) {a_timer->leafStart();}
    ~AutoStartLeaf(){m_timer->leafStop();}
    bool active();
  private:
    TraceTimer* m_timer;
  };

  class AutoStart
  {
  public:
    AutoStart(TraceTimer* a_timer, char* mutex, char* childMutex)
      :m_mutex(mutex), m_childMutex(childMutex),m_timer(a_timer)
    {a_timer->start(mutex);}
    AutoStart(TraceTimer* a_timer, char* mutex)
      :m_mutex(mutex), m_childMutex(&AutoStart::ok),m_timer(a_timer)
    {a_timer->start(mutex);}
    inline ~AutoStart();
    bool active();
  private:
    char* m_mutex;
    char* m_childMutex;
    TraceTimer* m_timer;
    static char ok;

  };

  inline
  AutoStart::~AutoStart()
  {
#  ifndef NDEBUG
    if(*m_childMutex == 1)
      MayDay::Error("Child timer still running on function exit");
#  endif
    m_timer->stop(m_mutex);
  }

  inline double TimerGetTimeStampWC(){

    // #ifdef CH_MPI
    //     return( MPI_Wtime() );
    // #endif
#ifndef CH_NTIMER
    struct timeval tv;   //  Values from call to gettimeofday
    struct timezone tz;
    gettimeofday(&tv, &tz);
    return((double)tv.tv_sec + 0.000001 * (double)tv.tv_usec);
#else
    return 0;
#endif
  }

inline void TraceTimer::leafStart()
{
  if(m_pruned) return;
  ++m_count;
  m_last_WCtime_stamp = ch_ticks();
}

inline void TraceTimer::leafStop()
{
  if(m_pruned) return;
  m_accumulated_WCtime +=  ch_ticks() - m_last_WCtime_stamp;
  m_last_WCtime_stamp=0;
}
// Pruning options


#ifndef CH_NTIMER
#include "BaseNamespaceFooter.H"
#endif
#endif // CH_TIMER_H

---