Changeset 1689:f1795dafe42c in lemon-0.x for lemon/time_measure.h

Timestamp:

09/28/05 10:14:39 (19 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2213

Message:

• runningTimeTest(): a tool to measure running times more precisely.
• TimeStamp? now uses double to count cpu-times
• 'get's removed from the query functions of Times and TimeStamp?

File:

• lemon/time_measure.h (modified) (5 diffs)

lemon/time_measure.h

@@ -51 +51 @@
   class TimeStamp
   {
-    tms ts;
+    struct rtms 
+    {
+      double tms_utime;
+      double tms_stime;
+      double tms_cutime;
+      double tms_cstime;
+      rtms() {}
+      rtms(tms ts) : tms_utime(ts.tms_utime), tms_stime(ts.tms_stime),
+                     tms_cutime(ts.tms_cutime), tms_cstime(ts.tms_cstime) {}
+    };
+    rtms ts;
     double real_time;
   
+    rtms &getTms() {return ts;}
+    const rtms &getTms() const {return ts;}
+
   public:
 
-    tms &getTms() {return ts;}
-    const tms &getTms() const {return ts;}
     ///Read the current time values of the process
     void stamp()
     {
       timeval tv;
-      times(&ts);
+      tms _ts;
+      times(&_ts);
       gettimeofday(&tv, 0);real_time=tv.tv_sec+double(tv.tv_usec)/1e6;
+      ts=_ts;
     }
   
@@ -104 +117 @@
       return t-=b;
     }
+    ///\e
+
+    ///\bug operator * and / gives rounded values!
+    TimeStamp &operator*=(double b)
+    {
+      ts.tms_utime*=b;
+      ts.tms_stime*=b;
+      ts.tms_cutime*=b;
+      ts.tms_cstime*=b;
+      real_time*=b;
+      return *this;
+    }
+    ///\e
+    TimeStamp operator*(double b) const
+    {
+      TimeStamp t(*this);
+      return t*=b;
+    }
+    friend TimeStamp operator*(double b,const TimeStamp &t);
+    ///\e
+    TimeStamp &operator/=(double b)
+    {
+      ts.tms_utime/=b;
+      ts.tms_stime/=b;
+      ts.tms_cutime/=b;
+      ts.tms_cstime/=b;
+      real_time/=b;
+      return *this;
+    }
+    ///\e
+    TimeStamp operator/(double b) const
+    {
+      TimeStamp t(*this);
+      return t/=b;
+    }
     ///The time ellapsed since the last call of stamp()
     TimeStamp ellapsed() const
@@ -114 +162 @@
   
     ///Gives back the user time of the process
-    double getUserTime() const
+    double userTime() const
     {
       return double(ts.tms_utime)/sysconf(_SC_CLK_TCK);
     }
     ///Gives back the system time of the process
-    double getSystemTime() const
+    double systemTime() const
     {
       return double(ts.tms_stime)/sysconf(_SC_CLK_TCK);
     }
     ///Gives back the user time of the process' children
-    double getCUserTime() const
+    double cUserTime() const
     {
       return double(ts.tms_cutime)/sysconf(_SC_CLK_TCK);
     }
     ///Gives back the user time of the process' children
-    double getCSystemTime() const
+    double cSystemTime() const
     {
       return double(ts.tms_cstime)/sysconf(_SC_CLK_TCK);
     }
     ///Gives back the real time of the process
-    double getRealTime() const {return real_time;}
+    double realTime() const {return real_time;}
   };
 
+  TimeStamp operator*(double b,const TimeStamp &t) 
+  {
+    return t*b;
+  }
+  
   ///Class measuring the cpu time and real time usage of the process
 
@@ -198 +251 @@
 
     ///Gives back the ellapsed user time of the process
-    double getUserTime() const
-    {
-      return operator TimeStamp().getUserTime();
+    double userTime() const
+    {
+      return operator TimeStamp().userTime();
     }
     ///Gives back the ellapsed system time of the process
-    double getSystemTime() const
-    {
-      return operator TimeStamp().getSystemTime();
+    double systemTime() const
+    {
+      return operator TimeStamp().systemTime();
     }
     ///Gives back the ellapsed user time of the process' children
-    double getCUserTime() const
-    {
-      return operator TimeStamp().getCUserTime();
+    double cUserTime() const
+    {
+      return operator TimeStamp().cUserTime();
     }
     ///Gives back the ellapsed user time of the process' children
-    double getCSystemTime() const
-    {
-      return operator TimeStamp().getCSystemTime();
+    double cSystemTime() const
+    {
+      return operator TimeStamp().cSystemTime();
     }
     ///Gives back the ellapsed real time of the process
-    double getRealTime() const
-    {
-      return operator TimeStamp().getRealTime();
+    double realTime() const
+    {
+      return operator TimeStamp().realTime();
     }
 
@@ -245 +298 @@
       "s, cu: " << double(t.getTms().tms_cutime)/cls <<
       "s, cs: " << double(t.getTms().tms_cstime)/cls <<
-      "s, real: " << t.getRealTime() << "s";
+      "s, real: " << t.realTime() << "s";
     return os;
   }
 
+  
+  ///Tool to measure the running time more exactly.
+  
+  ///This function calls \c f several times and returns the average
+  ///running time. The number of the executions will be choosen in such a way
+  ///that the full running time will be roughly between \c min_time
+  ///and <tt>2*min_time</tt>.
+  ///\param f the function object to be measured.
+  ///\param min_time the minimum total running time.
+  ///\retval num if it is not \c NULL, then *num will contain the actual
+  ///        number of execution of \c f.
+  ///\retval full_time if it is not \c NULL, then *full_time
+  ///        will contain the actual
+  ///        total running time.
+  ///\return The average running time of \c f.
+  
+  template<class F>
+  TimeStamp runningTimeTest(F &f,double min_time=10,int *num = NULL,
+                        TimeStamp *full_time=NULL)
+  {
+    Timer t;
+    TimeStamp full;
+    int total=0;
+    for(int tn=1;tn < 1<<24; tn*=2) {
+      for(;total<tn;total++) f();
+      full=t;
+      if(full.realTime()>min_time) {
+        if(num) *num=total;
+        if(full_time) *full_time=full;
+      return full/total;
+      }
+    }
+    return TimeStamp();
+  }
+  
   /// @}  
 
+
 } //namespace lemon