CoinTime.hpp

Go to the documentation of this file.

/* $Id$ */
// 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

 
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()
{
#ifdef COIN_DOING_DIFFS
  // when trying to see differences between runs it can be helpful
  return 0.0;
#endif
  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>

class CoinTimer {
private:
  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:
  CoinTimer()
    : start(0)
    , limit(1e100)
    , end(1e100)
#ifdef COIN_COMPILE_WITH_TRACING
    , stream(0)
    , write_stream(true)
#endif
  {
  }

  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
  CoinTimer(std::fstream *s, bool write)
    : start(0)
    , limit(1e100)
    , end(1e100)
    , stream(s)
    , write_stream(write)
  {
  }

  CoinTimer(double lim, std::fstream *s, bool w)
    : start(CoinCpuTime())
    , limit(lim)
    , end(start + lim)
    , stream(s)
    , write_stream(w)
  {
  }
#endif

  inline void restart()
  {
    start = CoinCpuTime();
    end = start + limit;
  }

  inline void reset() { restart(); }
  inline void reset(double lim)
  {
    limit = lim;
    restart();
  }

  inline bool isPastPercent(double pct) const
  {
    return evaluate(start + limit * pct < CoinCpuTime());
  }

  inline bool isPast(double lim) const
  {
    return evaluate(start + lim < CoinCpuTime());
  }

  inline bool isExpired() const
  {
    return evaluate(end < CoinCpuTime());
  }

  inline double timeLeft() const
  {
    return evaluate(end - CoinCpuTime());
  }

  inline double timeElapsed() const
  {
    return evaluate(CoinCpuTime() - start);
  }
 
  inline void setLimit(double l)
  {
    limit = l;
    return;
  }
};
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/