clock.hxx

Go to the documentation of this file.

#ifndef CH_TOOLS__CLOCK_HXX
#define CH_TOOLS__CLOCK_HXX

#include <iostream>
#include <iomanip>
extern "C"{
#include <time.h>
}
#ifdef __unix
extern "C"{
#include <sys/resource.h>
#include <sys/timeb.h>
//we need extern int getrusage(int who, struct rusage *r_usage);
}
#endif

namespace CH_Tools {


  class Microseconds{
    bool infinity;     
    long seconds;      
    long microsecs;    

public:

    Microseconds(){seconds=0;microsecs=0;infinity=false;}
    Microseconds(bool infty){seconds=0;microsecs=0;infinity=infty;}
    Microseconds(const Microseconds& m)
    {seconds=m.seconds; microsecs=m.microsecs;infinity=m.infinity;}
    Microseconds(long secs, long msecs=0)
    {seconds=secs; microsecs=msecs;infinity=false;}
    
    Microseconds(int secs, int msecs=0)
    {seconds=secs; microsecs=msecs;infinity=false;}
    Microseconds(long hours,long minutes,long secs, long micros)
    {seconds=hours*3600+minutes*60+secs; microsecs=micros;infinity=false;}
    Microseconds(int hours,int minutes,int secs, int micros)
    {seconds=hours*3600+minutes*60+secs; microsecs=micros;infinity=false;}


    

    Microseconds& operator=(const Microseconds& m)
    {seconds=m.seconds; microsecs=m.microsecs; infinity=m.infinity;return *this;}
    
    Microseconds& operator+=(const Microseconds& m)
    {
      if (m.infinity){
        infinity=true;
        return *this;
      }
      microsecs+=m.microsecs;
      seconds+=m.seconds;
      while (microsecs>1000000){
        seconds++;
        microsecs-=1000000;
      }
      return *this;
    }
     
    Microseconds& operator-=(const Microseconds& m)
    {
     microsecs-=m.microsecs;
     seconds-=m.seconds;
     while (microsecs<0) {
         seconds--; microsecs+=1000000;
     }
     return *this;
    }

    Microseconds operator-(const Microseconds& m) const
    {Microseconds s(*this); return s-=m;}
    Microseconds operator+(const Microseconds& m) const
    {Microseconds s(*this); return s+=m;}

    bool operator<(const Microseconds& m) const
    {
      if (infinity) return false;
      if (m.infinity) return true;
      return ((seconds<m.seconds)||((seconds==m.seconds)&&(microsecs<m.microsecs)));
    }

    bool operator>(const Microseconds& m) const
    {
      if (infinity&&(!m.infinity)) return true;
      if (m.infinity) return false;
      return ((seconds>m.seconds)||((seconds==m.seconds)&&(microsecs>m.microsecs)));}

    bool operator<=(const Microseconds& m) const
    {
      if (infinity&&(!m.infinity)) return false;
      if (m.infinity) return true;
      return ((seconds<m.seconds)||((seconds==m.seconds)&&(microsecs<=m.microsecs)));}

    bool operator>=(const Microseconds& m) const 
    {
      if (infinity) return true;
      if (m.infinity) return false;
      return ((seconds>m.seconds)||((seconds==m.seconds)&&(microsecs>=m.microsecs)));}

    bool operator==(const Microseconds& m) const
    {
     if ((infinity&&(!m.infinity))||(m.infinity)) return false;
     return ((seconds==m.seconds)&&(microsecs==m.microsecs));}



    void set_infinity(bool infty){infinity=infty;}
    bool get_infinity() const {return infinity;}

    operator double() const 
    { return double(seconds)+double(microsecs)/1000000.; }

    void hhmmss(long& hours,long& minutes,long& secs) const
    {
     long s=seconds;
     if (microsecs>=500000) s++;
     hours=s/3600;
     minutes=(s%3600)/60;
     secs=(s%60);
    }

