CoinTime.hpp

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.

#ifndef _CoinTime_hpp
#define _CoinTime_hpp

//#############################################################################

#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
#include <sys/resource.h>
#endif

//#############################################################################

static inline double CoinCpuTime()
{
  double cpu_temp;
#if defined(_MSC_VER)
  unsigned int ticksnow;        /* clock_t is same as int */
  
  ticksnow = (unsigned int)clock();
  
  cpu_temp = (double)((double)ticksnow/CLOCKS_PER_SEC);
#else
  struct rusage usage;
  getrusage(RUSAGE_SELF,&usage);
  cpu_temp = usage.ru_utime.tv_sec;
  cpu_temp += 1.0e-6*((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());
   }
};

#endif

---