Line data Source code
1 : /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 : Copyright (c) 2012-2023 The plumed team
3 : (see the PEOPLE file at the root of the distribution for a list of names)
4 :
5 : See http://www.plumed.org for more information.
6 :
7 : This file is part of plumed, version 2.
8 :
9 : plumed is free software: you can redistribute it and/or modify
10 : it under the terms of the GNU Lesser General Public License as published by
11 : the Free Software Foundation, either version 3 of the License, or
12 : (at your option) any later version.
13 :
14 : plumed is distributed in the hope that it will be useful,
15 : but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : GNU Lesser General Public License for more details.
18 :
19 : You should have received a copy of the GNU Lesser General Public License
20 : along with plumed. If not, see <http://www.gnu.org/licenses/>.
21 : +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
22 : #ifndef __PLUMED_tools_Stopwatch_h
23 : #define __PLUMED_tools_Stopwatch_h
24 :
25 : #include "Exception.h"
26 : #include "Tools.h"
27 : #include <string>
28 : #include <iosfwd>
29 : #include <chrono>
30 :
31 : namespace PLMD {
32 :
33 : /**
34 : \ingroup TOOLBOX
35 : Class implementing stopwatch to time execution.
36 :
37 : Each instance of this class is a container which
38 : can keep track of several named stopwatches at
39 : the same time. Access to the stopwatches
40 : is obtained using start(), stop(), pause() methods,
41 : giving as a parameter the name of the specific stopwatch.
42 : Also an empty string can be used (un-named stopwatch).
43 : Finally, all the times can be logged using << operator
44 :
45 : \verbatim
46 : #include "Stopwatch.h"
47 :
48 : int main(){
49 : Stopwatch sw;
50 : sw.start();
51 :
52 : sw.start("initialization");
53 : // do initialization ...
54 : sw.stop("initialization");
55 :
56 : for(int i=0;i<100;i++){
57 : sw.start("loop");
58 : // do calculation
59 : sw.stop("loop");
60 : }
61 :
62 : sw.stop();
63 : return 0;
64 : }
65 :
66 : \endverbatim
67 :
68 : Using pause a stopwatch can be put on hold until
69 : the next start:
70 :
71 : \verbatim
72 : #include "Stopwatch.h"
73 :
74 : int main(){
75 : Stopwatch sw;
76 : sw.start();
77 :
78 : sw.start("initialization");
79 : // do initialization ...
80 : sw.stop("initialization");
81 :
82 : for(int i=0;i<100;i++){
83 : sw.start("loop");
84 : // do calculation
85 : sw.pause("loop");
86 : // here goes something that we do not want to include
87 : sw.start("loop");
88 : // do calculation
89 : sw.stop("loop");
90 : }
91 :
92 : sw.stop();
93 : return 0;
94 : }
95 :
96 : \endverbatim
97 :
98 : Notice that as of PLUMED 2.5 it is possible to use a slightly modified
99 : interface that allow for exception safety. In practice,
100 : one can replace a pair of calls to Stopwatch::start() and Stopwatch::stop()
101 : with a single call to Stopwatch::startStop(). This call will return an object
102 : that, when goes out of scope, will stop the timer.
103 :
104 : \notice The exception safety interace is highly recommended since it allows
105 : to make sure that stopwatches are started and stopped consistently.
106 :
107 : For instance the following
108 : code
109 : \verbatim
110 : {
111 : sw.start("A");
112 : // any code
113 : sw.stop("A");
114 : }
115 : \endverbatim
116 : can be replaced with
117 : \verbatim
118 : {
119 : auto sww=sw.startStop("A");
120 : // any code
121 :
122 : // stopwatch is stopped when sww goes out of scope
123 : }
124 : \endverbatim
125 : Similarly, Stopwatch::startPause() can be used to replace a pair of
126 : Stopwatch::start() and Stopwatch::pause().
127 :
128 : The older syntax (explicitly calling `Stopwatch::start()` and `Stopwatch::pause()`) is still
129 : allowed for backward compatibility.
130 :
131 : Notice that the returned object is of type `Stopwatch::Handler`.
132 : You might be willing to explicitly declare a `Stopwatch::Handler` (instead of using `auto`)
133 : when you want to conditionally start the stopwatch. For instance:
134 : \verbatim
135 : {
136 : Stopwatch::Handler handler;
137 : if(you_want_to_time_this) handler=sw.startStop();
138 : ... do something ...
139 : }
140 : // in case it was started, the stopwatch will stop here, at the end of the block
141 : // in case it was not started, nothing will happen
142 : \endverbatim
143 :
144 : A `Stopwatch::Handler` can not be copied but it can be moved (it behaves like a unique_ptr).
145 : Moving it explicitly allows one to transfer it to another `Stopwatch::Handler` with a different scope.
146 : For instance, in case you want to conditionally stop the stopwatch you might use something like this:
147 : \verbatim
148 : {
149 : Stopwatch::Handler handler;
150 : if(you_want_to_time_this) handler=sw.startStop();
151 : ... do something ...
152 : if(you_want_to_stop_here) auto h2=std::move(handler);
153 : // the previous instruction moves handler to h2 that is then destroyed, stopping the watch
154 : // notice that if the stop was not started it will not stop.
155 : ... do something else ...
156 : }
157 : // in case it is running, the stopwatch will stop here, at the end of the block
158 : \endverbatim
159 :
160 : Finally, notice that in order to write the timers on an output file when the
161 : Stopwatch is destroyed, one can store a reference to a PLMD::Log by passing it
162 : to the Stopwatch constructor.
163 : This will make sure timers are written also in case of a premature end.
164 : */
165 :
166 : class Log;
167 :
168 : /// Return an empty string.
169 : /// Inline static so that it can store a static variable (for quicker access)
170 : /// without adding a unique global symbol to a library including this header file.
171 1350636 : inline static const std::string & StopwatchEmptyString() noexcept {
172 1350636 : const static std::string s;
173 1350636 : return s;
174 : }
175 :
176 : class Stopwatch {
177 :
178 : public:
179 : /// Forward declaration
180 : class Watch;
181 : /// Auxiliary class for handling exception-safe start/pause and start/stop.
182 : class Handler {
183 : Watch* watch=nullptr;
184 : /// stop (true) or pause (false).
185 : /// might be changed to an enum if clearer.
186 : bool stop=false;
187 : /// Private constructor.
188 : /// This is kept private to avoid misuse. Handler objects should
189 : /// only be created using startPause() or startStop().
190 : /// stop is required to know if the destructor should stop or pause the watch.
191 : Handler(Watch* watch,bool stop);
192 : /// Allows usage of private constructor
193 : friend class Stopwatch;
194 : public:
195 : /// Default constructor
196 : Handler() = default;
197 : /// Default copy constructor is deleted (not copyable)
198 : Handler(const Handler & handler) = delete;
199 : /// Default copy assignment is deleted (not copyable)
200 : Handler & operator=(const Handler & handler) = delete;
201 : /// Move constructor.
202 : Handler(Handler && handler) noexcept;
203 : /// Move assignment.
204 : Handler & operator=(Handler && handler) noexcept;
205 : /// Destructor either stops or pauses the watch
206 : ~Handler();
207 : };
208 :
209 : /// Class to store a single stopwatch.
210 : /// Class Stopwatch contains a collection of them
211 14006 : class Watch {
212 : /// Instant in time when Watch was started last time
213 : std::chrono::time_point<std::chrono::high_resolution_clock> lastStart;
214 : /// Total accumulated time, in nanoseconds
215 : long long int total = 0;
216 : /// Accumulated time for this lap, in nanoseconds
217 : long long int lap = 0;
218 : /// Slowest lap so far, in nanoseconds
219 : long long int max = 0;
220 : /// Fastest lap so far, in nanoseconds
221 : long long int min = 0;
222 : /// Total number of cycles
223 : unsigned cycles = 0;
224 : /// count how many times Watch was started (+1) or stopped/paused (-1).
225 : unsigned running = 0;
226 : enum class State {started, stopped, paused};
227 : /// last lap
228 : long long int lastLap = 0;
229 : /// keep track of state
230 : State state = State::stopped;
231 : /// Allows access to internal data
232 : friend class Stopwatch;
233 : public:
234 : /// start the watch
235 : Watch & start();
236 : /// stop the watch
237 : Watch & stop();
238 : /// pause the watch
239 : Watch & pause();
240 : /// returns a start-stop handler
241 : Handler startStop();
242 : /// returns a start-pause handler
243 : Handler startPause();
244 : /// returns the time for the last cycle
245 : long long int getLastCycle() noexcept;
246 : /// returns the total time
247 : long long int getTotal() noexcept;
248 : };
249 :
250 : private:
251 :
252 : /// Pointer to a log file.
253 : /// If set, the stopwatch is logged in its destructor.
254 : Log*mylog=nullptr;
255 :
256 : /// List of watches.
257 : /// Each watch is labeled with a string.
258 : Tools::FastStringUnorderedMap<Watch> watches;
259 :
260 : /// Log over stream os.
261 : std::ostream& log(std::ostream& os)const;
262 :
263 : public:
264 : // Constructor.
265 : explicit Stopwatch() = default;
266 : // Constructor.
267 : // When destructing, stopwatch is logged.
268 : // Make sure that log survives stopwatch. Typically, it should be declared earlier, in order
269 : // to be destroyed later.
270 806829 : explicit Stopwatch(Log&log): mylog(&log) {}
271 : // Destructor.
272 : ~Stopwatch();
273 : /// Deleted copy
274 : Stopwatch(const Stopwatch&) = delete;
275 : /// Deleted assignment
276 : Stopwatch& operator=(const Stopwatch&) = delete;
277 : /// Move constructor
278 : Stopwatch(Stopwatch&&) noexcept;
279 : /// Move assignment
280 : Stopwatch& operator=(Stopwatch&&) noexcept;
281 : /// Start timer named "name"
282 : Stopwatch& start(const std::string_view&name=StopwatchEmptyString());
283 : /// Stop timer named "name"
284 : Stopwatch& stop(const std::string_view&name=StopwatchEmptyString());
285 : /// Pause timer named "name"
286 : Stopwatch& pause(const std::string_view&name=StopwatchEmptyString());
287 : /// Dump all timers on an ostream
288 : friend std::ostream& operator<<(std::ostream&,const Stopwatch&);
289 : /// Start with exception safety, then stop.
290 : /// Starts the Stopwatch and returns an object that, when goes out of scope,
291 : /// stops the watch. This allows Stopwatch to be started and stopped in
292 : /// an exception safe manner.
293 : Handler startStop(const std::string_view&name=StopwatchEmptyString());
294 : /// Start with exception safety, then pause.
295 : /// Starts the Stopwatch and returns an object that, when goes out of scope,
296 : /// pauses the watch. This allows Stopwatch to be started and paused in
297 : /// an exception safe manner.
298 : Handler startPause(const std::string_view&name=StopwatchEmptyString());
299 : /// Return the last completed cycle
300 : long long int getLastCycle(const std::string_view&name=StopwatchEmptyString());
301 : /// returns the total time
302 : long long int getTotal(const std::string_view&name=StopwatchEmptyString());
303 : };
304 :
305 : inline
306 : Stopwatch::Handler::Handler(Watch* watch,bool stop) :
307 3063540 : watch(watch),
308 3063540 : stop(stop) {
309 : watch->start();
310 : }
311 :
312 : inline
313 8640193 : Stopwatch::Handler::~Handler() {
314 8640193 : if(watch) {
315 3063540 : if(stop) {
316 1712906 : watch->stop();
317 : } else {
318 1350634 : watch->pause();
319 : }
320 : }
321 8640193 : }
322 :
323 : inline
324 8 : Stopwatch& Stopwatch::start(const std::string_view & name) {
325 8 : watches[name].start();
326 8 : return *this;
327 : }
328 :
329 : inline
330 4 : Stopwatch& Stopwatch::stop(const std::string_view & name) {
331 4 : watches[name].stop();
332 4 : return *this;
333 : }
334 :
335 : inline
336 1 : Stopwatch& Stopwatch::pause(const std::string_view & name) {
337 1 : watches[name].pause();
338 1 : return *this;
339 : }
340 :
341 : inline
342 1712906 : Stopwatch::Handler Stopwatch::startStop(const std::string_view&name) {
343 1712906 : return watches[name].startStop();
344 : }
345 :
346 : inline
347 1350634 : Stopwatch::Handler Stopwatch::startPause(const std::string_view&name) {
348 1350634 : return watches[name].startPause();
349 : }
350 :
351 : inline
352 : long long int Stopwatch::getLastCycle(const std::string_view&name) {
353 0 : return watches[name].getLastCycle();
354 : }
355 :
356 : inline
357 : long long int Stopwatch::getTotal(const std::string_view&name) {
358 : return watches[name].getTotal();
359 : }
360 :
361 : inline
362 : Stopwatch::Handler::Handler(Handler && handler) noexcept :
363 : watch(handler.watch),
364 : stop(handler.stop) {
365 : handler.watch=nullptr;
366 : }
367 :
368 : inline
369 5075 : Stopwatch::Handler & Stopwatch::Handler::operator=(Handler && handler) noexcept {
370 5075 : if(this!=&handler) {
371 5075 : if(watch) {
372 : try {
373 0 : if(stop) {
374 0 : watch->stop();
375 : } else {
376 0 : watch->pause();
377 : }
378 0 : } catch(...) {
379 : // this is to avoid problems with cppcheck, given than this method is declared as
380 : // noexcept and stop and pause might throw in case of an internal bug
381 0 : std::terminate();
382 : }
383 : }
384 5075 : watch=handler.watch;
385 5075 : stop=handler.stop;
386 5075 : handler.watch=nullptr;
387 : }
388 5075 : return *this;
389 : }
390 :
391 : inline
392 : Stopwatch::Watch & Stopwatch::Watch::start() {
393 3064858 : state=State::started;
394 3064858 : running++;
395 3064858 : lastStart=std::chrono::high_resolution_clock::now();
396 : return *this;
397 : }
398 :
399 : inline
400 1714220 : Stopwatch::Watch & Stopwatch::Watch::stop() {
401 1714220 : pause();
402 1714220 : state=State::stopped;
403 1714220 : cycles++;
404 1714220 : total+=lap;
405 1714220 : if(lap>max) {
406 13143 : max=lap;
407 : }
408 1714220 : if(min>lap || cycles==1) {
409 32538 : min=lap;
410 : }
411 1714220 : lastLap=lap;
412 1714220 : lap=0;
413 1714220 : return *this;
414 : }
415 :
416 : inline
417 3064701 : Stopwatch::Watch & Stopwatch::Watch::pause() {
418 3064701 : state=State::paused;
419 : // In case of an internal bug (non matching start stop within the startStop or startPause interface)
420 : // this assertion could fail in a destructor.
421 : // If this happens, the program should crash immediately
422 3064701 : plumed_assert(running>0) << "Non matching start/pause or start/stop commands in a Stopwatch";
423 3064701 : running--;
424 : // notice: with exception safety the following might be converted to a plain error.
425 : // I leave it like this for now:
426 3064701 : if(running!=0) {
427 : return *this;
428 : }
429 3064650 : auto t=std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now()-lastStart);
430 3064650 : lap+=t.count();
431 3064650 : return *this;
432 : }
433 :
434 : inline
435 : Stopwatch::Handler Stopwatch::Watch::startStop() {
436 : return Handler( this,true );
437 : }
438 :
439 : inline
440 : Stopwatch::Handler Stopwatch::Watch::startPause() {
441 : return Handler( this,false );
442 : }
443 :
444 : inline
445 : long long int Stopwatch::Watch::getLastCycle() noexcept {
446 0 : return lastLap;
447 : }
448 :
449 : inline
450 : long long int Stopwatch::Watch::getTotal() noexcept {
451 : return total;
452 : }
453 :
454 : inline
455 : Stopwatch::Stopwatch(Stopwatch&& other) noexcept:
456 : mylog(other.mylog),
457 : watches(std::move(other.watches)) {
458 : other.mylog=nullptr;
459 : }
460 :
461 : inline
462 0 : Stopwatch& Stopwatch::operator=(Stopwatch&& other) noexcept {
463 0 : if(this!=&other) {
464 0 : mylog=other.mylog;
465 0 : watches=std::move(other.watches);
466 0 : other.mylog=nullptr;
467 : }
468 0 : return *this;
469 : }
470 :
471 :
472 : }
473 :
474 :
475 : #endif
|
