TimeMeasure.hh

/* 
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
Multimediale Systeme der Informationsverarbeitung
Institut fuer Informatik
Christian-Albrechts-Universitaet Kiel


BIAS 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.

BIAS 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 BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


#ifndef _TIMEMEASURE_H_261946892_
#define _TIMEMEASURE_H_261946892_

#ifdef WIN32

#  ifndef _WIN32_WINNT 
#    define _WIN32_WINNT 0x0501 // Windows XP for GetSystemTimes
#  endif // _WIN32_WINNT

#  include <time.h>
#  include <Base/Common/W32Compat.hh>

struct tms {
  clock_t tms_utime;  /* user time */
  clock_t tms_stime;  /* system time */
  clock_t tms_cutime; /* user time of children */
  clock_t tms_cstime; /* system time of children */
};

#else // WIN32

// Linux 
#  include <sys/time.h>
#  include <sys/times.h>
#  include <unistd.h>

#endif // WIN32


#include <fstream>
#include <errno.h>
#include <stdlib.h>
#include <limits.h>

// stl strings:
#include <string>
#include <iostream>

// debugging information
#include "Debug.hh"
#include "Error.hh"


namespace BIAS {

#ifdef WIN32
  /** @brief get "Time Stamp Counter"  on Pentium like CPU's. 
      Assembler function without prolog and epilog. 
      Should work on Intel Pentium and newer AMD CPU's, see rdtsc assembler 
      instruction. 
      This functions can't be class member inlined because it collides with 
      naked fastcall. 
      \todo cleanup TimeMeasure class in platform independant manner. (JW)
      \bug user/system time is implemented wrong on WIN32. see time and clock
      functions (JW)
      
      @returns the number of clock cycles since the CPU was powered up or
      reset. 
      @author Jan Woetzel, 12/2004 */
  // int64 has no ANSI equivalent (JW)
  // fallback workaround implementation 
#ifdef _WIN64
    __forceinline __int64 __fastcall GetTSC(){ return __rdtsc(); };
#else
    __forceinline __int64 __fastcall GetTSC(){ __asm rdtsc };
#endif

  /** @brief compute the difference between two int64 cycle counts using 12 
      bit overflow mask .
  @author Jan Woetzel 12/2004 */
  inline __int64 GetTSCTicks(__int64 start, __int64 end) 
  {return ((end - start) & 0xFFFFFFFFFFFF);};
#endif // WIN32

  /**  @class TimeMeasure
       @ingroup g_utils
       @brief class TimeMeasure contains functions for timing real time and 
       cpu time.
       
       added Win32 rdtsc assembler cycle count with int64  jw 12/2004
       added Linux cycle count functions for i386-processors woelk 07/2003

       For Win32 the minimum requiered version is 0x0501 (WinXP/Server2005)
       
       @author Jan Woetzel (03/04/2002 - 11/2005) **/
  class  BIASDebug_EXPORT TimeMeasure {
    
  public:
    /// default constructor:
    TimeMeasure();

    /// print the output when the desctructor is called ?
    ~TimeMeasure() {};

//Sorry for that ifdef-mess but WIN32 has no suitable
//timer functions!
#ifdef WIN32
    //Inline not possible for win32-implementation
    void Start();

    void Stop();
#else // WIN32
    inline void Start();

    inline void Stop();
#endif // WIN32

    void Print(std::ostream& os=std::cout) const;

    void Reset();

    /** return real time (=wall time clock) in usec JW
        For Win32: real-time is measured differently from
                   user-/kernel-time. Don't wonder about
                   small inconsistancies!
    */
    double GetRealTime() const;

    /** return user time (=system usage time) in msec JW 
        For Win32: user-time is the sum over all processes on
                   all processors in user-mode
                   (not only the calling process!)
    */
    double GetUserTime() const;

    /** WIN32: return time that system spended in kernel mode in msec cmenk
               = Sum over all processes on all processors in kernel mode
               (!!!including the system idle process!!!) 
    */
    double GetKernelTime() const;

