Proto_Timer.H

#ifndef _PR_TIMER_H_
#define _PR_TIMER_H_

#include <cstdlib>
#include <cstdio>
#include <vector>
#include <string>
#include <iostream>
#include "implem/Proto_ClockTicks.H"
#include <iostream>
#include <fstream>
#include <list>
#include <vector>
#include <cstdio>
#include <cstring>
#include <sys/time.h>

using std::string;

namespace Proto 
{
#ifndef PR_TURN_OFF_TIMERS
  inline double TimerGetTimeStampWC()
  {

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

  }

  class TraceTimer
  {
  public:
    virtual ~TraceTimer()
    {
      for(unsigned int i=0; i<m_children.size(); ++i)
      {
        delete m_children[i];
      }
    }

    TraceTimer()
    {
      m_filename = string("/dev/null");
    }
    inline void start(char* mutex);
    inline unsigned long long int stop(char* mutex);
    inline void report(bool a_closeAfter=false);
    inline void reset();


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


    void setTimerFileName(string a_filename)
    {
      
      std::vector<TraceTimer*>* troots = getRootTimerPtr();
      (*troots)[0]->m_filename = a_filename;
    }

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

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

    inline void addFlops(long long int flops) {m_flops+=flops;}


    const char*        m_name;
    mutable int        m_rank;
    int tid = 0;
    int                m_thread_id;
    long long int      m_flops;
    long long int      m_count;
//#pragma omp atomic

    static std::vector<TraceTimer*>* getRootTimerPtr()
    {
      static std::vector<TraceTimer*>* retval = new std::vector<TraceTimer*>();
      static bool initialized = false;
      if(!initialized)
      {
        std::vector<TraceTimer*>* current = getCurrentTimerPtr();
        //this is the code from initialize
        const char* rootName = "root";
        TraceTimer* rootTimer = new TraceTimer(rootName, NULL, 0);
        rootTimer->m_thread_id = 0;
        char mutex = 0;

        retval->resize(1);
        (*retval)[0] = rootTimer;

        (*current).resize(1);
        (*current)[0]=rootTimer;

        (*retval)[0]->tid = 0;
        rootTimer->start(&mutex);
        rootTimer->zeroTime = TimerGetTimeStampWC();
        rootTimer->zeroTicks = PR_ticks();
      }
      initialized = true;
      return retval;
    }


    static std::vector<TraceTimer*>* getCurrentTimerPtr()
    {
      static std::vector<TraceTimer*>* retval = new std::vector<TraceTimer*>(1);
      return retval;
    }


    //oh the evil crap we have to do to avoid static initialization
    static void staticReport()
    {
      std::vector<TraceTimer*>* vecptr = getRootTimerPtr();
      if(vecptr->size() > 0)
      {
        (*vecptr)[0]->report();
      }
    }

    //oh the evil crap we have to do to avoid static initialization
    static void staticReset()
    {
      std::vector<TraceTimer*>* vecptr = getRootTimerPtr();
      if(vecptr->size() > 0)
      {
        (*vecptr)[0]->reset();
      }
    }

    //oh the evil crap we have to do to avoid static initialization
    static void staticPruneTimersParentChildPercent(double percent)
    {
      std::vector<TraceTimer*>* vecptr = getRootTimerPtr();
      if(vecptr->size() > 0)
      {
        (*vecptr)[0]->PruneTimersParentChildPercent(percent);
      }
    }

    //oh the evil crap we have to do to avoid static initialization
    static void staticSetTimerFileName(string a_filename)
    {
      std::vector<TraceTimer*>* vecptr = getRootTimerPtr();
      if(vecptr->size() > 0)
      {
        (*vecptr)[0]->setTimerFileName(a_filename);
      }
    }

    //more evil crap
    static int getTID()
    {
      int retval = -1;
      std::vector<TraceTimer*>* vecptr = getRootTimerPtr();
      if(vecptr->size() > 0)
      {
        retval =  (*vecptr)[0]->tid;
      }
      return retval;
    }
    
    //and all for the lack of a perfect reasonable language feature 
    static TraceTimer* staticGetTimer(const char* name)
    {
      TraceTimer* retval = NULL;
      std::vector<TraceTimer*>* vecptr = getRootTimerPtr();
      if(vecptr->size() > 0)
      {
        retval =  (*vecptr)[0]->getTimer(name);
      }
      return retval;
    }

  private:
    string m_filename; //only meaningful at root

    TraceTimer(const char* a_name, TraceTimer* parent, int thread_id)
    //:m_pruned(false), m_parent(parent), m_name(a_name), m_count(0),
    // m_accumulated_WCtime(0),m_last_WCtime_stamp(0), m_thread_id(thread_id),
    // m_flops(0)
    {
        m_pruned = false;
        m_parent = parent;
        m_name = a_name;
        m_count = 0;
        m_accumulated_WCtime = 0;
        m_last_WCtime_stamp = 0;
        m_thread_id = thread_id;
        m_flops = 0;
    }



    bool               m_pruned;
    TraceTimer*        m_parent;
    std::vector<TraceTimer*> m_children;

    unsigned long long int      m_accumulated_WCtime;
    unsigned long long int      m_last_WCtime_stamp;
    
    double zeroTime = 0;
    unsigned long long int zeroTicks = 0;



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

    int m_depth;
    inline void macroTest();
    inline void macroTest2();

    inline void currentize() const ;

