Set the proper version for CMAKE in the tarballs (made by autotools).
1 /* -*- mode: C++; indent-tabs-mode: nil; -*-
3 * This file is a part of LEMON, a generic C++ optimization library.
5 * Copyright (C) 2003-2008
6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7 * (Egervary Research Group on Combinatorial Optimization, EGRES).
9 * Permission to use, modify and distribute this software is granted
10 * provided that this copyright notice appears in all copies. For
11 * precise terms see the accompanying LICENSE file.
13 * This software is provided "AS IS" with no warranty of any kind,
14 * express or implied, and with no claim as to its suitability for any
19 #ifndef LEMON_TIME_MEASURE_H
20 #define LEMON_TIME_MEASURE_H
24 ///\brief Tools for measuring cpu usage
27 #define WIN32_LEAN_AND_MEAN
32 #include <sys/times.h>
42 /// \addtogroup timecount
45 /// A class to store (cpu)time instances.
47 /// This class stores five time values.
50 /// - a system cpu time
51 /// - a user cpu time of children
52 /// - a system cpu time of children
54 /// TimeStamp's can be added to or substracted from each other and
55 /// they can be pushed to a stream.
57 /// In most cases, perhaps the \ref Timer or the \ref TimeReport
58 /// class is what you want to use instead.
69 utime = stime = cutime = cstime = rtime = 0;
74 ///Read the current time values of the process
80 rtime=tv.tv_sec+double(tv.tv_usec)/1e6;
83 double tck=sysconf(_SC_CLK_TCK);
85 utime=ts.tms_utime/tck;
86 stime=ts.tms_stime/tck;
87 cutime=ts.tms_cutime/tck;
88 cstime=ts.tms_cstime/tck;
90 static const double ch = 4294967296.0e-7;
91 static const double cl = 1.0e-7;
94 GetSystemTimeAsFileTime(&system);
95 rtime = ch * system.dwHighDateTime + cl * system.dwLowDateTime;
97 FILETIME create, exit, kernel, user;
98 if (GetProcessTimes(GetCurrentProcess(),&create, &exit, &kernel, &user)) {
99 utime = ch * user.dwHighDateTime + cl * user.dwLowDateTime;
100 stime = ch * kernel.dwHighDateTime + cl * kernel.dwLowDateTime;
113 /// Constructor initializing with zero
116 ///Constructor initializing with the current time values of the process
117 TimeStamp(void *) { stamp();}
119 ///Set every time value to zero
120 TimeStamp &reset() {_reset();return *this;}
123 TimeStamp &operator+=(const TimeStamp &b)
133 TimeStamp operator+(const TimeStamp &b) const
139 TimeStamp &operator-=(const TimeStamp &b)
149 TimeStamp operator-(const TimeStamp &b) const
155 TimeStamp &operator*=(double b)
165 TimeStamp operator*(double b) const
170 friend TimeStamp operator*(double b,const TimeStamp &t);
172 TimeStamp &operator/=(double b)
182 TimeStamp operator/(double b) const
187 ///The time ellapsed since the last call of stamp()
188 TimeStamp ellapsed() const
194 friend std::ostream& operator<<(std::ostream& os,const TimeStamp &t);
196 ///Gives back the user time of the process
197 double userTime() const
201 ///Gives back the system time of the process
202 double systemTime() const
206 ///Gives back the user time of the process' children
208 ///\note On <tt>WIN32</tt> platform this value is not calculated.
210 double cUserTime() const
214 ///Gives back the user time of the process' children
216 ///\note On <tt>WIN32</tt> platform this value is not calculated.
218 double cSystemTime() const
222 ///Gives back the real time
223 double realTime() const {return rtime;}
226 TimeStamp operator*(double b,const TimeStamp &t)
231 ///Prints the time counters
233 ///Prints the time counters in the following form:
235 /// <tt>u: XX.XXs s: XX.XXs cu: XX.XXs cs: XX.XXs real: XX.XXs</tt>
237 /// where the values are the
238 /// \li \c u: user cpu time,
239 /// \li \c s: system cpu time,
240 /// \li \c cu: user cpu time of children,
241 /// \li \c cs: system cpu time of children,
242 /// \li \c real: real time.
243 /// \relates TimeStamp
244 /// \note On <tt>WIN32</tt> platform the cummulative values are not
246 inline std::ostream& operator<<(std::ostream& os,const TimeStamp &t)
248 os << "u: " << t.userTime() <<
249 "s, s: " << t.systemTime() <<
250 "s, cu: " << t.cUserTime() <<
251 "s, cs: " << t.cSystemTime() <<
252 "s, real: " << t.realTime() << "s";
256 ///Class for measuring the cpu time and real time usage of the process
258 ///Class for measuring the cpu time and real time usage of the process.
259 ///It is quite easy-to-use, here is a short example.
261 /// #include<lemon/time_measure.h>
262 /// #include<iostream>
271 /// std::cout << t << '\n';
273 /// doSomethingElse();
274 /// std::cout << t << '\n';
281 ///The \ref Timer can also be \ref stop() "stopped" and
282 ///\ref start() "started" again, so it is possible to compute collected
285 ///\warning Depending on the operation system and its actual configuration
286 ///the time counters have a certain (10ms on a typical Linux system)
288 ///Therefore this tool is not appropriate to measure very short times.
289 ///Also, if you start and stop the timer very frequently, it could lead to
290 ///distorted results.
292 ///\note If you want to measure the running time of the execution of a certain
293 ///function, consider the usage of \ref TimeReport instead.
298 int _running; //Timer is running iff _running>0; (_running>=0 always holds)
299 TimeStamp start_time; //This is the relativ start-time if the timer
300 //is _running, the collected _running time otherwise.
302 void _reset() {if(_running) start_time.stamp(); else start_time.reset();}
307 ///\param run indicates whether or not the timer starts immediately.
309 Timer(bool run=true) :_running(run) {_reset();}
311 ///\name Control the state of the timer
312 ///Basically a Timer can be either running or stopped,
313 ///but it provides a bit finer control on the execution.
314 ///The \ref lemon::Timer "Timer" also counts the number of
315 ///\ref lemon::Timer::start() "start()" executions, and it stops
316 ///only after the same amount (or more) \ref lemon::Timer::stop()
317 ///"stop()"s. This can be useful e.g. to compute the running time
318 ///of recursive functions.
322 ///Reset and stop the time counters
324 ///This function resets and stops the time counters
332 ///Start the time counters
334 ///This function starts the time counters.
336 ///If the timer is started more than ones, it will remain running
337 ///until the same amount of \ref stop() is called.
341 if(_running) _running++;
346 start_time=t-start_time;
351 ///Stop the time counters
353 ///This function stops the time counters. If start() was executed more than
354 ///once, then the same number of stop() execution is necessary the really
364 if(_running && !--_running) {
367 start_time=t-start_time;
371 ///Halt (i.e stop immediately) the time counters
373 ///This function stops immediately the time counters, i.e. <tt>t.halt()</tt>
375 ///equivalent of the following.
377 /// while(t.running()) t.stop()
391 start_time=t-start_time;
395 ///Returns the running state of the timer
397 ///This function returns the number of stop() exections that is
398 ///necessary to really stop the timer.
399 ///For example the timer
400 ///is running if and only if the return value is \c true
401 ///(i.e. greater than
403 int running() { return _running; }
406 ///Restart the time counters
408 ///This function is a shorthand for
409 ///a reset() and a start() calls.
419 ///\name Query Functions for the ellapsed time
423 ///Gives back the ellapsed user time of the process
424 double userTime() const
426 return operator TimeStamp().userTime();
428 ///Gives back the ellapsed system time of the process
429 double systemTime() const
431 return operator TimeStamp().systemTime();
433 ///Gives back the ellapsed user time of the process' children
435 ///\note On <tt>WIN32</tt> platform this value is not calculated.
437 double cUserTime() const
439 return operator TimeStamp().cUserTime();
441 ///Gives back the ellapsed user time of the process' children
443 ///\note On <tt>WIN32</tt> platform this value is not calculated.
445 double cSystemTime() const
447 return operator TimeStamp().cSystemTime();
449 ///Gives back the ellapsed real time
450 double realTime() const
452 return operator TimeStamp().realTime();
454 ///Computes the ellapsed time
456 ///This conversion computes the ellapsed time, therefore you can print
457 ///the ellapsed time like this.
461 /// std::cout << t << '\n';
463 operator TimeStamp () const
467 return _running?t-start_time:start_time;
474 ///Same as Timer but prints a report on destruction.
476 ///Same as \ref Timer but prints a report on destruction.
477 ///This example shows its usage.
479 /// void myAlg(ListGraph &g,int n)
481 /// TimeReport tr("Running time of myAlg: ");
482 /// ... //Here comes the algorithm
488 class TimeReport : public Timer
496 ///\param title This text will be printed before the ellapsed time.
497 ///\param os The stream to print the report to.
498 ///\param run Sets whether the timer should start immediately.
499 TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true)
500 : Timer(run), _title(title), _os(os){}
501 ///Destructor that prints the ellapsed time
504 _os << _title << *this << std::endl;
508 ///'Do nothing' version of TimeReport
516 NoTimeReport(std::string,std::ostream &,bool) {}
518 NoTimeReport(std::string,std::ostream &) {}
520 NoTimeReport(std::string) {}
524 operator TimeStamp () const { return TimeStamp(); }
529 int running() { return 0; }
531 double userTime() const { return 0; }
532 double systemTime() const { return 0; }
533 double cUserTime() const { return 0; }
534 double cSystemTime() const { return 0; }
535 double realTime() const { return 0; }
538 ///Tool to measure the running time more exactly.
540 ///This function calls \c f several times and returns the average
541 ///running time. The number of the executions will be choosen in such a way
542 ///that the full real running time will be roughly between \c min_time
543 ///and <tt>2*min_time</tt>.
544 ///\param f the function object to be measured.
545 ///\param min_time the minimum total running time.
546 ///\retval num if it is not \c NULL, then the actual
547 /// number of execution of \c f will be written into <tt>*num</tt>.
548 ///\retval full_time if it is not \c NULL, then the actual
549 /// total running time will be written into <tt>*full_time</tt>.
550 ///\return The average running time of \c f.
553 TimeStamp runningTimeTest(F f,double min_time=10,unsigned int *num = NULL,
554 TimeStamp *full_time=NULL)
557 unsigned int total=0;
559 for(unsigned int tn=1;tn <= 1U<<31 && full.realTime()<=min_time; tn*=2) {
560 for(;total<tn;total++) f();
564 if(full_time) *full_time=full;
573 #endif //LEMON_TIME_MEASURE_H