    /** WIN32: return time that system spended in idle mode in msec cmenk 
               Seems to be a bit useless
    */
    double GetIdleTime() const;

    /** returns the frequency in Hz based on real time (= fps)*/
    double GetFreq() const;

    /** returns the frequency in Hz based on user time (= fps)*/
    double GetUserFreq() const;

    /** print the real time (=wall time clok)
        @param verbose true for additionoutput in days hour sminutes seconds 
        Jan Woetzel */
    void PrintRealTime(std::ostream& os=std::cout, 
                       const bool &verbose=true) const;

    /** print the user time (=system usage time)
        @param verbose true for additionoutput in days hour sminutes seconds  
        Jan Woetzel */
    void PrintUserTime(std::ostream& os=std::cout, 
                       const bool &verbose=true) const;

    /** print the time that the system spended in kernel mode (WIN32)
        @param verbose true for additionoutput in days hour sminutes seconds  
        cmenk */
    void PrintKernelTime(std::ostream& os=std::cout, 
                         const bool &verbose=true) const;

    /** print the time that the system spended in idle mode
        @param verbose true for additionoutput in days hour sminutes seconds  
        cmenk */
    void PrintIdleTime(std::ostream& os=std::cout, 
                       const bool & verbose=true) const;

    bool IsRunning() const;

    void SetTimerFile(const std::string &file);
    void LogToFileAndReset(const std::string &comment);
    void CloseTimerFile();

    /** return number of cycles between all subsequent calls 
        to Start() and Stop() since last call to Reset() 
        @author woelk */
    double GetCycleCount() const;

    /** prints the number of cycles between subsequent 
        calls to Start() and Stop()  since last call to Reset() to os  
        @author woelk */ 
    void PrintCycleCount(std::ostream& os=std::cout) const ;

    /* Set *hi and *lo to the high and low order bits  of the cycle counter.  
       Implementation requires assembly code to use the rdtsc instruction.
       @author woelk (Linux), Win32 by Jan Woetzel */
    inline void ReadCycleCounter(unsigned int *hi, unsigned int *lo);


    /** returns the number of cycles between subsequent Start() and Stop() 
        calls !! implies a Reset(); !!!  
        @author woelk */
    double MeasureOverhead();

    /** measures the ProcessorFrequency in MHz  
        @author woelk */
    double MeasureProcessorFrequency();


    /** converts a given amount of millisecs to human redable format

        extracts hours, minutes, seconds, msecs from amout of msecs 
        (1/1000 sec).
        @param msecIN input parameter
        @author Jan Woetzel */    
    static void MSecondsToHumanReadable(const unsigned long & msIN,
                                        int & msecOUT, int & seconds,
                                        int & minutes, int & hours,
                                        int & days, int & weeks );


    /** display nr of msecs in format weeks,days,hours,minutes,seconds */
    static std::ostream & PrintMsecHumanReadable(const unsigned long msecIN, 
                                                 std::ostream &os=std::cout);
    /**
     * \brief Obtains the current time and returns as string.
     * For alternative formats see:
     * http://www.cplusplus.com/reference/clibrary/ctime/strftime/
     * \author Ingo Schiller
     * \date 04/2011
     */
    static std::string GetCurrentTimeAsString();
    /**
     * \brief Obtains the current date and returns as string.
     * For alternative formats see:
     * http://www.cplusplus.com/reference/clibrary/ctime/strftime/
     * \author Ingo Schiller
     * \date 04/2011
     */
    static std::string GetDateAsString();

  protected:
    timeval rtRealSum;
    timeval rtLast;
    timeval rtActual;
    timeval rtKernelSum;
    clock_t user; // user time
    struct tms startstruct, stopstruct; // see `man 2 times`
    bool running; // boolean to tell wether the clock is running or not 

#ifdef WIN32
    FILETIME _UserTimeStart,   _UserTimeStop;
    FILETIME _KernelTimeStart, _KernelTimeStop;
    FILETIME _IdleTimeStart,   _IdleTimeStop;
    clock_t kernel; // kernel time
    clock_t idle;   // idle time
#endif // WIN32

