Logo ROOT  
Reference Guide
TStopwatch.cxx
Go to the documentation of this file.
1 // @(#)root/base:$Id$
2 // Author: Fons Rademakers 11/10/95
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 /** \class TStopwatch
13 \ingroup Base
14 
15 Stopwatch class. This class returns the real and cpu time between
16 the start and stop events.
17 */
18 
19 #include "TStopwatch.h"
20 #include "TTimeStamp.h"
21 #include "TString.h"
22 
23 #if defined(R__UNIX)
24 # include <sys/times.h>
25 # include <unistd.h>
26 static Double_t gTicks = 0;
27 #elif defined(WIN32)
28 # include "TError.h"
29 const Double_t gTicks = 1.0e-7;
30 # include "Windows4Root.h"
31 #endif
32 
33 
35 
36 ////////////////////////////////////////////////////////////////////////////////
37 /// Create a stopwatch and start it.
38 
40 {
41 #ifdef R__UNIX
42  if (gTicks <= 0.0)
43  gTicks = (Double_t)sysconf(_SC_CLK_TCK);
44 #endif
45 
46  fStopRealTime = 0;
47  fStopCpuTime = 0;
48 
49  Start();
50 }
51 
52 ////////////////////////////////////////////////////////////////////////////////
53 /// Start the stopwatch. If reset is kTRUE reset the stopwatch before
54 /// starting it (including the stopwatch counter).
55 /// Use kFALSE to continue timing after a Stop() without
56 /// resetting the stopwatch.
57 
59 {
60  if (reset) {
62  fTotalCpuTime = 0;
63  fTotalRealTime = 0;
64  fCounter = 0;
65  }
66  if (fState != kRunning) {
69  }
70  fState = kRunning;
71  fCounter++;
72 }
73 
74 ////////////////////////////////////////////////////////////////////////////////
75 /// Stop the stopwatch.
76 
78 {
81 
82  if (fState == kRunning) {
85  }
86  fState = kStopped;
87 }
88 
89 ////////////////////////////////////////////////////////////////////////////////
90 /// Resume a stopped stopwatch. The stopwatch continues counting from the last
91 /// Start() onwards (this is like the laptimer function).
92 
94 {
95  if (fState == kUndefined)
96  Error("Continue", "stopwatch not started");
97 
98  if (fState == kStopped) {
101  }
102 
103  fState = kRunning;
104 }
105 
106 ////////////////////////////////////////////////////////////////////////////////
107 /// Stop the stopwatch (if it is running) and return the realtime (in
108 /// seconds) passed between the start and stop events.
109 
111 {
112  if (fState == kUndefined)
113  Error("RealTime", "stopwatch not started");
114 
115  if (fState == kRunning)
116  Stop();
117 
118  return fTotalRealTime;
119 }
120 
121 ////////////////////////////////////////////////////////////////////////////////
122 /// Stop the stopwatch (if it is running) and return the cputime (in
123 /// seconds) passed between the start and stop events.
124 
126 {
127  if (fState == kUndefined)
128  Error("CpuTime", "stopwatch not started");
129 
130  if (fState == kRunning)
131  Stop();
132 
133  return fTotalCpuTime;
134 }
135 
136 ////////////////////////////////////////////////////////////////////////////////
137 /// Private static method returning system realtime.
138 
140 {
141 #if defined(R__UNIX)
142  return TTimeStamp();
143 #elif defined(WIN32)
144  union {
145  FILETIME ftFileTime;
146  __int64 ftInt64;
147  } ftRealTime; // time the process has spent in kernel mode
148  SYSTEMTIME st;
149  GetSystemTime(&st);
150  SystemTimeToFileTime(&st,&ftRealTime.ftFileTime);
151  return (Double_t)ftRealTime.ftInt64 * gTicks;
152 #endif
153 }
154 
155 ////////////////////////////////////////////////////////////////////////////////
156 /// Private static method returning system CPU time.
157 
159 {
160 #if defined(R__UNIX)
161  struct tms cpt;
162  times(&cpt);
163  return (Double_t)(cpt.tms_utime+cpt.tms_stime) / gTicks;
164 #elif defined(WIN32)
165 
166  OSVERSIONINFO OsVersionInfo;
167 
168  // Value Platform
169  //----------------------------------------------------
170  // VER_PLATFORM_WIN32s Win32s on Windows 3.1
171  // VER_PLATFORM_WIN32_WINDOWS Win32 on Windows 95
172  // VER_PLATFORM_WIN32_NT Windows NT
173  //
174  OsVersionInfo.dwOSVersionInfoSize=sizeof(OSVERSIONINFO);
175  GetVersionEx(&OsVersionInfo);
176  if (OsVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) {
177  DWORD ret;
178  FILETIME ftCreate, // when the process was created
179  ftExit; // when the process exited
180 
181  union {
182  FILETIME ftFileTime;
183  __int64 ftInt64;
184  } ftKernel; // time the process has spent in kernel mode
185 
186  union {
187  FILETIME ftFileTime;
188  __int64 ftInt64;
189  } ftUser; // time the process has spent in user mode
190 
191  HANDLE hThread = GetCurrentThread();
192  ret = GetThreadTimes (hThread, &ftCreate, &ftExit,
193  &ftKernel.ftFileTime,
194  &ftUser.ftFileTime);
195  if (ret != TRUE) {
196  ret = GetLastError ();
197  ::Error ("GetCPUTime", " Error on GetProcessTimes 0x%lx", (int)ret);
198  }
199 
200  // Process times are returned in a 64-bit structure, as the number of
201  // 100 nanosecond ticks since 1 January 1601. User mode and kernel mode
202  // times for this process are in separate 64-bit structures.
203  // To convert to floating point seconds, we will:
204  //
205  // Convert sum of high 32-bit quantities to 64-bit int
206 
207  return (Double_t) (ftKernel.ftInt64 + ftUser.ftInt64) * gTicks;
208  } else
209  return GetRealTime();
210 #endif
211 }
212 
213 ////////////////////////////////////////////////////////////////////////////////
214 /// Print the real and cpu time passed between the start and stop events.
215 /// and the number of times (slices) this TStopwatch was called
216 /// (if this number > 1). If opt="m" print out realtime in milli second
217 /// precision. If opt="u" print out realtime in micro second precision.
218 
219 void TStopwatch::Print(Option_t *opt) const
220 {
221  Double_t realt = const_cast<TStopwatch*>(this)->RealTime();
222  Double_t cput = const_cast<TStopwatch*>(this)->CpuTime();
223 
224  Int_t hours = Int_t(realt / 3600);
225  realt -= hours * 3600;
226  Int_t min = Int_t(realt / 60);
227  realt -= min * 60;
228  Int_t sec = Int_t(realt);
229 
230  if (realt < 0) realt = 0;
231  if (cput < 0) cput = 0;
232 
233  if (opt && *opt == 'm') {
234  if (Counter() > 1) {
235  Printf("Real time %d:%02d:%06.3f, CP time %.3f, %d slices", hours, min, realt, cput, Counter());
236  } else {
237  Printf("Real time %d:%02d:%06.3f, CP time %.3f", hours, min, realt, cput);
238  }
239  } else if (opt && *opt == 'u') {
240  if (Counter() > 1) {
241  Printf("Real time %d:%02d:%09.6f, CP time %.3f, %d slices", hours, min, realt, cput, Counter());
242  } else {
243  Printf("Real time %d:%02d:%09.6f, CP time %.3f", hours, min, realt, cput);
244  }
245  } else {
246  if (Counter() > 1) {
247  Printf("Real time %d:%02d:%02d, CP time %.3f, %d slices", hours, min, sec, cput, Counter());
248  } else {
249  Printf("Real time %d:%02d:%02d, CP time %.3f", hours, min, sec, cput);
250  }
251  }
252 }
Windows4Root.h
TStopwatch::Continue
void Continue()
Resume a stopped stopwatch.
Definition: TStopwatch.cxx:93
TTimeStamp.h
gTicks
const Double_t gTicks
Definition: TWinNTSystem.cxx:4378
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
TStopwatch.h
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:890
TStopwatch::fTotalCpuTime
Double_t fTotalCpuTime
Definition: TStopwatch.h:43
TStopwatch::fStopRealTime
Double_t fStopRealTime
Definition: TStopwatch.h:40
TStopwatch::kStopped
@ kStopped
Definition: TStopwatch.h:43
Int_t
int Int_t
Definition: RtypesCore.h:45
TStopwatch::Counter
Int_t Counter() const
Definition: TStopwatch.h:56
TStopwatch::fStopCpuTime
Double_t fStopCpuTime
Definition: TStopwatch.h:42
TString.h
bool
TStopwatch::fStartRealTime
Double_t fStartRealTime
Definition: TStopwatch.h:39
TStopwatch::RealTime
Double_t RealTime()
Stop the stopwatch (if it is running) and return the realtime (in seconds) passed between the start a...
Definition: TStopwatch.cxx:110
TStopwatch::Print
void Print(Option_t *option="") const
Print the real and cpu time passed between the start and stop events.
Definition: TStopwatch.cxx:219
TStopwatch::fState
EState fState
Definition: TStopwatch.h:45
Option_t
const typedef char Option_t
Definition: RtypesCore.h:66
TStopwatch::fStartCpuTime
Double_t fStartCpuTime
Definition: TStopwatch.h:41
TStopwatch::Start
void Start(Bool_t reset=kTRUE)
Start the stopwatch.
Definition: TStopwatch.cxx:58
TStopwatch::CpuTime
Double_t CpuTime()
Stop the stopwatch (if it is running) and return the cputime (in seconds) passed between the start an...
Definition: TStopwatch.cxx:125
Printf
void Printf(const char *fmt,...)
TStopwatch::fTotalRealTime
Double_t fTotalRealTime
Definition: TStopwatch.h:44
Double_t
double Double_t
Definition: RtypesCore.h:59
TStopwatch
Definition: TStopwatch.h:28
TStopwatch::kRunning
@ kRunning
Definition: TStopwatch.h:43
TStopwatch::TStopwatch
TStopwatch()
Create a stopwatch and start it.
Definition: TStopwatch.cxx:39
TStopwatch::fCounter
Int_t fCounter
Definition: TStopwatch.h:46
TStopwatch::kUndefined
@ kUndefined
Definition: TStopwatch.h:43
TTimeStamp
Definition: TTimeStamp.h:71
TStopwatch::Stop
void Stop()
Stop the stopwatch.
Definition: TStopwatch.cxx:77
TStopwatch::GetRealTime
static Double_t GetRealTime()
Private static method returning system realtime.
Definition: TStopwatch.cxx:139
TRUE
#define TRUE
Definition: mesh.c:42
int
TError.h
TStopwatch::GetCPUTime
static Double_t GetCPUTime()
Private static method returning system CPU time.
Definition: TStopwatch.cxx:158