CoinTime.hpp
Go to the documentation of this file.00001
00002
00003
00004
00005
00006 #ifndef _CoinTime_hpp
00007 #define _CoinTime_hpp
00008
00009
00010
00011
00012
00013
00014
00015
00016 #include <ctime>
00017 #if defined(_MSC_VER)
00018
00019 # pragma warning(disable:4786)
00020 #else
00021
00022 #if defined(__MACH__) || defined (__FreeBSD__)
00023 #include <sys/time.h>
00024 #endif
00025 #if !defined(__MSVCRT__)
00026 #include <sys/resource.h>
00027 #endif
00028 #endif
00029
00030
00031
00032 #if defined(_MSC_VER)
00033
00034 #if 0 // change this to 1 if want to use the win32 API
00035 #include <windows.h>
00036 #ifdef small
00037
00038
00039 #undef small
00040 #endif
00041 #define TWO_TO_THE_THIRTYTWO 4294967296.0
00042 #define DELTA_EPOCH_IN_SECS 11644473600.0
00043 inline double CoinGetTimeOfDay()
00044 {
00045 FILETIME ft;
00046
00047 GetSystemTimeAsFileTime(&ft);
00048 double t = ft.dwHighDateTime * TWO_TO_THE_THIRTYTWO + ft.dwLowDateTime;
00049 t = t/10000000.0 - DELTA_EPOCH_IN_SECS;
00050 return t;
00051 }
00052 #else
00053 #include <sys/types.h>
00054 #include <sys/timeb.h>
00055 inline double CoinGetTimeOfDay()
00056 {
00057 struct _timeb timebuffer;
00058 #pragma warning(disable:4996)
00059 _ftime( &timebuffer );
00060 #pragma warning(default:4996)
00061 return timebuffer.time + timebuffer.millitm/1000.0;
00062 }
00063 #endif
00064
00065 #else
00066
00067 #include <sys/time.h>
00068
00069 inline double CoinGetTimeOfDay()
00070 {
00071 struct timeval tv;
00072 gettimeofday(&tv, NULL);
00073 return static_cast<double>(tv.tv_sec) + static_cast<int>(tv.tv_usec)/1000000.0;
00074 }
00075
00076 #endif // _MSC_VER
00077
00086 inline double CoinWallclockTime(double callType = 0)
00087 {
00088 double callTime = CoinGetTimeOfDay();
00089 static const double firstCall = callType > 0 ? callType : callTime;
00090 return callType < 0 ? firstCall : callTime - firstCall;
00091 }
00092
00093
00094
00095
00096 #ifdef HAVE_SDK
00097 #include <windows.h>
00098 #ifdef small
00099
00100
00101 #undef small
00102 #endif
00103 #define TWO_TO_THE_THIRTYTWO 4294967296.0
00104 #endif
00105
00106 static inline double CoinCpuTime()
00107 {
00108 double cpu_temp;
00109 #if defined(_MSC_VER) || defined(__MSVCRT__)
00110 #ifdef HAVE_SDK
00111 FILETIME creation;
00112 FILETIME exit;
00113 FILETIME kernel;
00114 FILETIME user;
00115 GetProcessTimes(GetCurrentProcess(), &creation, &exit, &kernel, &user);
00116 double t = user.dwHighDateTime * TWO_TO_THE_THIRTYTWO + user.dwLowDateTime;
00117 return t/10000000.0;
00118 #else
00119 unsigned int ticksnow;
00120 ticksnow = (unsigned int)clock();
00121 cpu_temp = (double)((double)ticksnow/CLOCKS_PER_SEC);
00122 #endif
00123
00124 #else
00125 struct rusage usage;
00126 # ifdef ZEROFAULT
00127 usage.ru_utime.tv_sec = 0 ;
00128 usage.ru_utime.tv_usec = 0 ;
00129 # endif
00130 getrusage(RUSAGE_SELF,&usage);
00131 cpu_temp = static_cast<double>(usage.ru_utime.tv_sec);
00132 cpu_temp += 1.0e-6*(static_cast<double> (usage.ru_utime.tv_usec));
00133 #endif
00134 return cpu_temp;
00135 }
00136
00137
00138
00139
00140
00141 static inline double CoinSysTime()
00142 {
00143 double sys_temp;
00144 #if defined(_MSC_VER) || defined(__MSVCRT__)
00145 sys_temp = 0.0;
00146 #else
00147 struct rusage usage;
00148 # ifdef ZEROFAULT
00149 usage.ru_utime.tv_sec = 0 ;
00150 usage.ru_utime.tv_usec = 0 ;
00151 # endif
00152 getrusage(RUSAGE_SELF,&usage);
00153 sys_temp = static_cast<double>(usage.ru_stime.tv_sec);
00154 sys_temp += 1.0e-6*(static_cast<double> (usage.ru_stime.tv_usec));
00155 #endif
00156 return sys_temp;
00157 }
00158
00159
00160
00161 static inline double CoinCpuTimeJustChildren()
00162 {
00163 double cpu_temp;
00164 #if defined(_MSC_VER) || defined(__MSVCRT__)
00165 cpu_temp = 0.0;
00166 #else
00167 struct rusage usage;
00168 # ifdef ZEROFAULT
00169 usage.ru_utime.tv_sec = 0 ;
00170 usage.ru_utime.tv_usec = 0 ;
00171 # endif
00172 getrusage(RUSAGE_CHILDREN,&usage);
00173 cpu_temp = static_cast<double>(usage.ru_utime.tv_sec);
00174 cpu_temp += 1.0e-6*(static_cast<double> (usage.ru_utime.tv_usec));
00175 #endif
00176 return cpu_temp;
00177 }
00178
00179
00180 #include <fstream>
00181
00197 class CoinTimer
00198 {
00199 private:
00201 double start;
00203 double limit;
00204 double end;
00205 #ifdef COIN_COMPILE_WITH_TRACING
00206 std::fstream* stream;
00207 bool write_stream;
00208 #endif
00209
00210 private:
00211 #ifdef COIN_COMPILE_WITH_TRACING
00212 inline bool evaluate(bool b_tmp) const {
00213 int i_tmp = b_tmp;
00214 if (stream) {
00215 if (write_stream)
00216 (*stream) << i_tmp << "\n";
00217 else
00218 (*stream) >> i_tmp;
00219 }
00220 return i_tmp;
00221 }
00222 inline double evaluate(double d_tmp) const {
00223 if (stream) {
00224 if (write_stream)
00225 (*stream) << d_tmp << "\n";
00226 else
00227 (*stream) >> d_tmp;
00228 }
00229 return d_tmp;
00230 }
00231 #else
00232 inline bool evaluate(const bool b_tmp) const {
00233 return b_tmp;
00234 }
00235 inline double evaluate(const double d_tmp) const {
00236 return d_tmp;
00237 }
00238 #endif
00239
00240 public:
00242 CoinTimer() :
00243 start(0), limit(1e100), end(1e100)
00244 #ifdef COIN_COMPILE_WITH_TRACING
00245 , stream(0), write_stream(true)
00246 #endif
00247 {}
00248
00250 CoinTimer(double lim) :
00251 start(CoinCpuTime()), limit(lim), end(start+lim)
00252 #ifdef COIN_COMPILE_WITH_TRACING
00253 , stream(0), write_stream(true)
00254 #endif
00255 {}
00256
00257 #ifdef COIN_COMPILE_WITH_TRACING
00258
00260 CoinTimer(std::fstream* s, bool write) :
00261 start(0), limit(1e100), end(1e100),
00262 stream(s), write_stream(write) {}
00263
00266 CoinTimer(double lim, std::fstream* s, bool w) :
00267 start(CoinCpuTime()), limit(lim), end(start+lim),
00268 stream(s), write_stream(w) {}
00269 #endif
00270
00272 inline void restart() { start=CoinCpuTime(); end=start+limit; }
00274 inline void reset() { restart(); }
00276 inline void reset(double lim) { limit=lim; restart(); }
00277
00280 inline bool isPastPercent(double pct) const {
00281 return evaluate(start + limit * pct < CoinCpuTime());
00282 }
00285 inline bool isPast(double lim) const {
00286 return evaluate(start + lim < CoinCpuTime());
00287 }
00290 inline bool isExpired() const {
00291 return evaluate(end < CoinCpuTime());
00292 }
00293
00295 inline double timeLeft() const {
00296 return evaluate(end - CoinCpuTime());
00297 }
00298
00300 inline double timeElapsed() const {
00301 return evaluate(CoinCpuTime() - start);
00302 }
00303
00304 inline void setLimit(double l) {
00305 limit = l;
00306 return;
00307 }
00308 };
00309
00310 #endif