lemon-0.x: comparison lemon/time

equal deleted inserted replaced

-:17b697332983
+:d46c4a64e3e9
 */
 #ifndef LEMON_TIME_MEASURE_H
 #define LEMON_TIME_MEASURE_H
-///\ingroup misc
+///\ingroup timecount
 ///\file
 ///\brief Tools for measuring cpu usage
 #include <sys/time.h>
 #include <sys/times.h>
 #include <iostream>
 #include <unistd.h>
 namespace lemon {
-/// \addtogroup misc
+/// \addtogroup timecount
 /// @{
 /// A class to store (cpu)time instances.
 /// This class stores five time values.
 ///  ...
 ///
 ///  Timer T;
 ///  doSomething();
 ///  std::cout << T << '\n';
-///  T.reset();
+///  T.restart();
 ///  doSomethingElse();
 ///  std::cout << T << '\n';
 ///
 ///  ...
 ///
 ///The \ref Timer can also be \ref stop() "stopped" and
 ///\ref start() "started" again, so it is possible to compute collected
 ///running times.
 ///
 ///\warning Depending on the operation system and its actual configuration
-///the time counters have a certain (relatively big) granularity.
+///the time counters have a certain (10ms on a typical Linux system)
+///granularity.
 ///Therefore this tool is not appropriate to measure very short times.
 ///Also, if you start and stop the timer very frequently, it could lead
 ///distorted results.
 ///
 ///The \ref Timer also counts the number of \ref start()
 ///\todo This shouldn't be Unix (Linux) specific.
 ///
 ///\author Alpar Juttner
 class Timer
 {
-int running; //Timer is running iff running>0; (running>=0 always holds)
+int _running; //Timer is running iff _running>0; (_running>=0 always holds)
 TimeStamp start_time; //This is the relativ start-time if the timer
-//is running, the collected running time otherwise.
+//is _running, the collected _running time otherwise.
-void _reset() {if(running) start_time.stamp(); else start_time.reset();}
+void _reset() {if(_running) start_time.stamp(); else start_time.reset();}
 public:
 ///Constructor.
 ///\param _running indicates whether or not the timer starts immediately.
 ///
-Timer(bool _running=true) :running(_running) {_reset();}
+Timer(bool run=true) :_running(run) {_reset();}
 ///Computes the ellapsed time
 ///This conversion computes the ellapsed time
 ///
 operator TimeStamp () const
 {
 TimeStamp t;
 t.stamp();
-return running?t-start_time:start_time;
+return _running?t-start_time:start_time;
 }
-///Resets the time counters
+///Reset and stop the time counters
-///Resets the time counters
+///This function resets and stops the time counters
-///
+///\sa restart()
 void reset()
 {
+_running=0;
 _reset();
 }
 ///Start the time counters
 ///If the timer is started more than ones, it will remain running
 ///until the same amount of \ref stop() is called.
 ///\sa stop()
 void start()
 {
-if(running) running++;
+if(_running) _running++;
 else {
 	TimeStamp t;
 	t.stamp();
 	start_time=t-start_time;
 }
 }
 ///Stop the time counters
-///This function stops the time counters.
+///This function stops the time counters. If start() was executed more than
-///
+///once, then the same number of stop() execution is necessary the really
-///\sa stop()
+///stop the timer.
+///
+///\sa halt()
+///\sa start()
+///\sa restart()
+///\sa reset()
 void stop()
 {
-if(running && !--running) {
+if(_running && !--_running) {
 	TimeStamp t;
 	t.stamp();
 	start_time=t-start_time;
 }
 }
+///Halt (i.e stop immediately) the time counters
+///This function stops immediately the time counters.
+///
+///\sa stop()
+///\sa restart()
+///\sa reset()
+void halt()
+{
+if(_running) {
+	_running=0;
+	TimeStamp t;
+	t.stamp();
+	start_time=t-start_time;
+}
+}
+///Returns the running state of the timer
+///This function returns the number of stop() exections that is
+///necessary to really stop the timer.
+///For example the timer
+///is running if and only if the return value is \c true
+///(i.e. greater than
+///zero).
+int running()  { return _running; }
+///Restart the time counters
+///This function is a shorthand for
+///a reset() and a start() calls.
+///
+void restart()
+{
+reset();
+start();
+}
 ///Gives back the ellapsed user time of the process
 double userTime() const
 {
 return operator TimeStamp().userTime();
 return operator TimeStamp().realTime();
 }
 };
+///Same as \ref Timer but prints a report on destruction.
+///Same as \ref Timer but prints a report on destruction.
+///\todo Untested
+class TimeReport : public Timer
+{
+std::string _title;
+std::ostream &_os;
+public:
+///\e
+TimeReport(std::string title,std::ostream &os,bool run)
+: Timer(run), _title(title), _os(os){}
+~TimeReport()
+{
+_os << _title << this << std::endl;
+}
+};
 ///Prints the time counters
 ///Prints the time counters in the following form:
 ///
 /// <tt>u: XX.XXs s: XX.XXs cu: XX.XXs cs: XX.XXs real: XX.XXs</tt>

changeset 1849	a4d1362397fe
parent 1839	b2dfd32b4895
child 1850	50d1d6acfcc2