include_starpu/skepu/src/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() // used to estimate when using multi-Backend
    {
    double max = 0.0f; 
    //std::cout<<"AddMultiMaxTime call before"<<time.size()<<"\n";
    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 );
    //std::cout<<"MAXXX:"<<max<<" ";
    
    multi_time.clear();  // clear it in both cases.
    //std::cout<<"AddMultiMaxTime call after reset"<<time.size()<<"\n";
    }
    
    void addMultiMinTime() // used to estimate when using multi-Backend
    {
    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);
    //std::cout<<"start_\n";
    }

    void stop()
    {
        gettimeofday(&timerEnd, NULL);
    if(record_multi)
      multi_time.push_back( (timerEnd.tv_sec - timerStart.tv_sec + (timerEnd.tv_usec - timerStart.tv_usec) / 1000000.0) * 1000 );
    else 
      time.push_back( (timerEnd.tv_sec - timerStart.tv_sec + (timerEnd.tv_usec - timerStart.tv_usec) / 1000000.0) * 1000 );
    //std::cout<<"stop_\n";
    }

    void reset()
    {
      if(!record_multi)
      {
//  std::cout<<"Time reset:\n";
        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