Profiler.H

Go to the documentation of this file.

#ifndef _PROFILER_H_
#define _PROFILER_H_
#include <map>
#include <list>
#include <vector>
#include <string>
#include <iostream>
#include <sys/time.h>
//#include <cstdint>
#ifdef _PROFILER_WITH_PAPI_
#include <papi.h>
#endif


#if __cplusplus >= 201103L // C++11 supported?
#include <chrono>
static __inline__ unsigned long long rdtsc(void)
{
  return(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());
}

#elif defined(__i386) || defined(__x86_64__)

static __inline__ unsigned long long rdtsc(void)
{
  unsigned int lo, hi;
  __asm__ __volatile__ (
                        "cpuid \n"
                        "rdtsc"
                        : "=a"(lo), "=d"(hi) /* outputs */
                        : "a"(0)             /* inputs */
                        : "%ebx", "%ecx");   /* clobbers*/
  return ((unsigned long long)lo) | (((unsigned long long)hi) << 32);
}

#elif defined(__ia64)

static __inline__ unsigned long long rdtsc(void)
{
  unsigned long long r;
  __asm__ __volatile__ ("mov %0=ar.itc" : "=r" (r) :: "memory");
  return r;
}

#elif defined(__i386__)

static __inline__ unsigned long long rdtsc(void)
{
  unsigned long long int x;
  __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
  return x;
}

#elif defined(__powerpc__)
static __inline__ unsigned long long rdtsc(void)
{
  unsigned long long int result=0;
  unsigned long int upper, lower,tmp;
  __asm__ volatile(
                "0:                  \n"
                "\tmftbu   %0           \n"
                "\tmftb    %1           \n"
                "\tmftbu   %2           \n"
                "\tcmpw    %2,%0        \n"
                "\tbne     0b         \n"
                : "=r"(upper),"=r"(lower),"=r"(tmp)
                   );
  result = upper;
  result = result<<32;
  result = result|lower;

  return(result);
}
#endif

namespace ix {

  namespace profiler {

    struct cumulative_stats {
      double incl;
      double excl;
      unsigned int ncalls;
      double incl_dev;
      double excl_dev;
      cumulative_stats(){
        incl = excl = incl_dev = excl_dev = 0.0;
        ncalls = 0;
      };
    };
  

    struct parallel_stats {
      double incl_min;
      double incl_max;
      unsigned int incl_minrank;
      unsigned int incl_maxrank;
      double incl_mean;
      double incl_stdev;
      double excl_min;
      double excl_max;
      unsigned int excl_minrank;
      unsigned int excl_maxrank;
      double excl_mean;
      double excl_stdev;
      double call_mean;
      unsigned int call_max;
      unsigned int call_min;
      unsigned int call_maxrank;
      unsigned int call_minrank;
      double call_stdev;
      parallel_stats(){
        incl_mean = incl_stdev = excl_min = excl_max = 0.0;
        excl_mean = excl_stdev = call_mean = call_stdev = 0.0;
        incl_minrank = incl_maxrank = excl_minrank = 0;
        excl_maxrank = call_max = call_min = call_maxrank = 0;
        call_minrank = 0;
        incl_min = incl_max = 0.0;
      };
    };
  
    struct scalability_stats 
    {
      std::vector<unsigned int> nprocs;
      std::vector<double> sstats[18];
    };
  
    class Event {
      friend std::ostream &operator<<(std::ostream &,const Event &);
      friend std::istream &operator>>(std::istream &,Event &);
    protected:
      unsigned int _id;
      double _exclusive;
      double _inclusive;
      double _timestamp;
#ifdef _PROFILER_WITH_PAPI_
      int _nhwc;
      size_t *_inc_hwc;
      size_t *_exc_hwc;
      bool _hwc;
#endif
    public:
      Event()
        : _id(0),_exclusive(0.),_inclusive(0.),_timestamp(0.)
      {
// #ifdef _PROFILER_WITH_PAPI_
//      init_papi();
// #endif
      };
      Event(unsigned int i)
        : _id(i),_exclusive(0.),_inclusive(0.),_timestamp(0.)
      {
// #ifdef _PROFILER_WITH_PAPI_
//      init_papi();
// #endif
      };
      Event(unsigned int i,double ts)
        : _id(i),_exclusive(0.),_inclusive(0.),_timestamp(0.)
      {
#ifdef _PROFILER_WITH_PAPI_
        init_papi();
#endif
      };
      Event(unsigned int i,double e,double it)
        : _id(i),_exclusive(e),_inclusive(it),_timestamp(0.)
      {
#ifdef _PROFILER_WITH_PAPI_
        init_papi();
#endif
      };
      Event(const Event &e)
        : _id(e._id),_exclusive(e._exclusive),_inclusive(e._inclusive),
          _timestamp(e._timestamp)
      {
#ifdef _PROFILER_WITH_PAPI_
        _nhwc = e._nhwc;
        _inc_hwc = new long long [_nhwc];
        _exc_hwc = new long long [_nhwc];
        hwc = true;
#endif
      };
#ifdef _PROFILER_WITH_PAPI_
      ~Event()
      {
        if(_hwc){
          delete [] _inc_hwc;
          delete [] _exc_hwc;
        }
      };
#endif
      Event &
      operator=(const Event &e)
      {
        _id = e._id;
        _exclusive = e._exclusive;
        _inclusive = e._inclusive;
        _timestamp = e._timestamp;
#ifdef _PROFILER_WITH_PAPI_
        if(!_hwc){
          _nwhc = e._nhwc;
          _inc_hwc = new long long [_nhwc];
          _exc_hwc = new long long [_nhwc];
        }
        for(int i = 0;i < _nwhc;i++){
          _inc_hwc[i] = e._inc_hwc[i];
          _exc_hwc[i] = e._exc_hwc[i];
        }
#endif
        return(*this);
      };
      inline double &exclusive()
      {
        return (_exclusive);
      };
      inline double exclusive() const
      {
        return (_exclusive);
      };
      inline double &inclusive()
      {
        return (_inclusive);
      };
      inline double inclusive() const 
      {
        return (_inclusive);
      };
      inline void exclusive(double e)
      {
        _exclusive = e;
      };
      inline void inclusive(double i)
      {
        _inclusive = i;
      };
      inline double &timestamp()
      {
        return (_timestamp);
      };
      inline double timestamp() const
      {
        return (_timestamp);
      };
      inline void timestamp(double t)
      {
        _timestamp = t;
      };
      inline unsigned int &id()
      {
        return(_id);
      };
      inline unsigned int id() const
      {
        return(_id);
      };
      inline void id(unsigned int i)
      {
        _id = i;
      };
      inline bool operator<(const Event &e) const 
      {
        return(_timestamp < e._timestamp);
      };
#ifdef _PROFILER_WITH_PAPI_
      int papiEventSet;
      void init_papi();
      int nhwc() comst { return (_nhwc); };
      void update_hwc(long long *,long long *);
      long long &inc_hwc(int i);
      long long inc_hwc(int i) const;
      long long &exc_hwc(int i);
      long long exc_hwc(int i) const;
#endif
    };
  
