611 lines
15 KiB
C++
Executable File
611 lines
15 KiB
C++
Executable File
/* -*- mode: C++; indent-tabs-mode: nil; -*-
|
|
*
|
|
* This file is a part of LEMON, a generic C++ optimization library.
|
|
*
|
|
* Copyright (C) 2003-2013
|
|
* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
|
|
* (Egervary Research Group on Combinatorial Optimization, EGRES).
|
|
*
|
|
* Permission to use, modify and distribute this software is granted
|
|
* provided that this copyright notice appears in all copies. For
|
|
* precise terms see the accompanying LICENSE file.
|
|
*
|
|
* This software is provided "AS IS" with no warranty of any kind,
|
|
* express or implied, and with no claim as to its suitability for any
|
|
* purpose.
|
|
*
|
|
*/
|
|
|
|
#ifndef LEMON_TIME_MEASURE_H
|
|
#define LEMON_TIME_MEASURE_H
|
|
|
|
///\ingroup timecount
|
|
///\file
|
|
///\brief Tools for measuring cpu usage
|
|
|
|
#ifdef WIN32
|
|
#include <lemon/bits/windows.h>
|
|
#else
|
|
#include <unistd.h>
|
|
#include <sys/times.h>
|
|
#include <sys/time.h>
|
|
#endif
|
|
|
|
#include <string>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <lemon/math.h>
|
|
|
|
namespace lemon {
|
|
|
|
/// \addtogroup timecount
|
|
/// @{
|
|
|
|
/// A class to store (cpu)time instances.
|
|
|
|
/// This class stores five time values.
|
|
/// - a real time
|
|
/// - a user cpu time
|
|
/// - a system cpu time
|
|
/// - a user cpu time of children
|
|
/// - a system cpu time of children
|
|
///
|
|
/// TimeStamp's can be added to or substracted from each other and
|
|
/// they can be pushed to a stream.
|
|
///
|
|
/// In most cases, perhaps the \ref Timer or the \ref TimeReport
|
|
/// class is what you want to use instead.
|
|
|
|
class TimeStamp
|
|
{
|
|
double utime;
|
|
double stime;
|
|
double cutime;
|
|
double cstime;
|
|
double rtime;
|
|
|
|
public:
|
|
///Display format specifier
|
|
|
|
///\e
|
|
///
|
|
enum Format {
|
|
/// Reports all measured values
|
|
NORMAL = 0,
|
|
/// Only real time and an error indicator is displayed
|
|
SHORT = 1
|
|
};
|
|
|
|
private:
|
|
static Format _format;
|
|
|
|
void _reset() {
|
|
utime = stime = cutime = cstime = rtime = 0;
|
|
}
|
|
|
|
public:
|
|
|
|
///Set output format
|
|
|
|
///Set output format.
|
|
///
|
|
///The output format is global for all timestamp instances.
|
|
static void format(Format f) { _format = f; }
|
|
///Retrieve the current output format
|
|
|
|
///Retrieve the current output format
|
|
///
|
|
///The output format is global for all timestamp instances.
|
|
static Format format() { return _format; }
|
|
|
|
|
|
///Read the current time values of the process
|
|
void stamp()
|
|
{
|
|
#ifndef WIN32
|
|
timeval tv;
|
|
gettimeofday(&tv, 0);
|
|
rtime=tv.tv_sec+double(tv.tv_usec)/1e6;
|
|
|
|
tms ts;
|
|
double tck=sysconf(_SC_CLK_TCK);
|
|
times(&ts);
|
|
utime=ts.tms_utime/tck;
|
|
stime=ts.tms_stime/tck;
|
|
cutime=ts.tms_cutime/tck;
|
|
cstime=ts.tms_cstime/tck;
|
|
#else
|
|
bits::getWinProcTimes(rtime, utime, stime, cutime, cstime);
|
|
#endif
|
|
}
|
|
|
|
/// Constructor initializing with zero
|
|
TimeStamp()
|
|
{ _reset(); }
|
|
///Constructor initializing with the current time values of the process
|
|
TimeStamp(void *) { stamp();}
|
|
|
|
///Set every time value to zero
|
|
TimeStamp &reset() {_reset();return *this;}
|
|
|
|
///\e
|
|
TimeStamp &operator+=(const TimeStamp &b)
|
|
{
|
|
utime+=b.utime;
|
|
stime+=b.stime;
|
|
cutime+=b.cutime;
|
|
cstime+=b.cstime;
|
|
rtime+=b.rtime;
|
|
return *this;
|
|
}
|
|
///\e
|
|
TimeStamp operator+(const TimeStamp &b) const
|
|
{
|
|
TimeStamp t(*this);
|
|
return t+=b;
|
|
}
|
|
///\e
|
|
TimeStamp &operator-=(const TimeStamp &b)
|
|
{
|
|
utime-=b.utime;
|
|
stime-=b.stime;
|
|
cutime-=b.cutime;
|
|
cstime-=b.cstime;
|
|
rtime-=b.rtime;
|
|
return *this;
|
|
}
|
|
///\e
|
|
TimeStamp operator-(const TimeStamp &b) const
|
|
{
|
|
TimeStamp t(*this);
|
|
return t-=b;
|
|
}
|
|
///\e
|
|
TimeStamp &operator*=(double b)
|
|
{
|
|
utime*=b;
|
|
stime*=b;
|
|
cutime*=b;
|
|
cstime*=b;
|
|
rtime*=b;
|
|
return *this;
|
|
}
|
|
///\e
|
|
TimeStamp operator*(double b) const
|
|
{
|
|
TimeStamp t(*this);
|
|
return t*=b;
|
|
}
|
|
friend TimeStamp operator*(double b,const TimeStamp &t);
|
|
///\e
|
|
TimeStamp &operator/=(double b)
|
|
{
|
|
utime/=b;
|
|
stime/=b;
|
|
cutime/=b;
|
|
cstime/=b;
|
|
rtime/=b;
|
|
return *this;
|
|
}
|
|
///\e
|
|
TimeStamp operator/(double b) const
|
|
{
|
|
TimeStamp t(*this);
|
|
return t/=b;
|
|
}
|
|
///The time ellapsed since the last call of stamp()
|
|
TimeStamp ellapsed() const
|
|
{
|
|
TimeStamp t(NULL);
|
|
return t-*this;
|
|
}
|
|
|
|
friend std::ostream& operator<<(std::ostream& os,const TimeStamp &t);
|
|
|
|
///Gives back the user time of the process
|
|
double userTime() const
|
|
{
|
|
return utime;
|
|
}
|
|
///Gives back the system time of the process
|
|
double systemTime() const
|
|
{
|
|
return stime;
|
|
}
|
|
///Gives back the user time of the process' children
|
|
|
|
///\note On <tt>WIN32</tt> platform this value is not calculated.
|
|
///
|
|
double cUserTime() const
|
|
{
|
|
return cutime;
|
|
}
|
|
///Gives back the user time of the process' children
|
|
|
|
///\note On <tt>WIN32</tt> platform this value is not calculated.
|
|
///
|
|
double cSystemTime() const
|
|
{
|
|
return cstime;
|
|
}
|
|
///Gives back the real time
|
|
double realTime() const {return rtime;}
|
|
};
|
|
|
|
inline TimeStamp operator*(double b,const TimeStamp &t)
|
|
{
|
|
return t*b;
|
|
}
|
|
|
|
///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>
|
|
///
|
|
/// where the values are the
|
|
/// \li \c u: user cpu time,
|
|
/// \li \c s: system cpu time,
|
|
/// \li \c cu: user cpu time of children,
|
|
/// \li \c cs: system cpu time of children,
|
|
/// \li \c real: real time.
|
|
/// \relates TimeStamp
|
|
/// \note On <tt>WIN32</tt> platform the cummulative values are not
|
|
/// calculated.
|
|
inline std::ostream& operator<<(std::ostream& os,const TimeStamp &t)
|
|
{
|
|
switch(t._format)
|
|
{
|
|
case TimeStamp::NORMAL:
|
|
os << "u: " << t.userTime() <<
|
|
"s, s: " << t.systemTime() <<
|
|
"s, cu: " << t.cUserTime() <<
|
|
"s, cs: " << t.cSystemTime() <<
|
|
"s, real: " << t.realTime() << "s";
|
|
break;
|
|
case TimeStamp::SHORT:
|
|
double total = t.userTime()+t.systemTime()+
|
|
t.cUserTime()+t.cSystemTime();
|
|
os << t.realTime()
|
|
<< "s (err: " << round((t.realTime()-total)/
|
|
t.realTime()*10000)/100
|
|
<< "%)";
|
|
break;
|
|
}
|
|
return os;
|
|
}
|
|
|
|
///Class for measuring the cpu time and real time usage of the process
|
|
|
|
///Class for measuring the cpu time and real time usage of the process.
|
|
///It is quite easy-to-use, here is a short example.
|
|
///\code
|
|
/// #include<lemon/time_measure.h>
|
|
/// #include<iostream>
|
|
///
|
|
/// int main()
|
|
/// {
|
|
///
|
|
/// ...
|
|
///
|
|
/// Timer t;
|
|
/// doSomething();
|
|
/// std::cout << t << '\n';
|
|
/// t.restart();
|
|
/// doSomethingElse();
|
|
/// std::cout << t << '\n';
|
|
///
|
|
/// ...
|
|
///
|
|
/// }
|
|
///\endcode
|
|
///
|
|
///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 (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 to
|
|
///distorted results.
|
|
///
|
|
///\note If you want to measure the running time of the execution of a certain
|
|
///function, consider the usage of \ref TimeReport instead.
|
|
///
|
|
///\sa TimeReport
|
|
class Timer
|
|
{
|
|
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.
|
|
|
|
void _reset() {if(_running) start_time.stamp(); else start_time.reset();}
|
|
|
|
public:
|
|
///Constructor.
|
|
|
|
///\param run indicates whether or not the timer starts immediately.
|
|
///
|
|
Timer(bool run=true) :_running(run) {_reset();}
|
|
|
|
///\name Control the State of the Timer
|
|
///Basically a Timer can be either running or stopped,
|
|
///but it provides a bit finer control on the execution.
|
|
///The \ref lemon::Timer "Timer" also counts the number of
|
|
///\ref lemon::Timer::start() "start()" executions, and it stops
|
|
///only after the same amount (or more) \ref lemon::Timer::stop()
|
|
///"stop()"s. This can be useful e.g. to compute the running time
|
|
///of recursive functions.
|
|
|
|
///@{
|
|
|
|
///Reset and stop the time counters
|
|
|
|
///This function resets and stops the time counters
|
|
///\sa restart()
|
|
void reset()
|
|
{
|
|
_running=0;
|
|
_reset();
|
|
}
|
|
|
|
///Start the time counters
|
|
|
|
///This function starts 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++;
|
|
else {
|
|
_running=1;
|
|
TimeStamp t;
|
|
t.stamp();
|
|
start_time=t-start_time;
|
|
}
|
|
}
|
|
|
|
|
|
///Stop 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
|
|
///stop the timer.
|
|
///
|
|
///\sa halt()
|
|
///\sa start()
|
|
///\sa restart()
|
|
///\sa reset()
|
|
|
|
void stop()
|
|
{
|
|
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, i.e. <tt>t.halt()</tt>
|
|
///is a faster
|
|
///equivalent of the following.
|
|
///\code
|
|
/// while(t.running()) t.stop()
|
|
///\endcode
|
|
///
|
|
///
|
|
///\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();
|
|
}
|
|
|
|
///@}
|
|
|
|
///\name Query Functions for the Ellapsed Time
|
|
|
|
///@{
|
|
|
|
///Gives back the ellapsed user time of the process
|
|
double userTime() const
|
|
{
|
|
return operator TimeStamp().userTime();
|
|
}
|
|
///Gives back the ellapsed system time of the process
|
|
double systemTime() const
|
|
{
|
|
return operator TimeStamp().systemTime();
|
|
}
|
|
///Gives back the ellapsed user time of the process' children
|
|
|
|
///\note On <tt>WIN32</tt> platform this value is not calculated.
|
|
///
|
|
double cUserTime() const
|
|
{
|
|
return operator TimeStamp().cUserTime();
|
|
}
|
|
///Gives back the ellapsed user time of the process' children
|
|
|
|
///\note On <tt>WIN32</tt> platform this value is not calculated.
|
|
///
|
|
double cSystemTime() const
|
|
{
|
|
return operator TimeStamp().cSystemTime();
|
|
}
|
|
///Gives back the ellapsed real time
|
|
double realTime() const
|
|
{
|
|
return operator TimeStamp().realTime();
|
|
}
|
|
///Computes the ellapsed time
|
|
|
|
///This conversion computes the ellapsed time, therefore you can print
|
|
///the ellapsed time like this.
|
|
///\code
|
|
/// Timer t;
|
|
/// doSomething();
|
|
/// std::cout << t << '\n';
|
|
///\endcode
|
|
operator TimeStamp () const
|
|
{
|
|
TimeStamp t;
|
|
t.stamp();
|
|
return _running?t-start_time:start_time;
|
|
}
|
|
|
|
|
|
///@}
|
|
};
|
|
|
|
///Same as Timer but prints a report on destruction.
|
|
|
|
///Same as \ref Timer but prints a report on destruction.
|
|
///This example shows its usage.
|
|
///\code
|
|
/// void myAlg(ListGraph &g,int n)
|
|
/// {
|
|
/// TimeReport tr("Running time of myAlg: ");
|
|
/// ... //Here comes the algorithm
|
|
/// }
|
|
///\endcode
|
|
///
|
|
///\sa Timer
|
|
///\sa NoTimeReport
|
|
class TimeReport : public Timer
|
|
{
|
|
std::string _title;
|
|
std::ostream &_os;
|
|
bool _active;
|
|
public:
|
|
///Constructor
|
|
|
|
///Constructor.
|
|
///\param title This text will be printed before the ellapsed time.
|
|
///\param os The stream to print the report to.
|
|
///\param run Sets whether the timer should start immediately.
|
|
///\param active Sets whether the report should actually be printed
|
|
/// on destruction.
|
|
TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true,
|
|
bool active=true)
|
|
: Timer(run), _title(title), _os(os), _active(active) {}
|
|
///Destructor that prints the ellapsed time
|
|
~TimeReport()
|
|
{
|
|
if(_active) _os << _title << *this << std::endl;
|
|
}
|
|
|
|
///Retrieve the activity status
|
|
|
|
///\e
|
|
///
|
|
bool active() const { return _active; }
|
|
///Set the activity status
|
|
|
|
/// This function set whether the time report should actually be printed
|
|
/// on destruction.
|
|
void active(bool a) { _active=a; }
|
|
};
|
|
|
|
///'Do nothing' version of TimeReport
|
|
|
|
///\sa TimeReport
|
|
///
|
|
class NoTimeReport
|
|
{
|
|
public:
|
|
///\e
|
|
NoTimeReport(std::string,std::ostream &,bool) {}
|
|
///\e
|
|
NoTimeReport(std::string,std::ostream &) {}
|
|
///\e
|
|
NoTimeReport(std::string) {}
|
|
///\e Do nothing.
|
|
~NoTimeReport() {}
|
|
|
|
operator TimeStamp () const { return TimeStamp(); }
|
|
void reset() {}
|
|
void start() {}
|
|
void stop() {}
|
|
void halt() {}
|
|
int running() { return 0; }
|
|
void restart() {}
|
|
double userTime() const { return 0; }
|
|
double systemTime() const { return 0; }
|
|
double cUserTime() const { return 0; }
|
|
double cSystemTime() const { return 0; }
|
|
double realTime() const { return 0; }
|
|
};
|
|
|
|
///Tool to measure the running time more exactly.
|
|
|
|
///This function calls \c f several times and returns the average
|
|
///running time. The number of the executions will be choosen in such a way
|
|
///that the full real running time will be roughly between \c min_time
|
|
///and <tt>2*min_time</tt>.
|
|
///\param f the function object to be measured.
|
|
///\param min_time the minimum total running time.
|
|
///\retval num if it is not \c NULL, then the actual
|
|
/// number of execution of \c f will be written into <tt>*num</tt>.
|
|
///\retval full_time if it is not \c NULL, then the actual
|
|
/// total running time will be written into <tt>*full_time</tt>.
|
|
///\return The average running time of \c f.
|
|
|
|
template<class F>
|
|
TimeStamp runningTimeTest(F f,double min_time=10,unsigned int *num = NULL,
|
|
TimeStamp *full_time=NULL)
|
|
{
|
|
TimeStamp full;
|
|
unsigned int total=0;
|
|
Timer t;
|
|
for(unsigned int tn=1;tn <= 1U<<31 && full.realTime()<=min_time; tn*=2) {
|
|
for(;total<tn;total++) f();
|
|
full=t;
|
|
}
|
|
if(num) *num=total;
|
|
if(full_time) *full_time=full;
|
|
return full/total;
|
|
}
|
|
|
|
/// @}
|
|
|
|
|
|
} //namespace lemon
|
|
|
|
#endif //LEMON_TIME_MEASURE_H
|