LEMON/LEMON-official Changeset - r126:e1dd2a70737c

Repositories » LEMON » LEMON-official

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r126:e1dd2a70737c

« 125:19e82b

127:1c9a9e »

r126:e1dd2a70737c

Mon, 14 Apr 2008 10:46:41

[Not Reviewed]

0 comments (0 inline)

deba@inf.elte.hu
deba@inf.elte.hu

MinGW compatible time measure + changes in its internals

0 1 0

default

1 file changed with 88 insertions and 53 deletions:

lemon/time_measure.h

↑ Collapse diff ↑

lemon/time_measure.h

Show inline comments

@@ -14,30 +14,34 @@
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_TIME_MEASURE_H
 		#define LEMON_TIME_MEASURE_H
 		///\ingroup timecount
 		///\file
 		///\brief Tools for measuring cpu usage
 		#ifdef WIN32
 		#include <windows.h>
 		#include <cmath>
 		#else
 		#include <sys/times.h>
 		#include <sys/time.h>
 		#endif
 		#include <sys/time.h>
 		#include <fstream>
 		#include <iostream>
 		#include <unistd.h>
 		namespace lemon {
 		  /// \addtogroup timecount
 		  /// @{
 		  /// A class to store (cpu)time instances.
 		  /// This class stores five time values.
 		  /// - a real time
 		  /// - a user cpu time
 		  /// - a system cpu time
@@ -45,189 +49,214 @@
 		  /// - a system cpu time of children
 		  ///
 		  /// TimeStamp's can be added to or substracted from each other and
 		  /// they can be pushed to a stream.
 		  ///
 		  /// In most cases, perhaps the \ref Timer or the \ref TimeReport
 		  /// class is what you want to use instead.
 		  ///
 		  ///\author Alpar Juttner
 		  class TimeStamp
+		  {
 		    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;
 		    double utime;
 		    double stime;
 		    double cutime;
 		    double cstime;
 		    double rtime;
 		    rtms &getTms() {return ts;}
 		    const rtms &getTms() const {return ts;}
 		    void _reset() {
 		      ts.tms_utime = ts.tms_stime = ts.tms_cutime = ts.tms_cstime = 0;
 		      real_time = 0;
 		      utime = stime = cutime = cstime = rtime = 0;
+		    }
 		  public:
 		    ///Read the current time values of the process
 		    void stamp()
+		    {
 		#ifndef WIN32
 		      timeval tv;
 		      tms _ts;
 		      times(&_ts);
 		      gettimeofday(&tv, 0);real_time=tv.tv_sec+double(tv.tv_usec)/1e6;
 		      ts=_ts;
 		      gettimeofday(&tv, 0);
 		      rtime=tv.tv_sec+double(tv.tv_usec)/1e6;
 		      tms ts;
 		      double tck=sysconf(_SC_CLK_TCK);
 		      times(&ts);
 		      utime=ts.tms_utime/tck;
 		      stime=ts.tms_stime/tck;
 		      cutime=ts.tms_cutime/tck;
 		      cstime=ts.tms_cstime/tck;
 		#else
 		      static const double ch = 4294967296.0e-7;
 		      static const double cl = 1.0e-7;
 		      FILETIME system;
 		      GetSystemTimeAsFileTime(&system);
 		      rtime = ch * system.dwHighDateTime + cl * system.dwLowDateTime;
 		      FILETIME create, exit, kernel, user;
 		      if (GetProcessTimes(GetCurrentProcess(),&create, &exit, &kernel, &user)) {
 			utime = ch * user.dwHighDateTime + cl * user.dwLowDateTime;
 			stime = ch * kernel.dwHighDateTime + cl * kernel.dwLowDateTime;
 			cutime = 0;
 			cstime = 0;
 		      } else {
 			rtime = 0;
 			utime = 0;
 			stime = 0;
 			cutime = 0;
 			cstime = 0;
+		      }
 		#endif
+		    }
 		    /// Constructor initializing with zero
 		    TimeStamp()
 		    { _reset(); }
 		    ///Constructor initializing with the current time values of the process
 		    TimeStamp(void *) { stamp();}
 		    ///Set every time value to zero
 		    TimeStamp &reset() {_reset();return *this;}
 		    ///\e
 		    TimeStamp &operator+=(const TimeStamp &b)
+		    {
 		      ts.tms_utime+=b.ts.tms_utime;
 		      ts.tms_stime+=b.ts.tms_stime;
 		      ts.tms_cutime+=b.ts.tms_cutime;
 		      ts.tms_cstime+=b.ts.tms_cstime;
-		      real_time+=b.real_time;
+		      utime+=b.utime;
 		      stime+=b.stime;
 		      cutime+=b.cutime;
 		      cstime+=b.cstime;
 		      rtime+=b.rtime;
 		      return *this;
+		    }
 		    ///\e
 		    TimeStamp operator+(const TimeStamp &b) const
+		    {
 		      TimeStamp t(*this);
 		      return t+=b;
+		    }
 		    ///\e
 		    TimeStamp &operator-=(const TimeStamp &b)
+		    {
 		      ts.tms_utime-=b.ts.tms_utime;
 		      ts.tms_stime-=b.ts.tms_stime;
 		      ts.tms_cutime-=b.ts.tms_cutime;
 		      ts.tms_cstime-=b.ts.tms_cstime;
-		      real_time-=b.real_time;
+		      utime-=b.utime;
 		      stime-=b.stime;
 		      cutime-=b.cutime;
 		      cstime-=b.cstime;
 		      rtime-=b.rtime;
 		      return *this;
+		    }
 		    ///\e
 		    TimeStamp operator-(const TimeStamp &b) const
+		    {
 		      TimeStamp t(*this);
 		      return t-=b;
+		    }
 		    ///\e
 		    TimeStamp &operator*=(double b)
+		    {
 		      ts.tms_utime*=b;
 		      ts.tms_stime*=b;
 		      ts.tms_cutime*=b;
 		      ts.tms_cstime*=b;
-		      real_time*=b;
+		      utime*=b;
 		      stime*=b;
 		      cutime*=b;
 		      cstime*=b;
 		      rtime*=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;
+		      utime/=b;
 		      stime/=b;
 		      cutime/=b;
 		      cstime/=b;
 		      rtime/=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
+		    {
 		      TimeStamp t(NULL);
 		      return t-*this;
+		    }
 		    friend std::ostream& operator<<(std::ostream& os,const TimeStamp &t);
 		    ///Gives back the user time of the process
 		    double userTime() const
+		    {
-		      return double(ts.tms_utime)/sysconf(_SC_CLK_TCK);
+		      return utime;
+		    }
 		    ///Gives back the system time of the process
 		    double systemTime() const
+		    {
-		      return double(ts.tms_stime)/sysconf(_SC_CLK_TCK);
+		      return stime;
+		    }
 		    ///Gives back the user time of the process' children
 		    ///\note On <tt>WIN32</tt> platform this value is not calculated.
 		    ///
 		    double cUserTime() const
+		    {
-		      return double(ts.tms_cutime)/sysconf(_SC_CLK_TCK);
+		      return cutime;
+		    }
 		    ///Gives back the user time of the process' children
 		    ///\note On <tt>WIN32</tt> platform this value is not calculated.
 		    ///
 		    double cSystemTime() const
+		    {
-		      return double(ts.tms_cstime)/sysconf(_SC_CLK_TCK);
+		      return cstime;
+		    }
 		    ///Gives back the real time
-		    double realTime() const {return real_time;}
+		    double realTime() const {return rtime;}
 		  };
 		  TimeStamp operator*(double b,const TimeStamp &t)
+		  {
 		    return t*b;
+		  }
 		  ///Prints the time counters
 		  ///Prints the time counters in the following form:
 		  ///
 		  /// <tt>u: XX.XXs s: XX.XXs cu: XX.XXs cs: XX.XXs real: XX.XXs</tt>
 		  ///
 		  /// where the values are the
 		  /// \li \c u: user cpu time,
 		  /// \li \c s: system cpu time,
 		  /// \li \c cu: user cpu time of children,
 		  /// \li \c cs: system cpu time of children,
 		  /// \li \c real: real time.
 		  /// \relates TimeStamp
 		  /// \note On <tt>WIN32</tt> platform the cummulative values are not
 		  /// calculated.
 		  inline std::ostream& operator<<(std::ostream& os,const TimeStamp &t)
+		  {
 		    long cls = sysconf(_SC_CLK_TCK);
 		    os << "u: " << double(t.getTms().tms_utime)/cls <<
 		      "s, s: " << double(t.getTms().tms_stime)/cls <<
 		      "s, cu: " << double(t.getTms().tms_cutime)/cls <<
-		      "s, cs: " << double(t.getTms().tms_cstime)/cls <<
+		    os << "u: " << t.userTime() <<
 		      "s, s: " << t.systemTime() <<
 		      "s, cu: " << t.cUserTime() <<
 		      "s, cs: " << t.cSystemTime() <<
 		      "s, real: " << t.realTime() << "s";
 		    return os;
+		  }
 		  ///Class for measuring the cpu time and real time usage of the process
 		  ///Class for measuring the cpu time and real time usage of the process.
 		  ///It is quite easy-to-use, here is a short example.
 		  ///\code
 		  /// #include<lemon/time_measure.h>
 		  /// #include<iostream>
 		  ///
@@ -395,29 +424,35 @@
 		    ///Gives back the ellapsed user time of the process
 		    double userTime() const
+		    {
 		      return operator TimeStamp().userTime();
+		    }
 		    ///Gives back the ellapsed system time of the process
 		    double systemTime() const
+		    {
 		      return operator TimeStamp().systemTime();
+		    }
 		    ///Gives back the ellapsed user time of the process' children
 		    ///\note On <tt>WIN32</tt> platform this value is not calculated.
 		    ///
 		    double cUserTime() const
+		    {
 		      return operator TimeStamp().cUserTime();
+		    }
 		    ///Gives back the ellapsed user time of the process' children
 		    ///\note On <tt>WIN32</tt> platform this value is not calculated.
 		    ///
 		    double cSystemTime() const
+		    {
 		      return operator TimeStamp().cSystemTime();
+		    }
 		    ///Gives back the ellapsed real time
 		    double realTime() const
+		    {
 		      return operator TimeStamp().realTime();
+		    }
 		    ///Computes the ellapsed time
 		    ///This conversion computes the ellapsed time, therefore you can print

0 comments (0 inline)

RhodeCode

Login to your account