diff options
Diffstat (limited to 'build/Bonmin/include/coin/CoinTime.hpp')
| -rw-r--r-- | build/Bonmin/include/coin/CoinTime.hpp | 310 |
1 files changed, 310 insertions, 0 deletions
diff --git a/build/Bonmin/include/coin/CoinTime.hpp b/build/Bonmin/include/coin/CoinTime.hpp new file mode 100644 index 0000000..49e8507 --- /dev/null +++ b/build/Bonmin/include/coin/CoinTime.hpp @@ -0,0 +1,310 @@ +/* $Id: CoinTime.hpp 1372 2011-01-03 23:31:00Z lou $ */ +// Copyright (C) 2002, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef _CoinTime_hpp +#define _CoinTime_hpp + +// Uncomment the next three lines for thorough memory initialisation. +// #ifndef ZEROFAULT +// # define ZEROFAULT +// #endif + +//############################################################################# + +#include <ctime> +#if defined(_MSC_VER) +// Turn off compiler warning about long names +# pragma warning(disable:4786) +#else +// MacOS-X and FreeBSD needs sys/time.h +#if defined(__MACH__) || defined (__FreeBSD__) +#include <sys/time.h> +#endif +#if !defined(__MSVCRT__) +#include <sys/resource.h> +#endif +#endif + +//############################################################################# + +#if defined(_MSC_VER) + +#if 0 // change this to 1 if want to use the win32 API +#include <windows.h> +#ifdef small +/* for some unfathomable reason (to me) rpcndr.h (pulled in by windows.h) does a + '#define small char' */ +#undef small +#endif +#define TWO_TO_THE_THIRTYTWO 4294967296.0 +#define DELTA_EPOCH_IN_SECS 11644473600.0 +inline double CoinGetTimeOfDay() +{ + FILETIME ft; + + GetSystemTimeAsFileTime(&ft); + double t = ft.dwHighDateTime * TWO_TO_THE_THIRTYTWO + ft.dwLowDateTime; + t = t/10000000.0 - DELTA_EPOCH_IN_SECS; + return t; +} +#else +#include <sys/types.h> +#include <sys/timeb.h> +inline double CoinGetTimeOfDay() +{ + struct _timeb timebuffer; +#pragma warning(disable:4996) + _ftime( &timebuffer ); // C4996 +#pragma warning(default:4996) + return timebuffer.time + timebuffer.millitm/1000.0; +} +#endif + +#else + +#include <sys/time.h> + +inline double CoinGetTimeOfDay() +{ + struct timeval tv; + gettimeofday(&tv, NULL); + return static_cast<double>(tv.tv_sec) + static_cast<int>(tv.tv_usec)/1000000.0; +} + +#endif // _MSC_VER + +/** + Query the elapsed wallclock time since the first call to this function. If + a positive argument is passed to the function then the time of the first + call is set to that value (this kind of argument is allowed only at the + first call!). If a negative argument is passed to the function then it + returns the time when it was set. +*/ + +inline double CoinWallclockTime(double callType = 0) +{ + double callTime = CoinGetTimeOfDay(); + static const double firstCall = callType > 0 ? callType : callTime; + return callType < 0 ? firstCall : callTime - firstCall; +} + +//############################################################################# + +//#define HAVE_SDK // if SDK under Win32 is installed, for CPU instead of elapsed time under Win +#ifdef HAVE_SDK +#include <windows.h> +#ifdef small +/* for some unfathomable reason (to me) rpcndr.h (pulled in by windows.h) does a + '#define small char' */ +#undef small +#endif +#define TWO_TO_THE_THIRTYTWO 4294967296.0 +#endif + +static inline double CoinCpuTime() +{ + double cpu_temp; +#if defined(_MSC_VER) || defined(__MSVCRT__) +#ifdef HAVE_SDK + FILETIME creation; + FILETIME exit; + FILETIME kernel; + FILETIME user; + GetProcessTimes(GetCurrentProcess(), &creation, &exit, &kernel, &user); + double t = user.dwHighDateTime * TWO_TO_THE_THIRTYTWO + user.dwLowDateTime; + return t/10000000.0; +#else + unsigned int ticksnow; /* clock_t is same as int */ + ticksnow = (unsigned int)clock(); + cpu_temp = (double)((double)ticksnow/CLOCKS_PER_SEC); +#endif + +#else + struct rusage usage; +# ifdef ZEROFAULT + usage.ru_utime.tv_sec = 0 ; + usage.ru_utime.tv_usec = 0 ; +# endif + getrusage(RUSAGE_SELF,&usage); + cpu_temp = static_cast<double>(usage.ru_utime.tv_sec); + cpu_temp += 1.0e-6*(static_cast<double> (usage.ru_utime.tv_usec)); +#endif + return cpu_temp; +} + +//############################################################################# + + + +static inline double CoinSysTime() +{ + double sys_temp; +#if defined(_MSC_VER) || defined(__MSVCRT__) + sys_temp = 0.0; +#else + struct rusage usage; +# ifdef ZEROFAULT + usage.ru_utime.tv_sec = 0 ; + usage.ru_utime.tv_usec = 0 ; +# endif + getrusage(RUSAGE_SELF,&usage); + sys_temp = static_cast<double>(usage.ru_stime.tv_sec); + sys_temp += 1.0e-6*(static_cast<double> (usage.ru_stime.tv_usec)); +#endif + return sys_temp; +} + +//############################################################################# +// On most systems SELF seems to include children threads, This is for when it doesn't +static inline double CoinCpuTimeJustChildren() +{ + double cpu_temp; +#if defined(_MSC_VER) || defined(__MSVCRT__) + cpu_temp = 0.0; +#else + struct rusage usage; +# ifdef ZEROFAULT + usage.ru_utime.tv_sec = 0 ; + usage.ru_utime.tv_usec = 0 ; +# endif + getrusage(RUSAGE_CHILDREN,&usage); + cpu_temp = static_cast<double>(usage.ru_utime.tv_sec); + cpu_temp += 1.0e-6*(static_cast<double> (usage.ru_utime.tv_usec)); +#endif + return cpu_temp; +} +//############################################################################# + +#include <fstream> + +/** + This class implements a timer that also implements a tracing functionality. + + The timer stores the start time of the timer, for how much time it was set to + and when does it expire (start + limit = end). Queries can be made that tell + whether the timer is expired, is past an absolute time, is past a percentage + of the length of the timer. All times are given in seconds, but as double + numbers, so there can be fractional values. + + The timer can also be initialized with a stream and a specification whether + to write to or read from the stream. In the former case the result of every + query is written into the stream, in the latter case timing is not tested at + all, rather the supposed result is read out from the stream. This makes it + possible to exactly retrace time sensitive program execution. +*/ +class CoinTimer +{ +private: + /// When the timer was initialized/reset/restarted + double start; + /// + double limit; + double end; +#ifdef COIN_COMPILE_WITH_TRACING + std::fstream* stream; + bool write_stream; +#endif + +private: +#ifdef COIN_COMPILE_WITH_TRACING + inline bool evaluate(bool b_tmp) const { + int i_tmp = b_tmp; + if (stream) { + if (write_stream) + (*stream) << i_tmp << "\n"; + else + (*stream) >> i_tmp; + } + return i_tmp; + } + inline double evaluate(double d_tmp) const { + if (stream) { + if (write_stream) + (*stream) << d_tmp << "\n"; + else + (*stream) >> d_tmp; + } + return d_tmp; + } +#else + inline bool evaluate(const bool b_tmp) const { + return b_tmp; + } + inline double evaluate(const double d_tmp) const { + return d_tmp; + } +#endif + +public: + /// Default constructor creates a timer with no time limit and no tracing + CoinTimer() : + start(0), limit(1e100), end(1e100) +#ifdef COIN_COMPILE_WITH_TRACING + , stream(0), write_stream(true) +#endif + {} + + /// Create a timer with the given time limit and with no tracing + CoinTimer(double lim) : + start(CoinCpuTime()), limit(lim), end(start+lim) +#ifdef COIN_COMPILE_WITH_TRACING + , stream(0), write_stream(true) +#endif + {} + +#ifdef COIN_COMPILE_WITH_TRACING + /** Create a timer with no time limit and with writing/reading the trace + to/from the given stream, depending on the argument \c write. */ + CoinTimer(std::fstream* s, bool write) : + start(0), limit(1e100), end(1e100), + stream(s), write_stream(write) {} + + /** Create a timer with the given time limit and with writing/reading the + trace to/from the given stream, depending on the argument \c write. */ + CoinTimer(double lim, std::fstream* s, bool w) : + start(CoinCpuTime()), limit(lim), end(start+lim), + stream(s), write_stream(w) {} +#endif + + /// Restart the timer (keeping the same time limit) + inline void restart() { start=CoinCpuTime(); end=start+limit; } + /// An alternate name for \c restart() + inline void reset() { restart(); } + /// Reset (and restart) the timer and change its time limit + inline void reset(double lim) { limit=lim; restart(); } + + /** Return whether the given percentage of the time limit has elapsed since + the timer was started */ + inline bool isPastPercent(double pct) const { + return evaluate(start + limit * pct < CoinCpuTime()); + } + /** Return whether the given amount of time has elapsed since the timer was + started */ + inline bool isPast(double lim) const { + return evaluate(start + lim < CoinCpuTime()); + } + /** Return whether the originally specified time limit has passed since the + timer was started */ + inline bool isExpired() const { + return evaluate(end < CoinCpuTime()); + } + + /** Return how much time is left on the timer */ + inline double timeLeft() const { + return evaluate(end - CoinCpuTime()); + } + + /** Return how much time has elapsed */ + inline double timeElapsed() const { + return evaluate(CoinCpuTime() - start); + } + + inline void setLimit(double l) { + limit = l; + return; + } +}; + +#endif |