r126:e1dd2a70737c
Mon, 14 Apr 2008 10:46:41
[Not Reviewed]
0 comments (0 inline)
0
1
0
88
53
| ... | ... |
@@ -20,18 +20,22 @@ |
| 20 | 20 |
#define LEMON_TIME_MEASURE_H |
| 21 | 21 |
|
| 22 | 22 |
///\ingroup timecount |
| 23 | 23 |
///\file |
| 24 | 24 |
///\brief Tools for measuring cpu usage |
| 25 | 25 |
|
| 26 |
#ifdef WIN32 |
|
| 27 |
#include <windows.h> |
|
| 28 |
#include <cmath> |
|
| 29 |
#else |
|
| 26 | 30 |
#include <sys/times.h> |
| 31 |
#include <sys/time.h> |
|
| 32 |
#endif |
|
| 27 | 33 |
|
| 28 |
#include <sys/time.h> |
|
| 29 | 34 |
#include <fstream> |
| 30 | 35 |
#include <iostream> |
| 31 |
#include <unistd.h> |
|
| 32 | 36 |
|
| 33 | 37 |
namespace lemon {
|
| 34 | 38 |
|
| 35 | 39 |
/// \addtogroup timecount |
| 36 | 40 |
/// @{
|
| 37 | 41 |
|
| ... | ... |
@@ -51,43 +55,61 @@ |
| 51 | 55 |
/// class is what you want to use instead. |
| 52 | 56 |
/// |
| 53 | 57 |
///\author Alpar Juttner |
| 54 | 58 |
|
| 55 | 59 |
class TimeStamp |
| 56 | 60 |
{
|
| 57 |
struct rtms |
|
| 58 |
{
|
|
| 59 |
double tms_utime; |
|
| 60 |
double tms_stime; |
|
| 61 |
double tms_cutime; |
|
| 62 |
double tms_cstime; |
|
| 63 |
rtms() {}
|
|
| 64 |
rtms(tms ts) : tms_utime(ts.tms_utime), tms_stime(ts.tms_stime), |
|
| 65 |
tms_cutime(ts.tms_cutime), tms_cstime(ts.tms_cstime) {}
|
|
| 66 |
}; |
|
| 67 |
rtms ts; |
|
| 68 |
double real_time; |
|
| 61 |
double utime; |
|
| 62 |
double stime; |
|
| 63 |
double cutime; |
|
| 64 |
double cstime; |
|
| 65 |
double rtime; |
|
| 69 | 66 |
|
| 70 |
rtms &getTms() {return ts;}
|
|
| 71 |
const rtms &getTms() const {return ts;}
|
|
| 72 |
|
|
| 73 | 67 |
void _reset() {
|
| 74 |
ts.tms_utime = ts.tms_stime = ts.tms_cutime = ts.tms_cstime = 0; |
|
| 75 |
real_time = 0; |
|
| 68 |
utime = stime = cutime = cstime = rtime = 0; |
|
| 76 | 69 |
} |
| 77 | 70 |
|
| 78 | 71 |
public: |
| 79 | 72 |
|
| 80 | 73 |
///Read the current time values of the process |
| 81 | 74 |
void stamp() |
| 82 | 75 |
{
|
| 76 |
#ifndef WIN32 |
|
| 83 | 77 |
timeval tv; |
| 84 |
tms _ts; |
|
| 85 |
times(&_ts); |
|
| 86 |
gettimeofday(&tv, 0);real_time=tv.tv_sec+double(tv.tv_usec)/1e6; |
|
| 87 |
ts=_ts; |
|
| 78 |
gettimeofday(&tv, 0); |
|
| 79 |
rtime=tv.tv_sec+double(tv.tv_usec)/1e6; |
|
| 80 |
|
|
| 81 |
tms ts; |
|
| 82 |
double tck=sysconf(_SC_CLK_TCK); |
|
| 83 |
times(&ts); |
|
| 84 |
utime=ts.tms_utime/tck; |
|
| 85 |
stime=ts.tms_stime/tck; |
|
| 86 |
cutime=ts.tms_cutime/tck; |
|
| 87 |
cstime=ts.tms_cstime/tck; |
|
| 88 |
#else |
|
| 89 |
static const double ch = 4294967296.0e-7; |
|
| 90 |
static const double cl = 1.0e-7; |
|
| 91 |
|
|
| 92 |
FILETIME system; |
|
| 93 |
GetSystemTimeAsFileTime(&system); |
|
| 94 |
rtime = ch * system.dwHighDateTime + cl * system.dwLowDateTime; |
|
| 95 |
|
|
| 96 |
FILETIME create, exit, kernel, user; |
|
| 97 |
if (GetProcessTimes(GetCurrentProcess(),&create, &exit, &kernel, &user)) {
|
|
| 98 |
utime = ch * user.dwHighDateTime + cl * user.dwLowDateTime; |
|
| 99 |
stime = ch * kernel.dwHighDateTime + cl * kernel.dwLowDateTime; |
|
| 100 |
cutime = 0; |
|
| 101 |
cstime = 0; |
|
| 102 |
} else {
|
|
| 103 |
rtime = 0; |
|
| 104 |
utime = 0; |
|
| 105 |
stime = 0; |
|
| 106 |
cutime = 0; |
|
| 107 |
cstime = 0; |
|
| 108 |
} |
|
| 109 |
#endif |
|
| 88 | 110 |
} |
| 89 | 111 |
|
| 90 | 112 |
/// Constructor initializing with zero |
| 91 | 113 |
TimeStamp() |
| 92 | 114 |
{ _reset(); }
|
| 93 | 115 |
///Constructor initializing with the current time values of the process |
| ... | ... |
@@ -96,66 +118,66 @@ |
| 96 | 118 |
///Set every time value to zero |
| 97 | 119 |
TimeStamp &reset() {_reset();return *this;}
|
| 98 | 120 |
|
| 99 | 121 |
///\e |
| 100 | 122 |
TimeStamp &operator+=(const TimeStamp &b) |
| 101 | 123 |
{
|
| 102 |
ts.tms_utime+=b.ts.tms_utime; |
|
| 103 |
ts.tms_stime+=b.ts.tms_stime; |
|
| 104 |
ts.tms_cutime+=b.ts.tms_cutime; |
|
| 105 |
ts.tms_cstime+=b.ts.tms_cstime; |
|
| 106 |
|
|
| 124 |
utime+=b.utime; |
|
| 125 |
stime+=b.stime; |
|
| 126 |
cutime+=b.cutime; |
|
| 127 |
cstime+=b.cstime; |
|
| 128 |
rtime+=b.rtime; |
|
| 107 | 129 |
return *this; |
| 108 | 130 |
} |
| 109 | 131 |
///\e |
| 110 | 132 |
TimeStamp operator+(const TimeStamp &b) const |
| 111 | 133 |
{
|
| 112 | 134 |
TimeStamp t(*this); |
| 113 | 135 |
return t+=b; |
| 114 | 136 |
} |
| 115 | 137 |
///\e |
| 116 | 138 |
TimeStamp &operator-=(const TimeStamp &b) |
| 117 | 139 |
{
|
| 118 |
ts.tms_utime-=b.ts.tms_utime; |
|
| 119 |
ts.tms_stime-=b.ts.tms_stime; |
|
| 120 |
ts.tms_cutime-=b.ts.tms_cutime; |
|
| 121 |
ts.tms_cstime-=b.ts.tms_cstime; |
|
| 122 |
|
|
| 140 |
utime-=b.utime; |
|
| 141 |
stime-=b.stime; |
|
| 142 |
cutime-=b.cutime; |
|
| 143 |
cstime-=b.cstime; |
|
| 144 |
rtime-=b.rtime; |
|
| 123 | 145 |
return *this; |
| 124 | 146 |
} |
| 125 | 147 |
///\e |
| 126 | 148 |
TimeStamp operator-(const TimeStamp &b) const |
| 127 | 149 |
{
|
| 128 | 150 |
TimeStamp t(*this); |
| 129 | 151 |
return t-=b; |
| 130 | 152 |
} |
| 131 | 153 |
///\e |
| 132 | 154 |
TimeStamp &operator*=(double b) |
| 133 | 155 |
{
|
| 134 |
ts.tms_utime*=b; |
|
| 135 |
ts.tms_stime*=b; |
|
| 136 |
ts.tms_cutime*=b; |
|
| 137 |
ts.tms_cstime*=b; |
|
| 138 |
|
|
| 156 |
utime*=b; |
|
| 157 |
stime*=b; |
|
| 158 |
cutime*=b; |
|
| 159 |
cstime*=b; |
|
| 160 |
rtime*=b; |
|
| 139 | 161 |
return *this; |
| 140 | 162 |
} |
| 141 | 163 |
///\e |
| 142 | 164 |
TimeStamp operator*(double b) const |
| 143 | 165 |
{
|
| 144 | 166 |
TimeStamp t(*this); |
| 145 | 167 |
return t*=b; |
| 146 | 168 |
} |
| 147 | 169 |
friend TimeStamp operator*(double b,const TimeStamp &t); |
| 148 | 170 |
///\e |
| 149 | 171 |
TimeStamp &operator/=(double b) |
| 150 | 172 |
{
|
| 151 |
ts.tms_utime/=b; |
|
| 152 |
ts.tms_stime/=b; |
|
| 153 |
ts.tms_cutime/=b; |
|
| 154 |
ts.tms_cstime/=b; |
|
| 155 |
|
|
| 173 |
utime/=b; |
|
| 174 |
stime/=b; |
|
| 175 |
cutime/=b; |
|
| 176 |
cstime/=b; |
|
| 177 |
rtime/=b; |
|
| 156 | 178 |
return *this; |
| 157 | 179 |
} |
| 158 | 180 |
///\e |
| 159 | 181 |
TimeStamp operator/(double b) const |
| 160 | 182 |
{
|
| 161 | 183 |
TimeStamp t(*this); |
| ... | ... |
@@ -170,31 +192,37 @@ |
| 170 | 192 |
|
| 171 | 193 |
friend std::ostream& operator<<(std::ostream& os,const TimeStamp &t); |
| 172 | 194 |
|
| 173 | 195 |
///Gives back the user time of the process |
| 174 | 196 |
double userTime() const |
| 175 | 197 |
{
|
| 176 |
return |
|
| 198 |
return utime; |
|
| 177 | 199 |
} |
| 178 | 200 |
///Gives back the system time of the process |
| 179 | 201 |
double systemTime() const |
| 180 | 202 |
{
|
| 181 |
return |
|
| 203 |
return stime; |
|
| 182 | 204 |
} |
| 183 | 205 |
///Gives back the user time of the process' children |
| 206 |
|
|
| 207 |
///\note On <tt>WIN32</tt> platform this value is not calculated. |
|
| 208 |
/// |
|
| 184 | 209 |
double cUserTime() const |
| 185 | 210 |
{
|
| 186 |
return |
|
| 211 |
return cutime; |
|
| 187 | 212 |
} |
| 188 | 213 |
///Gives back the user time of the process' children |
| 214 |
|
|
| 215 |
///\note On <tt>WIN32</tt> platform this value is not calculated. |
|
| 216 |
/// |
|
| 189 | 217 |
double cSystemTime() const |
| 190 | 218 |
{
|
| 191 |
return |
|
| 219 |
return cstime; |
|
| 192 | 220 |
} |
| 193 | 221 |
///Gives back the real time |
| 194 |
double realTime() const {return
|
|
| 222 |
double realTime() const {return rtime;}
|
|
| 195 | 223 |
}; |
| 196 | 224 |
|
| 197 | 225 |
TimeStamp operator*(double b,const TimeStamp &t) |
| 198 | 226 |
{
|
| 199 | 227 |
return t*b; |
| 200 | 228 |
} |
| ... | ... |
@@ -209,19 +237,20 @@ |
| 209 | 237 |
/// \li \c u: user cpu time, |
| 210 | 238 |
/// \li \c s: system cpu time, |
| 211 | 239 |
/// \li \c cu: user cpu time of children, |
| 212 | 240 |
/// \li \c cs: system cpu time of children, |
| 213 | 241 |
/// \li \c real: real time. |
| 214 | 242 |
/// \relates TimeStamp |
| 243 |
/// \note On <tt>WIN32</tt> platform the cummulative values are not |
|
| 244 |
/// calculated. |
|
| 215 | 245 |
inline std::ostream& operator<<(std::ostream& os,const TimeStamp &t) |
| 216 | 246 |
{
|
| 217 |
long cls = sysconf(_SC_CLK_TCK); |
|
| 218 |
os << "u: " << double(t.getTms().tms_utime)/cls << |
|
| 219 |
"s, s: " << double(t.getTms().tms_stime)/cls << |
|
| 220 |
"s, cu: " << double(t.getTms().tms_cutime)/cls << |
|
| 221 |
|
|
| 247 |
os << "u: " << t.userTime() << |
|
| 248 |
"s, s: " << t.systemTime() << |
|
| 249 |
"s, cu: " << t.cUserTime() << |
|
| 250 |
"s, cs: " << t.cSystemTime() << |
|
| 222 | 251 |
"s, real: " << t.realTime() << "s"; |
| 223 | 252 |
return os; |
| 224 | 253 |
} |
| 225 | 254 |
|
| 226 | 255 |
///Class for measuring the cpu time and real time usage of the process |
| 227 | 256 |
|
| ... | ... |
@@ -401,17 +430,23 @@ |
| 401 | 430 |
///Gives back the ellapsed system time of the process |
| 402 | 431 |
double systemTime() const |
| 403 | 432 |
{
|
| 404 | 433 |
return operator TimeStamp().systemTime(); |
| 405 | 434 |
} |
| 406 | 435 |
///Gives back the ellapsed user time of the process' children |
| 436 |
|
|
| 437 |
///\note On <tt>WIN32</tt> platform this value is not calculated. |
|
| 438 |
/// |
|
| 407 | 439 |
double cUserTime() const |
| 408 | 440 |
{
|
| 409 | 441 |
return operator TimeStamp().cUserTime(); |
| 410 | 442 |
} |
| 411 | 443 |
///Gives back the ellapsed user time of the process' children |
| 444 |
|
|
| 445 |
///\note On <tt>WIN32</tt> platform this value is not calculated. |
|
| 446 |
/// |
|
| 412 | 447 |
double cSystemTime() const |
| 413 | 448 |
{
|
| 414 | 449 |
return operator TimeStamp().cSystemTime(); |
| 415 | 450 |
} |
| 416 | 451 |
///Gives back the ellapsed real time |
| 417 | 452 |
double realTime() const |
0 comments (0 inline)