    std::ostream &
    operator<<(std::ostream &ost,const Event &e);
  
    std::istream &
    operator>>(std::istream &ist,Event &e);

#ifdef _PAPI_ENABLED_
    static inline int
    PAPIInit()
    {return(PAPIInit(PAPI_CURRENT_VERSION));};
    
    static inline int
    ResetCounters(){ return(PAPI_reset(papiEventSet) == PAPI_OK); };

    static inline int
    Count(size_t *counterValues)
    {
      return(PAPI_read(papiEventSet,counterValues) == PAPI_OK);
    };

    static inline int
    AccumulateCounters(size_t *counterValues)
    {
      return(PAPI_accum(papiEventSet,counterValues) == PAPI_OK);
    };

#endif
    static inline double
    Time()
    {
//        struct timeval tv;
//        gettimeofday(&tv,NULL);
//        double t = tv.tv_sec + tv.tv_usec/1000000.;
//        return(t);
      return(rdtsc()*1e-9);
    }
  
    typedef std::map<std::string,unsigned int> FunctionMap;
    typedef std::map<unsigned int,std::string> ConfigMap;
    typedef std::map<unsigned int,cumulative_stats> StatMap;
    typedef std::list<std::pair<unsigned int,StatMap> > PStatList;
    typedef std::map<unsigned int,parallel_stats> PStatMap;
    typedef std::map<unsigned int,PStatMap> ScalaMap;
    typedef std::list<std::pair<unsigned int,std::list<Event> > > PEventList;
    typedef std::map<std::string,unsigned int> FunctionMap;
    typedef std::map<unsigned int,scalability_stats> ScalaStatMap;

    class DummyProfilerObj {

    public:
      int Init(int id){return 0;};
      int Init(const std::string &name,int id){return 0;};
      int FunctionEntry(const std::string &name){return 0;};
      int FunctionEntry(int id){return 0;};
      int FunctionExit(const std::string &name){return 0;};
      int FunctionExit(int id){return 0;};
      int FunctionExitAll(){return 0;};
      int Finalize(){return 0;};
      int Dump(std::ostream &Ostr){return 0;}; 
      bool Ready() {return true;};
    };
    
    class ProfilerObj {
    protected:
      unsigned int profiler_rank;
      unsigned int verblevel;
      std::ostream *Out;
      std::ostream *Err;
      double time0;
      std::list<Event> open_event_list;
      std::list<Event> event_list;
      FunctionMap function_map;
      ConfigMap configmap;
      unsigned int nfunc;

    public:
      ProfilerObj();

      int Init(int id);

      int Init(const std::string &name,int id);

      int FunctionEntry(const std::string &name);

      int FunctionEntry(int id);

      int FunctionExit(const std::string &name);

      int FunctionExit(int id);

      int FunctionExitAll();

      int  Dump(std::ostream &Ostr);

      void SetOut(std::ostream *Os){Out = Os;};

      void SetErr(std::ostream *Oe){Err = Oe;};

      void SummarizeSerialExecution(std::ostream &Ostr);

      void WriteEventFile();
    
      void DumpEvents(std::ostream &Ostr);

      bool  FinalizeReady(){return (open_event_list.size() == 1); };

      int  Finalize(bool writeFiles = true);

      int  ReadConfig(const std::string &fname);

      int  ReadEventsFromFile(const std::string &filename);

      int  ReadParallelEventFiles(const std::vector<std::string> &infiles,
                                  PEventList &par_event_list);

      int SummarizeParallelExecution(std::ostream &Ostr,
                                     std::ostream &Ouf,
                                     PEventList &parallel_event_list);
      int ReadSummaryFiles(const std::vector<std::string> &input_files,
                           ScalaMap &scala_map);

      int PopulateScalaMap(ScalaMap &scala_map,
                           ScalaStatMap &scala_statmap,
                           bool is_scaled);
      int ScalabilitySummary(ScalaStatMap &scala_statmap,std::ostream &Out);

    private:
      bool _strict;
      bool _initd;
      bool _finalized;

    };
  };
};

#endif