CSystemClock.hpp

/* This file is part of sUtil, a random collection of utilities.

sUtil is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3 of the License, or (at your option) any later version.

Alternatively, you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.

sUtil 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 Lesser General Public
License and a copy of the GNU General Public License along with
sUtil. If not, see <http://www.gnu.org/licenses/>.
 */
/* \file CSystemClock.hpp
 *
 *  Created on: Jul 17, 2011
 *
 *  Copyright (C) 2011, Samir Menon <smenon@stanford.edu>
 */

#ifndef CSYSTEMCLOCK_HPP_
#define CSYSTEMCLOCK_HPP_

#include <sutil/CSingleton.hpp>

#include <unistd.h>
#include <sys/time.h>

namespace sutil
{
  typedef double suClock;

  class SSystemClock
  {
  public:
    SSystemClock()
    {
      gettimeofday(&t_start_,NULL);
      sim_time_ = 0.0;
    }

    friend class CSystemClock;

  private:
    suClock sim_time_;

    timeval t_start_;

    SSystemClock(const SSystemClock&);

    SSystemClock& operator= (const SSystemClock&);
  };

  class CSystemClock : private CSingleton<SSystemClock>
  {
  public:
    static bool start()
    {
      if(NULL != CSingleton<SSystemClock>::getData())
      { return true;  }
      else
      {  return false; }
    }
    static suClock getSysTime()
    { return computeTDiff(CSingleton<SSystemClock>::getData()->t_start_);  }

    static suClock getSimTime()
    { return CSingleton<SSystemClock>::getData()->sim_time_; }

    static void tick(suClock arg_dt)
    { CSingleton<SSystemClock>::getData()->sim_time_+=arg_dt;  }

    static void progressToTime(const timeval &arg_t_start,
        const suClock arg_time_increment=1.0,
        const bool arg_increment_sim_clock=true)
    {//Sleeps up to when n seconds have elapsed from the passed timeval
      suClock time_diff;
      //How much time has passed since the timestamp
      time_diff = computeTDiff(arg_t_start);

      if(time_diff<arg_time_increment)//Sleep for remaining time
      { sleep(arg_time_increment-time_diff);  }

      if(arg_increment_sim_clock)//Increment the simulation time
      { CSingleton<SSystemClock>::getData()->sim_time_+=arg_time_increment; }
    }

  private:
    static suClock computeTDiff(const timeval &arg_t_start)
    {
      //To compute the elapsed time since the clock was initialized.
      timeval t_tick,t_diff,t_start(arg_t_start);

      //Get the current system time
      gettimeofday(&t_tick,NULL);
      if (t_tick.tv_usec < t_start.tv_usec)
      {
        long int nsec = (t_start.tv_usec - t_tick.tv_usec) / 1000000 + 1;
        t_start.tv_usec -= 1000000 * nsec;
        t_start.tv_sec += nsec;
      }
      if (t_tick.tv_usec - t_start.tv_usec > 1000000)
      {
        long int nsec = (t_tick.tv_usec - t_start.tv_usec) / 1000000;
        t_start.tv_usec += 1000000 * nsec;
        t_start.tv_sec -= nsec;
      }

      // Compute the remaining time. tv_usec is positive.
      t_diff.tv_sec = t_tick.tv_sec - t_start.tv_sec;
      t_diff.tv_usec = t_tick.tv_usec - t_start.tv_usec;

      return static_cast<suClock>(t_diff.tv_sec)+(static_cast<suClock>(t_diff.tv_usec)/1000000.00);
    }

    CSystemClock();

    CSystemClock(const CSystemClock&);

    CSystemClock& operator= (const CSystemClock&);
  };
}

#endif /*CSYSTEMCLOCK_HPP_*/