loos_timer.hpp

// A simple timer class...
 
/*
  This file is part of LOOS.
 
  LOOS (Lightweight Object-Oriented Structure library)
  Copyright (c) 2009, Tod D. Romo, Alan Grossfield
  Department of Biochemistry and Biophysics
  School of Medicine & Dentistry, University of Rochester
 
  This package (LOOS) is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation under version 3 of the License.
 
  This package is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
 
#if !defined(LOOS_TIMER_HPP)
#define LOOS_TIMER_HPP
 
#include <iostream>
#include <string>
#include <stdexcept>
 
#include <sys/time.h>
#include <sys/resource.h>
#include <boost/format.hpp>
 
#include <loos_defs.hpp>
 
 
namespace loos {
 
  class WallTimer {
  public:
    double currentTime(void) const {
      struct timeval tv;
      
      int i = gettimeofday(&tv, 0);
      if (i < 0)
        throw(std::runtime_error("Error in gettimeofday()"));
      return(static_cast<double>(tv.tv_sec) + static_cast<double>(tv.tv_usec) * 1e-6);
    }
  };
  
  class UserTimer {
  public:
    double currentTime(void) const {
      struct rusage ru;
      int i = getrusage(RUSAGE_SELF, &ru);
      if (i < 0)
        throw(std::runtime_error("Error in getrusage()"));
      return(static_cast<double>(ru.ru_utime.tv_sec) + static_cast<double>(ru.ru_utime.tv_usec) * 1e-6);
    }
  };
 
 
 
  template<class TimerType = WallTimer>
  class Timer : public TimerType {
  public:
    Timer() : t0(0), t1(0), avg(0), lapt(0), n(0), running(false) { }
 
    void start(void) {
      lapt = t0 = TimerType::currentTime();
      n=0;
      avg = 0.0;
      running = true;
    }
 
    // Automatically adds a lap...
    double stop(void) {
      t1 = TimerType::currentTime();
      avg += (t1 - lapt);
      ++n;
      running = false;
      return(t1-t0);
    }
 
 
    double elapsed(void) const { return( running ? TimerType::currentTime() - t0 : t1 - t0 ); }
 
 
    double lap(void) {
      if (!running)    // Don't adjust lap time if the timer ain't running...
        return(0.0);
 
      double t = TimerType::currentTime();
      double lt = t - lapt;
      lapt = t;
      avg += lt;
      ++n;
    }
 
    double averageLapTime(void) { return(avg / n); }
    
  private:
    double t0, t1, avg, lapt;
    ulong n;
    bool running;
  };
 
  template<class T>
  std::ostream& operator<<(std::ostream& os, const Timer<T>& t) {
    std::string s = timeAsString(t.elapsed());
    os << "Elapsed time " << s;
    return(os);
  }
}
 
 
 
 
#endif