    double _dSum;

#ifdef WIN32
    __int64 _tscStart, _tscEnd, _tscTicks;
#else // WIN32
#  ifdef __i386__
    unsigned int _uiHiStart, _uiLoStart, _uiHiStop, _uiLoStop;
#  endif // __i386__
#endif // WIN32

    // have one file stream to log to for all timer instances
    static std::ofstream TimerStream_;

  }; // class -----------------------------------


  //
  // inline IMPLEMENTATIONs
  //

#ifndef WIN32
  inline void TimeMeasure::Start() 
  {
#  ifdef BIAS_DEBUG
     if(running) BIASERR("clock already started");   
#  endif // BIAS_DEBUG

    running = true;

    gettimeofday(&rtLast,NULL);
    if (times(&startstruct) == (clock_t)(-1))
      BIASERR("error starting user timer "<<errno);      

#   ifdef __i386__
      ReadCycleCounter(&_uiHiStart, &_uiLoStart);
#   endif //__i386__            
  }


  inline void TimeMeasure::Stop() 
  {
    if(running) {

#  ifdef __i386__
      ReadCycleCounter(&_uiHiStop, &_uiLoStop);
#  endif // __i386__

      gettimeofday(&rtActual, NULL);
      if (times(&stopstruct) == (clock_t)(-1)){
        BIASERR("error stopping user timer "<<errno);
      }
      //cerr << "stop s: "<<rtActual.tv_sec<<"\tus: "<<rtActual.tv_usec
      //<<std::endl;      
      rtRealSum.tv_sec += rtActual.tv_sec  - rtLast.tv_sec;
      long usec;
      if (rtActual.tv_usec >  rtLast.tv_usec) {
        usec = rtActual.tv_usec - rtLast.tv_usec;
      } else {
        usec = 1000000-rtLast.tv_usec+rtActual.tv_usec;
        rtRealSum.tv_sec--;
      }
      rtRealSum.tv_usec += usec;
      // cerr << "act s: "<<rtActual.tv_sec<<"\tus: "<<rtActual.tv_usec<<endl;
      // cerr << "lst s: "<<rtLast.tv_sec<<"\tus: "<<rtLast.tv_usec<<endl;
      // cerr<<"stop s: "<<rtRealSum.tv_sec<<"\tus: "<<rtRealSum.tv_usec<<endl;

      user += stopstruct.tms_utime - startstruct.tms_utime;

      //cerr << "stopstruct.tms_utime: " << stopstruct.tms_utime << endl;

#  ifdef __i386__
      double count;
      if (_uiLoStop>_uiLoStart)
        count = ((double)_uiHiStop-(double)_uiHiStart)*(double)UINT_MAX+
        (double)_uiLoStop-(double)_uiLoStart;
      else
        count = ((double)_uiHiStop-(double)_uiHiStart-1)*(double)UINT_MAX+
        (double)_uiLoStop+(double)UINT_MAX-(double)_uiLoStart;
      _dSum+=count;
#  endif    //__i386__

      running = false;
    } else {
      BIASERR("cannot stop clock befor starting it");
      BIASASSERT(running);
    } 
  }

#  ifdef __i386__
  inline 
    void TimeMeasure::ReadCycleCounter(unsigned int *hi, unsigned int *lo)
  {
    // Linux: Felix
    // see BIAS::GetTSC for WIN32 equivalent (jw)
    asm("rdtsc; movl %%edx,%0; movl %%eax,%1"   /* Read cycle counter */
      : "=r" (*hi), "=r" (*lo)                /* and move results to */
      : /* No input */                        /* the two outputs */
    : "%edx", "%eax");
  }
#  endif // __i386__
#endif // not WIN32

} // namespace 
#endif // _TIMEMEASURE_H_261946892_