timer_linux.h

Go to the documentation of this file.

#ifndef TIMER_LINUX_H
#define TIMER_LINUX_H

#include <sys/time.h>
#include <iostream>
#include <vector>

namespace skepu
{

class TimerLinux_GTOD
{

private:
   timeval timerStart;
   timeval timerEnd;



   std::vector<double> multi_time; // used for estimating multi backends.
   std::vector<double> time;
   bool record_multi;


   void addMultiMaxTime()
   {
      double max = 0.0f;
      if(multi_time.empty())
         return;
      for(std::vector<double>::iterator it = multi_time.begin(); it != multi_time.end(); ++it)
      {
         if (max < *it)
            max = *it;
      }
      time.push_back( max );
      multi_time.clear();  // clear it in both cases.
   }

   void addMultiMinTime()
   {
      double min = 0.0f;
      if(multi_time.empty())
         return;
      for(std::vector<double>::iterator it = multi_time.begin(); it != multi_time.end(); ++it)
      {
         if (min > *it)
            min = *it;
      }
      time.push_back( min );
      multi_time.clear();  // clear it in both cases.
   }

public:

   void start_record_multi()
   {
      record_multi=true;
      multi_time.clear();  // clear it in both cases.
   }


   void stop_record_multi()
   {
      addMultiMaxTime();
      record_multi=false;
   }

   TimerLinux_GTOD()
   {
      record_multi=false;
   }

   void start()
   {
      gettimeofday(&timerStart, NULL);
   }

   void stop()
   {
      gettimeofday(&timerEnd, NULL);
      if(record_multi)
         multi_time.push_back( (((timerEnd.tv_sec  - timerStart.tv_sec) * 1000000u +  timerEnd.tv_usec - timerStart.tv_usec) / 1.e6) * 1000 );
      else
         time.push_back( (((timerEnd.tv_sec  - timerStart.tv_sec) * 1000000u +  timerEnd.tv_usec - timerStart.tv_usec) / 1.e6) * 1000 );
   }

   void reset()
   {
      if(!record_multi)
      {
         time.clear();
      }
      multi_time.clear();  // clear it in both cases.
   }




   double getTime(int run = 0)
   {
      return time.at(run);
   }

   double getTotalTime()
   {
      double totalTime = 0.0f;

      for(std::vector<double>::iterator it = time.begin(); it != time.end(); ++it)
      {
         totalTime += *it;
      }

      return totalTime;
   }

   double getAverageTime()
   {
      double totalTime = 0.0f;

      for(std::vector<double>::iterator it = time.begin(); it != time.end(); ++it)
      {
         totalTime += *it;
      }

      return (double)(totalTime/time.size());
   }

   double getMaxTime()
   {
      double max = 0.0f;
      for(std::vector<double>::iterator it = time.begin(); it != time.end(); ++it)
      {
         if (max < *it)
            max = *it;
      }
      return max;
   }


   double getMinTime()
   {
      double min = 0.0f;
      for(std::vector<double>::iterator it = time.begin(); it != time.end(); ++it)
      {
         if (min > *it)
            min = *it;
      }

      return min;
   }

   double getResolutionUs()
   {
      double result = 0.0f;
      timeval tStart;
      timeval tEnd;
      gettimeofday(&tStart, NULL);
      gettimeofday(&tEnd, NULL);
      int delay = 0;

      do
      {
         delay++;
         gettimeofday(&tStart, NULL);
         for(int i = 0; i < delay; ++i) ;
         gettimeofday(&tEnd, NULL);

         result = ((((double)tEnd.tv_sec)*1000000.0) + ((double)tEnd.tv_usec)) - ((((double)tStart.tv_sec)*1000000.0) + ((double)tStart.tv_usec));

      }
      while(result == 0);

      return result;
   }

   int getNumTimings()
   {
      return time.size();
   }
};

}

#endif