timer.h

Go to the documentation of this file.

#pragma once

#ifdef __CUDACC_RTC__

namespace quda {
  // dummy Implementation that can safely be parsed by nvrtc
  enum QudaProfileType { };

  class TimeProfile {
  public:
    TimeProfile(std::string fname);
    TimeProfile(std::string fname, bool use_global);
    void Print();
    void Start_(const char *func, const char *file, int line, QudaProfileType idx);
    void Stop_(const char *func, const char *file, int line, QudaProfileType idx);
    void Reset_(const char *func, const char *file, int line);
    double Last(QudaProfileType idx);
    void PrintGlobal();
    bool isRunning(QudaProfileType idx);
  };
}

#else

#include <sys/time.h>

#ifdef INTERFACE_NVTX
#if QUDA_NVTX_VERSION == 3
#include "nvtx3/nvToolsExt.h"
#else
#include "nvToolsExt.h"
#endif
#endif

namespace quda {

  struct Timer {
    double time;

    double last;

    timeval start;

    timeval stop;

    bool running;
    
    int count;

  Timer() : time(0.0), last(0.0), running(false), count(0) { ; } 

    void Start(const char *func, const char *file, int line) {
      if (running) {
  printfQuda("ERROR: Cannot start an already running timer (%s:%d in %s())\n", file, line, func);
  errorQuda("Aborting");
      }
      gettimeofday(&start, NULL);
      running = true;
    }

    void Stop(const char *func, const char *file, int line) {
      if (!running) {
  printfQuda("ERROR: Cannot stop an unstarted timer (%s:%d in %s())\n", file, line, func);
  errorQuda("Aborting");
      }
      gettimeofday(&stop, NULL);

      long ds = stop.tv_sec - start.tv_sec;
      long dus = stop.tv_usec - start.tv_usec;
      last = ds + 0.000001*dus;
      time += last;
      count++;

      running = false;
    }

    double Last() { return last; }

    void Reset(const char *func, const char *file, int line) {
      if (running) {
  printfQuda("ERROR: Cannot reset a started timer (%s:%d in %s())\n", file, line, func);
  errorQuda("Aborting");
      }
      time = 0.0;
      last = 0.0;
      count = 0;
    }

  };

