sprint/timer.h

Go to the documentation of this file.

/******************************************************************************
*   sprint::timer
*
*   Copyright (C) 2004-2011  Paolo Medici <www.pmx.it>
*
*  This library is free software; you can redistribute it and/or
*  modify it under the terms of the GNU Lesser General Public
*  License as published by the Free Software Foundation; either
*  version 2.1 of the License, or (at your option) any later version.
*
*  This library is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
*  Lesser General Public License for more details.
*
*  You should have received a copy of the GNU Lesser General Public
*  License along with this library; if not, write to the Free Software
*  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*
*******************************************************************************/

#ifndef _SPRINT_TIMER_H
#define _SPRINT_TIMER_H
  
#ifdef WIN32
 #include <windows.h>
#else
 #include <sys/time.h>
 #include <time.h>
#endif

namespace sprint {

class rtc {

#ifdef WIN32

        double time_factor;    // Time Scaling Factor
public:
        rtc() 
                {
                LONGLONG perf_cnt;
                
                if (QueryPerformanceFrequency((LARGE_INTEGER *) &perf_cnt)) 
                        {
                     time_factor=1.0/(double)perf_cnt; 
                        } 
                }

        inline double getTime() const
                {
                LONGLONG time;

                QueryPerformanceCounter((LARGE_INTEGER *) &time);
                return (time * time_factor);
                }
                
#else

        /*
        double time_factor;    // Time Scaling Factor
        inline unsigned long long rdtsc()       
        {
        unsigned long long v; 

         __asm__ ("rdtsc"  : "=A" (v)); 

        return v; 
        }
        */
public:
        rtc() 
                { 
                /*
                long long v0, v1;
                v0 = rdtsc();
                usleep(1000000);
                v1 = rdtsc();
                time_factor = 1.0 / (double) (v1 - v0);
                */
                }
 
        inline double getTime() const
                {
                /*
                long long v = rdtsc();
                return (v * time_factor);
                */
                struct timeval tv;
                gettimeofday(&tv, NULL);
                return (tv.tv_sec*1.0 + tv.tv_usec * 0.000001);
                }
#endif

        inline unsigned long getTimeMs() const
                {
                return (unsigned long)(getTime() * 1000.0);
                }

        inline unsigned long getTimeSec() const
                {
                return (unsigned long)(getTime() );
                }
};

class timer: public rtc {
        double user_time;
public:
        timer()
        {
        user_time = rtc::getTime();
        }

        inline void start()
        {
        user_time = rtc::getTime();
        }

        inline double getTime() const
        {
        return rtc::getTime() - user_time;
        }

};

}

#endif