COIN-OR::LEMON - Graph Library

source: lemon-0.x/lemon/time_measure.h @ 1435:8e85e6bbefdf

Last change on this file since 1435:8e85e6bbefdf was 1435:8e85e6bbefdf, checked in by Akos Ladanyi, 14 years ago

trunk/src/* move to trunk/

File size: 6.3 KB
Line 
1/* -*- C++ -*-
2 * lemon/time_measure.h - Part of LEMON, a generic C++ optimization library
3 *
4 * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
5 * (Egervary Research Group on Combinatorial Optimization, EGRES).
6 *
7 * Permission to use, modify and distribute this software is granted
8 * provided that this copyright notice appears in all copies. For
9 * precise terms see the accompanying LICENSE file.
10 *
11 * This software is provided "AS IS" with no warranty of any kind,
12 * express or implied, and with no claim as to its suitability for any
13 * purpose.
14 *
15 */
16
17#ifndef LEMON_TIME_MEASURE_H
18#define LEMON_TIME_MEASURE_H
19
20///\ingroup misc
21///\file
22///\brief Tools for measuring cpu usage
23
24#include <sys/time.h>
25#include <sys/times.h>
26#include <fstream>
27#include <iostream>
28#include <unistd.h>
29
30namespace lemon {
31
32  /// \addtogroup misc
33  /// @{
34
35  /// A class to store (cpu)time instances.
36
37  /// This class stores five time values.
38  /// - a real time
39  /// - a user cpu time
40  /// - a system cpu time
41  /// - a user cpu time of children
42  /// - a system cpu time of children
43  ///
44  /// TimeStamp's can be added to or substracted from each other and
45  /// they can be pushed to a stream.
46  ///
47  /// In most cases, perhaps \ref Timer class is what you want to use instead.
48  ///
49  ///\author Alpar Juttner
50
51  class TimeStamp
52  {
53    tms ts;
54    double real_time;
55 
56  public:
57
58    tms &getTms() {return ts;}
59    const tms &getTms() const {return ts;}
60    ///Read the current time values of the process
61    void stamp()
62    {
63      timeval tv;
64      times(&ts);
65      gettimeofday(&tv, 0);real_time=tv.tv_sec+double(tv.tv_usec)/1e6;
66    }
67 
68    /// Constructor initializing with zero
69    TimeStamp()
70    { ts.tms_utime=ts.tms_stime=ts.tms_cutime=ts.tms_cstime=0; real_time=0;}
71    ///Constructor initializing with the current time values of the process
72    TimeStamp(void *) { stamp();}
73 
74    ///\e
75    TimeStamp &operator+=(const TimeStamp &b)
76    {
77      ts.tms_utime+=b.ts.tms_utime;
78      ts.tms_stime+=b.ts.tms_stime;
79      ts.tms_cutime+=b.ts.tms_cutime;
80      ts.tms_cstime+=b.ts.tms_cstime;
81      real_time+=b.real_time;
82      return *this;
83    }
84    ///\e
85    TimeStamp operator+(const TimeStamp &b) const
86    {
87      TimeStamp t(*this);
88      return t+=b;
89    }
90    ///\e
91    TimeStamp &operator-=(const TimeStamp &b)
92    {
93      ts.tms_utime-=b.ts.tms_utime;
94      ts.tms_stime-=b.ts.tms_stime;
95      ts.tms_cutime-=b.ts.tms_cutime;
96      ts.tms_cstime-=b.ts.tms_cstime;
97      real_time-=b.real_time;
98      return *this;
99    }
100    ///\e
101    TimeStamp operator-(const TimeStamp &b) const
102    {
103      TimeStamp t(*this);
104      return t-=b;
105    }
106    ///The time ellapsed since the last call of stamp()
107    TimeStamp ellapsed() const
108    {
109      TimeStamp t(NULL);
110      return t-*this;
111    }
112 
113    friend std::ostream& operator<<(std::ostream& os,const TimeStamp &t);
114 
115    ///Gives back the user time of the process
116    double getUserTime() const
117    {
118      return double(ts.tms_utime)/sysconf(_SC_CLK_TCK);
119    }
120    ///Gives back the system time of the process
121    double getSystemTime() const
122    {
123      return double(ts.tms_stime)/sysconf(_SC_CLK_TCK);
124    }
125    ///Gives back the user time of the process' children
126    double getCUserTime() const
127    {
128      return double(ts.tms_cutime)/sysconf(_SC_CLK_TCK);
129    }
130    ///Gives back the user time of the process' children
131    double getCSystemTime() const
132    {
133      return double(ts.tms_cstime)/sysconf(_SC_CLK_TCK);
134    }
135    ///Gives back the real time of the process
136    double getRealTime() const {return real_time;}
137  };
138
139  ///Class measuring the cpu time and real time usage of the process
140
141  ///Class measuring the cpu time and real time usage of the process.
142  ///It is quite easy-to-use, here is a short example.
143  ///\code
144  ///#include<lemon/time_measure.h>
145  ///#include<iostream>
146  ///
147  ///int main()
148  ///{
149  ///
150  ///  ...
151  ///
152  ///  Timer T;
153  ///  doSomething();
154  ///  std::cout << T << '\n';
155  ///  T.reset();
156  ///  doSomethingElse();
157  ///  std::cout << T << '\n';
158  ///
159  ///  ...
160  ///
161  ///}
162  ///\endcode
163  ///
164  ///\todo This shouldn't be Unix (Linux) specific.
165  ///
166  ///\author Alpar Juttner
167  class Timer
168  {
169    TimeStamp start_time;
170
171    void _reset() {start_time.stamp();}
172 
173  public:
174    ///Constructor. It starts with zero time counters
175    Timer() {_reset();}
176
177    ///Computes the ellapsed time
178
179    ///This conversion computes the ellapsed time
180    ///since the construction of \c t or since
181    ///the last \c t.reset().
182    operator TimeStamp () const
183    {
184      TimeStamp t;
185      t.stamp();
186      return t-start_time;
187    }
188
189    ///Resets the time counters
190
191    ///Resets the time counters
192    ///
193    void reset()
194    {
195      _reset();
196    }
197
198
199    ///Gives back the ellapsed user time of the process
200    double getUserTime() const
201    {
202      return operator TimeStamp().getUserTime();
203    }
204    ///Gives back the ellapsed system time of the process
205    double getSystemTime() const
206    {
207      return operator TimeStamp().getSystemTime();
208    }
209    ///Gives back the ellapsed user time of the process' children
210    double getCUserTime() const
211    {
212      return operator TimeStamp().getCUserTime();
213    }
214    ///Gives back the ellapsed user time of the process' children
215    double getCSystemTime() const
216    {
217      return operator TimeStamp().getCSystemTime();
218    }
219    ///Gives back the ellapsed real time of the process
220    double getRealTime() const
221    {
222      return operator TimeStamp().getRealTime();
223    }
224
225  };
226
227  ///Prints the time counters
228
229  ///Prints the time counters in the following form:
230  ///
231  /// <tt>u: XX.XXs s: XX.XXs cu: XX.XXs cs: XX.XXs real: XX.XXs</tt>
232  ///
233  /// where the values are the
234  /// \li \c u: user cpu time,
235  /// \li \c s: system cpu time,
236  /// \li \c cu: user cpu time of children,
237  /// \li \c cs: system cpu time of children,
238  /// \li \c real: real time.
239  /// \relates TimeStamp
240  inline std::ostream& operator<<(std::ostream& os,const TimeStamp &t)
241  {
242    long cls = sysconf(_SC_CLK_TCK);
243    os << "u: " << double(t.getTms().tms_utime)/cls <<
244      "s, s: " << double(t.getTms().tms_stime)/cls <<
245      "s, cu: " << double(t.getTms().tms_cutime)/cls <<
246      "s, cs: " << double(t.getTms().tms_cstime)/cls <<
247      "s, real: " << t.getRealTime() << "s";
248    return os;
249  }
250
251  /// @} 
252
253} //namespace lemon
254
255#endif //LEMON_TIME_MEASURE_H
Note: See TracBrowser for help on using the repository browser.