  enum QudaProfileType {
    QUDA_PROFILE_H2D,      
    QUDA_PROFILE_D2H,      
    QUDA_PROFILE_INIT,     
    QUDA_PROFILE_PREAMBLE, 
    QUDA_PROFILE_COMPUTE,  
    QUDA_PROFILE_COMMS,    
    QUDA_PROFILE_EPILOGUE, 
    QUDA_PROFILE_FREE,     
    QUDA_PROFILE_IO,       
    QUDA_PROFILE_CHRONO,   
    QUDA_PROFILE_EIGEN,    
    QUDA_PROFILE_ARPACK,   
    // lower level counters used in the dslash and api profiling
    QUDA_PROFILE_LOWER_LEVEL, 
    QUDA_PROFILE_PACK_KERNEL,   
    QUDA_PROFILE_DSLASH_KERNEL, 
    QUDA_PROFILE_GATHER,        
    QUDA_PROFILE_SCATTER,       
    QUDA_PROFILE_LAUNCH_KERNEL,      
    QUDA_PROFILE_EVENT_RECORD,       
    QUDA_PROFILE_EVENT_QUERY,        
    QUDA_PROFILE_STREAM_WAIT_EVENT,  
    QUDA_PROFILE_FUNC_SET_ATTRIBUTE, 
    QUDA_PROFILE_EVENT_SYNCHRONIZE,  
    QUDA_PROFILE_STREAM_SYNCHRONIZE, 
    QUDA_PROFILE_DEVICE_SYNCHRONIZE, 
    QUDA_PROFILE_MEMCPY_D2D_ASYNC,   
    QUDA_PROFILE_MEMCPY_D2H_ASYNC,   
    QUDA_PROFILE_MEMCPY2D_D2H_ASYNC, 
    QUDA_PROFILE_MEMCPY_H2D_ASYNC,   
    QUDA_PROFILE_COMMS_START, 
    QUDA_PROFILE_COMMS_QUERY, 
    QUDA_PROFILE_CONSTANT, 
    QUDA_PROFILE_TOTAL, 
    QUDA_PROFILE_COUNT  
  };

#ifdef INTERFACE_NVTX



#define PUSH_RANGE(name,cid) { \
    int color_id = cid; \
    color_id = color_id%nvtx_num_colors;\
    nvtxEventAttributes_t eventAttrib = {0}; \
    eventAttrib.version = NVTX_VERSION; \
    eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; \
    eventAttrib.colorType = NVTX_COLOR_ARGB; \
    eventAttrib.color = nvtx_colors[color_id]; \
    eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII; \
    eventAttrib.message.ascii = name; \
    eventAttrib.category = cid;\
    nvtxRangePushEx(&eventAttrib); \
}
#define POP_RANGE nvtxRangePop();
#else
#define PUSH_RANGE(name,cid)
#define POP_RANGE
#endif

  class TimeProfile {
    std::string fname;  
#ifdef INTERFACE_NVTX
    static const uint32_t nvtx_colors[];// = { 0x0000ff00, 0x000000ff, 0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x00ff0000, 0x00ffffff };
    static const int nvtx_num_colors;// = sizeof(nvtx_colors)/sizeof(uint32_t);
#endif
    Timer profile[QUDA_PROFILE_COUNT];
    static std::string pname[];

    bool switchOff;
    bool use_global;

    // global timer
    static Timer global_profile[QUDA_PROFILE_COUNT];
    static bool global_switchOff[QUDA_PROFILE_COUNT];
    static int global_total_level[QUDA_PROFILE_COUNT]; // zero initialize

    static void StopGlobal(const char *func, const char *file, int line, QudaProfileType idx) {

      global_total_level[idx]--;
      if (global_total_level[idx]==0) global_profile[idx].Stop(func,file,line);

      // switch off total timer if we need to
      if (global_switchOff[idx]) {
        global_total_level[idx]--;
        if (global_total_level[idx]==0) global_profile[idx].Stop(func,file,line);
        global_switchOff[idx] = false;
      }
    }

    static void StartGlobal(const char *func, const char *file, int line, QudaProfileType idx) {
      // if total timer isn't running, then start it running
      if (!global_profile[idx].running) {
        global_profile[idx].Start(func,file,line);
        global_total_level[idx]++;
        global_switchOff[idx] = true;
      }

      if (global_total_level[idx]==0) global_profile[idx].Start(func,file,line);
      global_total_level[idx]++;
    }

  public:
    TimeProfile(std::string fname) : fname(fname), switchOff(false), use_global(true) { ; }

    TimeProfile(std::string fname, bool use_global) : fname(fname), switchOff(false), use_global(use_global) { ; }

    void Print();

    void Start_(const char *func, const char *file, int line, QudaProfileType idx) { 
      // if total timer isn't running, then start it running
      if (!profile[QUDA_PROFILE_TOTAL].running && idx != QUDA_PROFILE_TOTAL) {
  profile[QUDA_PROFILE_TOTAL].Start(func,file,line);
        switchOff = true;
      }

      profile[idx].Start(func, file, line); 
      PUSH_RANGE(fname.c_str(),idx)
  if (use_global) StartGlobal(func,file,line,idx);
    }


    void Stop_(const char *func, const char *file, int line, QudaProfileType idx) {
      profile[idx].Stop(func, file, line); 
      POP_RANGE

      // switch off total timer if we need to
      if (switchOff && idx != QUDA_PROFILE_TOTAL) {
        profile[QUDA_PROFILE_TOTAL].Stop(func,file,line);
        switchOff = false;
      }
      if (use_global) StopGlobal(func,file,line,idx);
    }

    void Reset_(const char *func, const char *file, int line) {
      for (int idx=0; idx<QUDA_PROFILE_COUNT; idx++)
  profile[idx].Reset(func, file, line);
    }

    double Last(QudaProfileType idx) { 
      return profile[idx].last;
    }

    static void PrintGlobal();

    bool isRunning(QudaProfileType idx) { return profile[idx].running; }

  };

} // namespace quda

#endif


#undef PUSH_RANGE
#undef POP_RANGE

#define TPSTART(idx) Start_(__func__, __FILE__, __LINE__, idx)
#define TPSTOP(idx) Stop_(__func__, __FILE__, __LINE__, idx)
#define TPRESET() Reset_(__func__, __FILE__, __LINE__)