    inline void reportFullTree(FILE* out, const TraceTimer& timer,
                        unsigned long long int totalTime, int depth, double secondspertick);
    inline void reportOneTree(FILE* out, const TraceTimer& timer, double secondspertick);


    inline void reset(TraceTimer& timer);
    inline void PruneTimersParentChildPercent(double threshold, TraceTimer* parent);
    inline void sumFlops(TraceTimer& timer);
  };


  class AutoStartLeaf
  {
  public:
    AutoStartLeaf(TraceTimer* a_timer):m_timer(a_timer) {if(a_timer)a_timer->leafStart();}
    ~AutoStartLeaf(){if(m_timer)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)
    {if(a_timer)a_timer->start(mutex);}
    AutoStart(TraceTimer* a_timer, char* mutex)
      :m_mutex(mutex), m_childMutex((char*)(getOKPtr()) ),m_timer(a_timer)
    {
      if(a_timer)a_timer->start(mutex);
    }
    inline ~AutoStart();
    bool active();
  private:
    static char* getOKPtr()
    {
      static bool init = false;
      static char* retval = new char[1024];
      if(!init)
      {
        sprintf(retval, "0");
      }
      init = true;
      return retval;
    }
    char* m_mutex;
    char* m_childMutex;
    TraceTimer* m_timer;
    static const char ok = 0;

  };

  inline
  AutoStart::~AutoStart()
  {
#  ifndef NDEBUG
    if(*m_childMutex == 1)
    {
      std::cerr<<" stop called in timer unexpectedly";
      abort();
    }
#  endif
    if(m_timer)m_timer->stop(m_mutex);
  }


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

  inline void TraceTimer::leafStop()
  {
    if(m_pruned) return;
    m_accumulated_WCtime +=  PR_ticks() - m_last_WCtime_stamp;
    m_last_WCtime_stamp=0;
  }
#endif

#ifdef PR_TURN_OFF_TIMERS

#define PR_TIMER(name, tpointer) 
#define PR_TIME(name)   
#define PR_FLOPS(flops)
#define PR_TIMELEAF(name)                                                   
#define PR_TIMERS(name)  
#define PR_START(tpointer)
#define PR_STOP(tpointer)  
#define PR_TIMER_REPORT()
#define PR_TIMER_RESET() 
#define PR_TIMER_PRUNE(threshold)
#define PR_TIMER_SETFILE(filename)

#else

#define PR_TIMER(name, tpointer)                                        \
  const char* TimerTag_##tpointer = name ;                              \
  ::Proto::TraceTimer* tpointer = NULL ;                                  \
  if(::Proto::TraceTimer::getTID()==0)                                    \
  {                                                                     \
    tpointer = ::Proto::TraceTimer::staticGetTimer(TimerTag_##tpointer) ;       \
  }

#define PR_TIME(name)                                           \
  const char* TimerTagA = name ;                                \
  char PR_TimermutexA = 0;                                      \
  ::Proto::TraceTimer* PR_tpointer = NULL;                      \
  if(::Proto::TraceTimer::getTID()==0)                          \
  {                                                             \
    PR_tpointer = ::Proto::TraceTimer::staticGetTimer(TimerTagA);       \
  }                                                             \
  ::Proto::AutoStart autostart(PR_tpointer, &PR_TimermutexA)

#define PR_FLOPS(flops)                         \
  if(PR_tpointer)PR_tpointer->addFlops(flops);

#define PR_TIMELEAF(name)                                       \
  const char* TimerTagA = name ;                                \
  ::Proto::TraceTimer* PR_tpointer = NULL;                        \
  if(::Proto::TraceTimer::getTID()==0)                            \
  {                                                             \
    PR_tpointer = ::Proto::TraceTimer::staticGetTimer(TimerTagA);       \
  }                                                             \
  ::Proto::AutoStartLeaf autostart(PR_tpointer)

#define PR_TIMERS(name)                                                 \
  const char* TimerTagA = name ;                                        \
  char PR_TimermutexA = 0;                                              \
  char PR_Timermutex = 0;                                               \
  ::Proto::TraceTimer* PR_tpointer = NULL;                                \
  if(::Proto::TraceTimer::getTID()==0)                                    \
  {                                                                     \
    PR_tpointer = ::Proto::TraceTimer::staticGetTimer(TimerTagA);               \
  }                                                                     \
  ::Proto::AutoStart autostart(PR_tpointer, &PR_TimermutexA, &PR_Timermutex)


#define PR_START(tpointer)                      \
  if(::Proto::TraceTimer::getTID()==0)            \
  {                                             \
  tpointer->start(&PR_Timermutex);              \
}

#define PR_STOP(tpointer)                       \
  if(::Proto::TraceTimer::getTID()==0)            \
  {                                             \
    tpointer->stop(&PR_Timermutex);             \
  }
  //#define PR_STOPV(tpointer, val ) val = tpointer->stop(&PR_Timermutex)

#define PR_TIMER_REPORT() ::Proto::TraceTimer::staticReport()

#define PR_TIMER_RESET() ::Proto::TraceTimer::staticReset()

#define PR_TIMER_PRUNE(threshold) ::Proto::TraceTimer::staticPruneTimersParentChildPercent(threshold)

#define PR_TIMER_SETFILE(filename) ::Proto::TraceTimer::staticSetTimerFileName(filename);
#endif
}//namespace proto

#include "implem/Proto_TimerImplem.H"
#endif // PR_TIMER_H