    void hhmmssdd(long& hours,long& minutes,long& secs,long& hund) const
    {
     hund=(microsecs+5000)/10000;
     long s=seconds;
     if (hund==100) {s++;hund=0;}
     hours=s/3600;
     minutes=(s%3600)/60;
     secs=(s%60);
    }

    long roundsecs() const
    {
     if (microsecs>=500000) return seconds+1;
     return seconds;
    }
    
    long roundhundredths() const
    {
     long hund=(microsecs+5000)/10000;
     hund+=seconds*100;
     return hund;
    }



    friend std::ostream& operator<<(std::ostream& out,const Microseconds& m)
    {if (m.infinity) return out<<"-1.000000";
     out<<m.seconds<<".";out.fill('0');out.width(6);out<<m.microsecs;
     out.fill(' ');return out;}


    friend std::istream& operator>>(std::istream& in,Microseconds& m)
    {
     char c; m.infinity=false;
     in>>m.seconds>>c>>m.microsecs;
     if (m.seconds<0) {m.seconds=0; m.infinity=true;}
     return in;
    }     

    friend void print_time(std::ostream& out,     
                           const Microseconds& m, 
                           int secondsonly=0      
                           )
    {
      long hours,minutes,seconds,hunds;
      out.fill('0');
      if (secondsonly){
        m.hhmmss(hours,minutes,seconds);
        out.width(2);out<<hours;
        out<<":";out.width(2);out<<minutes;
        out<<":";out.width(2);out<<seconds;
      }
      else {
        m.hhmmssdd(hours,minutes,seconds,hunds);
        out.width(2);out<<hours;
        out<<":";out.width(2);out<<minutes;
        out<<":";out.width(2);out<<seconds;
        out<<".";out.width(2);out<<hunds;
      }
      out.fill(' ');
    }
    

};


  inline Microseconds wall_clock(void)
  {
#ifdef __unix
    struct timeb ts;
    ftime(&ts);
    return Microseconds(long(ts.time),long(ts.millitm)*1000);
#else
    return Microseconds();
#endif
  }


class Clock
{
  private:
  Microseconds t_start; 
  Microseconds offset; 
  Microseconds wall_start; 
#ifdef __unix
#else
  long l_start; 
#endif

  public:
    void start(){
#ifdef __unix
        struct rusage r_usage;
        getrusage(RUSAGE_SELF,&r_usage);
        t_start=Microseconds(r_usage.ru_utime.tv_sec,r_usage.ru_utime.tv_usec);
        offset=Microseconds(0,0);
        wall_start=wall_clock();
#else
        t_start=Microseconds(static_cast<int>(::time(0)),0);
#endif
    }

    Clock(){start();}
    ~Clock(){}

    void set_offset(Microseconds offs){
        offset=offs;
    }

    Microseconds time() const{
#ifdef __unix
        struct rusage r_usage;
        getrusage(RUSAGE_SELF,&r_usage);
        Microseconds elapsed(r_usage.ru_utime.tv_sec,r_usage.ru_utime.tv_usec);
#else
        Microseconds elapsed(static_cast<int>(::time(0)),0);
#endif
        elapsed-=t_start;
        elapsed+=offset;
        return elapsed;
    }

    Microseconds wall_time() const {
      return wall_clock()-wall_start;
    }

    void elapsed_time(std::ostream& out) const
    {
        time_t current=::time(0);
        struct tm *loctime;                     
        Microseconds spent=time();
        out<<"elapsed time: ";
        print_time(out,wall_clock()-wall_start);
        out<<" user: ";
        print_time(out,spent);
        loctime=localtime(&current);
        out<<"   ----   "<<asctime(loctime)<<std::flush;
    }

    friend inline std::ostream& operator<<(std::ostream& out,const Clock& cl)
    {
        print_time(out,cl.time());
        return out;
    }
};


}

#endif