COIN-OR::LEMON - Graph Library

source: lemon-1.0/lemon/time_measure.h @ 364:55111a054b2e

Last change on this file since 364:55111a054b2e was 364:55111a054b2e, checked in by Alpar Juttner <alpar@…>, 10 years ago

Add missing include to time_measure.h

File size: 14.1 KB
Line 
1/* -*- mode: C++; indent-tabs-mode: nil; -*-
2 *
3 * This file is a part of LEMON, a generic C++ optimization library.
4 *
5 * Copyright (C) 2003-2008
6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7 * (Egervary Research Group on Combinatorial Optimization, EGRES).
8 *
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.
12 *
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
15 * purpose.
16 *
17 */
18
19#ifndef LEMON_TIME_MEASURE_H
20#define LEMON_TIME_MEASURE_H
21
22///\ingroup timecount
23///\file
24///\brief Tools for measuring cpu usage
25
26#ifdef WIN32
27#define WIN32_LEAN_AND_MEAN
28#define NOMINMAX
29#include <windows.h>
30#include <cmath>
31#else
32#include <unistd.h>
33#include <sys/times.h>
34#include <sys/time.h>
35#endif
36
37#include <string>
38#include <fstream>
39#include <iostream>
40
41namespace lemon {
42
43  /// \addtogroup timecount
44  /// @{
45
46  /// A class to store (cpu)time instances.
47
48  /// This class stores five time values.
49  /// - a real time
50  /// - a user cpu time
51  /// - a system cpu time
52  /// - a user cpu time of children
53  /// - a system cpu time of children
54  ///
55  /// TimeStamp's can be added to or substracted from each other and
56  /// they can be pushed to a stream.
57  ///
58  /// In most cases, perhaps the \ref Timer or the \ref TimeReport
59  /// class is what you want to use instead.
60
61  class TimeStamp
62  {
63    double utime;
64    double stime;
65    double cutime;
66    double cstime;
67    double rtime;
68
69    void _reset() {
70      utime = stime = cutime = cstime = rtime = 0;
71    }
72
73  public:
74
75    ///Read the current time values of the process
76    void stamp()
77    {
78#ifndef WIN32
79      timeval tv;
80      gettimeofday(&tv, 0);
81      rtime=tv.tv_sec+double(tv.tv_usec)/1e6;
82
83      tms ts;
84      double tck=sysconf(_SC_CLK_TCK);
85      times(&ts);
86      utime=ts.tms_utime/tck;
87      stime=ts.tms_stime/tck;
88      cutime=ts.tms_cutime/tck;
89      cstime=ts.tms_cstime/tck;
90#else
91      static const double ch = 4294967296.0e-7;
92      static const double cl = 1.0e-7;
93
94      FILETIME system;
95      GetSystemTimeAsFileTime(&system);
96      rtime = ch * system.dwHighDateTime + cl * system.dwLowDateTime;
97
98      FILETIME create, exit, kernel, user;
99      if (GetProcessTimes(GetCurrentProcess(),&create, &exit, &kernel, &user)) {
100        utime = ch * user.dwHighDateTime + cl * user.dwLowDateTime;
101        stime = ch * kernel.dwHighDateTime + cl * kernel.dwLowDateTime;
102        cutime = 0;
103        cstime = 0;
104      } else {
105        rtime = 0;
106        utime = 0;
107        stime = 0;
108        cutime = 0;
109        cstime = 0;
110      }
111#endif
112    }
113
114    /// Constructor initializing with zero
115    TimeStamp()
116    { _reset(); }
117    ///Constructor initializing with the current time values of the process
118    TimeStamp(void *) { stamp();}
119
120    ///Set every time value to zero
121    TimeStamp &reset() {_reset();return *this;}
122
123    ///\e
124    TimeStamp &operator+=(const TimeStamp &b)
125    {
126      utime+=b.utime;
127      stime+=b.stime;
128      cutime+=b.cutime;
129      cstime+=b.cstime;
130      rtime+=b.rtime;
131      return *this;
132    }
133    ///\e
134    TimeStamp operator+(const TimeStamp &b) const
135    {
136      TimeStamp t(*this);
137      return t+=b;
138    }
139    ///\e
140    TimeStamp &operator-=(const TimeStamp &b)
141    {
142      utime-=b.utime;
143      stime-=b.stime;
144      cutime-=b.cutime;
145      cstime-=b.cstime;
146      rtime-=b.rtime;
147      return *this;
148    }
149    ///\e
150    TimeStamp operator-(const TimeStamp &b) const
151    {
152      TimeStamp t(*this);
153      return t-=b;
154    }
155    ///\e
156    TimeStamp &operator*=(double b)
157    {
158      utime*=b;
159      stime*=b;
160      cutime*=b;
161      cstime*=b;
162      rtime*=b;
163      return *this;
164    }
165    ///\e
166    TimeStamp operator*(double b) const
167    {
168      TimeStamp t(*this);
169      return t*=b;
170    }
171    friend TimeStamp operator*(double b,const TimeStamp &t);
172    ///\e
173    TimeStamp &operator/=(double b)
174    {
175      utime/=b;
176      stime/=b;
177      cutime/=b;
178      cstime/=b;
179      rtime/=b;
180      return *this;
181    }
182    ///\e
183    TimeStamp operator/(double b) const
184    {
185      TimeStamp t(*this);
186      return t/=b;
187    }
188    ///The time ellapsed since the last call of stamp()
189    TimeStamp ellapsed() const
190    {
191      TimeStamp t(NULL);
192      return t-*this;
193    }
194
195    friend std::ostream& operator<<(std::ostream& os,const TimeStamp &t);
196
197    ///Gives back the user time of the process
198    double userTime() const
199    {
200      return utime;
201    }
202    ///Gives back the system time of the process
203    double systemTime() const
204    {
205      return stime;
206    }
207    ///Gives back the user time of the process' children
208
209    ///\note On <tt>WIN32</tt> platform this value is not calculated.
210    ///
211    double cUserTime() const
212    {
213      return cutime;
214    }
215    ///Gives back the user time of the process' children
216
217    ///\note On <tt>WIN32</tt> platform this value is not calculated.
218    ///
219    double cSystemTime() const
220    {
221      return cstime;
222    }
223    ///Gives back the real time
224    double realTime() const {return rtime;}
225  };
226
227  TimeStamp operator*(double b,const TimeStamp &t)
228  {
229    return t*b;
230  }
231
232  ///Prints the time counters
233
234  ///Prints the time counters in the following form:
235  ///
236  /// <tt>u: XX.XXs s: XX.XXs cu: XX.XXs cs: XX.XXs real: XX.XXs</tt>
237  ///
238  /// where the values are the
239  /// \li \c u: user cpu time,
240  /// \li \c s: system cpu time,
241  /// \li \c cu: user cpu time of children,
242  /// \li \c cs: system cpu time of children,
243  /// \li \c real: real time.
244  /// \relates TimeStamp
245  /// \note On <tt>WIN32</tt> platform the cummulative values are not
246  /// calculated.
247  inline std::ostream& operator<<(std::ostream& os,const TimeStamp &t)
248  {
249    os << "u: " << t.userTime() <<
250      "s, s: " << t.systemTime() <<
251      "s, cu: " << t.cUserTime() <<
252      "s, cs: " << t.cSystemTime() <<
253      "s, real: " << t.realTime() << "s";
254    return os;
255  }
256
257  ///Class for measuring the cpu time and real time usage of the process
258
259  ///Class for measuring the cpu time and real time usage of the process.
260  ///It is quite easy-to-use, here is a short example.
261  ///\code
262  /// #include<lemon/time_measure.h>
263  /// #include<iostream>
264  ///
265  /// int main()
266  /// {
267  ///
268  ///   ...
269  ///
270  ///   Timer t;
271  ///   doSomething();
272  ///   std::cout << t << '\n';
273  ///   t.restart();
274  ///   doSomethingElse();
275  ///   std::cout << t << '\n';
276  ///
277  ///   ...
278  ///
279  /// }
280  ///\endcode
281  ///
282  ///The \ref Timer can also be \ref stop() "stopped" and
283  ///\ref start() "started" again, so it is possible to compute collected
284  ///running times.
285  ///
286  ///\warning Depending on the operation system and its actual configuration
287  ///the time counters have a certain (10ms on a typical Linux system)
288  ///granularity.
289  ///Therefore this tool is not appropriate to measure very short times.
290  ///Also, if you start and stop the timer very frequently, it could lead to
291  ///distorted results.
292  ///
293  ///\note If you want to measure the running time of the execution of a certain
294  ///function, consider the usage of \ref TimeReport instead.
295  ///
296  ///\sa TimeReport
297  class Timer
298  {
299    int _running; //Timer is running iff _running>0; (_running>=0 always holds)
300    TimeStamp start_time; //This is the relativ start-time if the timer
301                          //is _running, the collected _running time otherwise.
302
303    void _reset() {if(_running) start_time.stamp(); else start_time.reset();}
304
305  public:
306    ///Constructor.
307
308    ///\param run indicates whether or not the timer starts immediately.
309    ///
310    Timer(bool run=true) :_running(run) {_reset();}
311
312    ///\name Control the state of the timer
313    ///Basically a Timer can be either running or stopped,
314    ///but it provides a bit finer control on the execution.
315    ///The \ref lemon::Timer "Timer" also counts the number of
316    ///\ref lemon::Timer::start() "start()" executions, and it stops
317    ///only after the same amount (or more) \ref lemon::Timer::stop()
318    ///"stop()"s. This can be useful e.g. to compute the running time
319    ///of recursive functions.
320
321    ///@{
322
323    ///Reset and stop the time counters
324
325    ///This function resets and stops the time counters
326    ///\sa restart()
327    void reset()
328    {
329      _running=0;
330      _reset();
331    }
332
333    ///Start the time counters
334
335    ///This function starts the time counters.
336    ///
337    ///If the timer is started more than ones, it will remain running
338    ///until the same amount of \ref stop() is called.
339    ///\sa stop()
340    void start()
341    {
342      if(_running) _running++;
343      else {
344        _running=1;
345        TimeStamp t;
346        t.stamp();
347        start_time=t-start_time;
348      }
349    }
350
351
352    ///Stop the time counters
353
354    ///This function stops the time counters. If start() was executed more than
355    ///once, then the same number of stop() execution is necessary the really
356    ///stop the timer.
357    ///
358    ///\sa halt()
359    ///\sa start()
360    ///\sa restart()
361    ///\sa reset()
362
363    void stop()
364    {
365      if(_running && !--_running) {
366        TimeStamp t;
367        t.stamp();
368        start_time=t-start_time;
369      }
370    }
371
372    ///Halt (i.e stop immediately) the time counters
373
374    ///This function stops immediately the time counters, i.e. <tt>t.halt()</tt>
375    ///is a faster
376    ///equivalent of the following.
377    ///\code
378    ///  while(t.running()) t.stop()
379    ///\endcode
380    ///
381    ///
382    ///\sa stop()
383    ///\sa restart()
384    ///\sa reset()
385
386    void halt()
387    {
388      if(_running) {
389        _running=0;
390        TimeStamp t;
391        t.stamp();
392        start_time=t-start_time;
393      }
394    }
395
396    ///Returns the running state of the timer
397
398    ///This function returns the number of stop() exections that is
399    ///necessary to really stop the timer.
400    ///For example the timer
401    ///is running if and only if the return value is \c true
402    ///(i.e. greater than
403    ///zero).
404    int running()  { return _running; }
405
406
407    ///Restart the time counters
408
409    ///This function is a shorthand for
410    ///a reset() and a start() calls.
411    ///
412    void restart()
413    {
414      reset();
415      start();
416    }
417
418    ///@}
419
420    ///\name Query Functions for the ellapsed time
421
422    ///@{
423
424    ///Gives back the ellapsed user time of the process
425    double userTime() const
426    {
427      return operator TimeStamp().userTime();
428    }
429    ///Gives back the ellapsed system time of the process
430    double systemTime() const
431    {
432      return operator TimeStamp().systemTime();
433    }
434    ///Gives back the ellapsed user time of the process' children
435
436    ///\note On <tt>WIN32</tt> platform this value is not calculated.
437    ///
438    double cUserTime() const
439    {
440      return operator TimeStamp().cUserTime();
441    }
442    ///Gives back the ellapsed user time of the process' children
443
444    ///\note On <tt>WIN32</tt> platform this value is not calculated.
445    ///
446    double cSystemTime() const
447    {
448      return operator TimeStamp().cSystemTime();
449    }
450    ///Gives back the ellapsed real time
451    double realTime() const
452    {
453      return operator TimeStamp().realTime();
454    }
455    ///Computes the ellapsed time
456
457    ///This conversion computes the ellapsed time, therefore you can print
458    ///the ellapsed time like this.
459    ///\code
460    ///  Timer t;
461    ///  doSomething();
462    ///  std::cout << t << '\n';
463    ///\endcode
464    operator TimeStamp () const
465    {
466      TimeStamp t;
467      t.stamp();
468      return _running?t-start_time:start_time;
469    }
470
471
472    ///@}
473  };
474
475  ///Same as Timer but prints a report on destruction.
476
477  ///Same as \ref Timer but prints a report on destruction.
478  ///This example shows its usage.
479  ///\code
480  ///  void myAlg(ListGraph &g,int n)
481  ///  {
482  ///    TimeReport tr("Running time of myAlg: ");
483  ///    ... //Here comes the algorithm
484  ///  }
485  ///\endcode
486  ///
487  ///\sa Timer
488  ///\sa NoTimeReport
489  class TimeReport : public Timer
490  {
491    std::string _title;
492    std::ostream &_os;
493  public:
494    ///Constructor
495
496    ///Constructor.
497    ///\param title This text will be printed before the ellapsed time.
498    ///\param os The stream to print the report to.
499    ///\param run Sets whether the timer should start immediately.
500    TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true)
501      : Timer(run), _title(title), _os(os){}
502    ///Destructor that prints the ellapsed time
503    ~TimeReport()
504    {
505      _os << _title << *this << std::endl;
506    }
507  };
508
509  ///'Do nothing' version of TimeReport
510
511  ///\sa TimeReport
512  ///
513  class NoTimeReport
514  {
515  public:
516    ///\e
517    NoTimeReport(std::string,std::ostream &,bool) {}
518    ///\e
519    NoTimeReport(std::string,std::ostream &) {}
520    ///\e
521    NoTimeReport(std::string) {}
522    ///\e Do nothing.
523    ~NoTimeReport() {}
524
525    operator TimeStamp () const { return TimeStamp(); }
526    void reset() {}
527    void start() {}
528    void stop() {}
529    void halt() {}
530    int running() { return 0; }
531    void restart() {}
532    double userTime() const { return 0; }
533    double systemTime() const { return 0; }
534    double cUserTime() const { return 0; }
535    double cSystemTime() const { return 0; }
536    double realTime() const { return 0; }
537  };
538
539  ///Tool to measure the running time more exactly.
540
541  ///This function calls \c f several times and returns the average
542  ///running time. The number of the executions will be choosen in such a way
543  ///that the full real running time will be roughly between \c min_time
544  ///and <tt>2*min_time</tt>.
545  ///\param f the function object to be measured.
546  ///\param min_time the minimum total running time.
547  ///\retval num if it is not \c NULL, then the actual
548  ///        number of execution of \c f will be written into <tt>*num</tt>.
549  ///\retval full_time if it is not \c NULL, then the actual
550  ///        total running time will be written into <tt>*full_time</tt>.
551  ///\return The average running time of \c f.
552
553  template<class F>
554  TimeStamp runningTimeTest(F f,double min_time=10,unsigned int *num = NULL,
555                            TimeStamp *full_time=NULL)
556  {
557    TimeStamp full;
558    unsigned int total=0;
559    Timer t;
560    for(unsigned int tn=1;tn <= 1U<<31 && full.realTime()<=min_time; tn*=2) {
561      for(;total<tn;total++) f();
562      full=t;
563    }
564    if(num) *num=total;
565    if(full_time) *full_time=full;
566    return full/total;
567  }
568
569  /// @}
570
571
572} //namespace lemon
573
574#endif //LEMON_TIME_MEASURE_H
Note: See TracBrowser for help on using the repository browser.