OMKClock.cpp

Go to the documentation of this file.

/*
 * Software OpenMASK-3DVis © INRIA 1993-2002, thereinafter the Software
 * 
 * The software has been developed within the Siames Project. 
 * INRIA hold intellectual property rights
 * 
 * The Software has been registered with the Agence pour la Protection des
 * Programmes (APP) under registration number IDDN.FR.001.500027.00.S.P.2001.000.41200
 *
 * This file may be distributed under the terms of the Q Public License
 * version 1.0 as defined by Trolltech AS of Norway and appearing in the file
 * LICENSE.QPL included in the packaging of this file.
 *
 * Licensees holding valid specific licenses issued by INRIA for the software may use 
 * this file in accordance with that specific license         
 *
 */
//-----------------------------------------------------------------------------
#include "OMKClock.h"

#include <OMKParametersAccessor.inl>

#ifdef _MSC_VER // WINDOWS Time Management
#include <time.h>
//Includes for using std::transform and toupper under VC
#include <cctype>
#include <string>
#include <algorithm>
#else // POSIX Time Management
#include <sys/time.h>
#endif

#include <math.h>

#define NANOSLEEP_RESOLUTION  20000000
using namespace OMK ;

//===================================================================
REGISTER_OBJECT_FACTORY( Clock, "Clock" ) ;
//===================================================================
Clock::Clock( Controller &ctrl,  const ObjectDescriptor &objectDescription ) 
: ExtensibleSimulatedObject( ctrl,  objectDescription ), 
  _firstRealDate(0ul), 
  _timeToSpend( 0l ),
  _simulFrequency( 1ul ),
  _wantedMult( 1.0f ),  _realMult( 0.0f ), 
  _freeRun( false ),  _activeSleep( true ), _simulationStarted( false) 
{  

#ifdef _MSC_VER // WINDOWS Time Management
  QueryPerformanceCounter( &_startSimulationDate );
  QueryPerformanceCounter( &_lastCallDate );
  QueryPerformanceCounter( &_lastRealRefresh );
  QueryPerformanceFrequency( &_processorFrequency );
#else // POSIX Time Management
  _lastCallDate = 0ul ;
  _lastRealRefresh = 0ul ;
#endif

}
//===================================================================

//===================================================================
Clock::~Clock()
{
}
//===================================================================

//===================================================================
void Clock::init()
{
  const ConfigurationParameterDescriptor* prm = getConfigurationParameters();
  
  std::string str;
  if( ParametersAccessor::get( prm, "SleepProcedure", str ) )
  {  
    std::transform( str.begin(), str.end(), str.begin(), toupper );
    _activeSleep = !( str == "PASSIVE" );
  }

  ParametersAccessor::get( prm, "FreeRun"     , _freeRun      );
  ParametersAccessor::get( prm, "InitCoeff"   , _wantedMult   );
  setWantedMultiplier( _wantedMult ) ;

#ifdef _MSC_VER
  QueryPerformanceCounter( &_startSimulationDate ) ;
  _lastRealRefresh = _startSimulationDate ;
  _lastCallDate = _startSimulationDate ;
#else
  timeval currentTime;
  gettimeofday( &currentTime, NULL );
  _firstRealDate = currentTime.tv_sec;
  // The filter is used to avoid numeric overflow
  _lastRealRefresh = _lastCallDate = ( currentTime.tv_sec & 0xfff ) * 1000000 + currentTime.tv_usec;
#endif

  _simulFrequency = getObjectDescriptor().getFrequency();
  return ExtensibleSimulatedObject::init();
}
//===================================================================

//===================================================================
bool Clock::processEvent( Event* event )
{
  return ExtensibleSimulatedObject::processEvent( event ) ;
}
//===================================================================

//===================================================================
void Clock::compute()
{
        if(!_simulationStarted){
          _simulationStarted = true ;
#ifdef _MSC_VER
          // current time in micro-sec
          LARGE_INTEGER firstDate ;
          QueryPerformanceCounter( &firstDate ) ;
          _startSimulationDate = firstDate ;
          _lastCallDate = firstDate ;
#else
          timeval firstTime;
          gettimeofday( &firstTime, NULL );
          // current time in micro-sec
          _lastCallDate = ( firstTime.tv_sec & 0xfff ) * 1000000 + firstTime.tv_usec;
#endif
        }

#ifdef _MSC_VER
  // current time in micro-sec
  LARGE_INTEGER newCallDate ;
  QueryPerformanceCounter( &newCallDate ) ;
  LARGE_INTEGER currentDate = newCallDate ;
  // ratio of step duration by elapsed time since last call
  _realMult = (float)( ( 1/ _simulFrequency ) * (_processorFrequency.QuadPart / (newCallDate.QuadPart - _lastCallDate.QuadPart) ) ) ;
#else
  timeval currentTime;
  gettimeofday( &currentTime, NULL );
  // current time in micro-sec
  unsigned long newCallDate = ( currentTime.tv_sec & 0xfff ) * 1000000 + currentTime.tv_usec;
  // ratio of step duration by elapsed time since last call
  _realMult = ( 1000000.0f / _simulFrequency ) / ( newCallDate - _lastCallDate );
#endif

  if( _freeRun )
  {
    _timeToSpend = 0;
  }
  else
  {  
    // Controled time, sleep if necessary
    // step duration in micro-sec
    long stepDuration = (long)( 1000000.0f / ( _simulFrequency * _wantedMult ) );
    // sleep duration is the wanted step duration minus the time needed for simulation
    // negative: time to catch up, positive: time to spend
#ifdef _MSC_VER
        _timeToSpend += (long)( stepDuration + ((_lastCallDate.QuadPart - newCallDate.QuadPart)*1000000/_processorFrequency.QuadPart) ) ;
#else
    _timeToSpend += _lastCallDate - newCallDate + stepDuration ;
#endif
    // never sleep more than step duration (to avoid numeric overflow on signed long)
    _timeToSpend = (stepDuration < _timeToSpend) ? stepDuration : _timeToSpend ;
    
    if( 0 < _timeToSpend )
    { 
      // Some time to spend
      if( _activeSleep )
      { 
        // Active sleep => loop
#ifdef _MSC_VER

                long currentStep = 0 ;
                while( currentStep < _timeToSpend){
                        QueryPerformanceCounter( &currentDate ) ;
                        currentStep = (long)(( currentDate.QuadPart - newCallDate.QuadPart )*1000000/_processorFrequency.QuadPart); // Get step in micro-sec

                }
#else
        // Compute the date to reach with the dummy loop
        timeval targetDate;
        targetDate.tv_sec = currentTime.tv_sec ;
        targetDate.tv_usec = currentTime.tv_usec + _timeToSpend ;
        for( targetDate.tv_usec = currentTime.tv_usec + _timeToSpend ; 
             1000000l < targetDate.tv_usec ; 
             targetDate.tv_usec -= 1000000l )
        { // Add a seconde until targetDate.tv_usec is in range (< 10000000usec)
          targetDate.tv_sec++ ;
        }

        while( currentTime.tv_sec < targetDate.tv_sec
            || ( currentTime.tv_sec == targetDate.tv_sec
               && currentTime.tv_usec < targetDate.tv_usec ) )
        { // The dummy loop until date is reached
            gettimeofday( &currentTime, NULL );
        }
#endif

      } 
      else
      { 
        // Passive sleep => nanosleep call
#ifdef _MSC_VER
        // TODO / FIX Windows "Sleep" is not precise enough (~10ms), and current method is :
            // 1. First, make PASSIVE SLEEP as much as possible (milli-second granularity)
        Sleep(_timeToSpend/1000);
                // 2. Then, spend the rest of time with active sleep
                long currentStep = (long)(( currentDate.QuadPart - newCallDate.QuadPart )*1000000/_processorFrequency.QuadPart ) ; // Get step in micro-sec
                while( currentStep < _timeToSpend){
                        QueryPerformanceCounter( &currentDate ) ;
                        currentStep = (long)( ( currentDate.QuadPart - newCallDate.QuadPart )*1000000/_processorFrequency.QuadPart ) ; // Get step in micro-sec
                }
#else
                timespec sleepNanoTime;
        sleepNanoTime.tv_sec = 0;
        sleepNanoTime.tv_nsec = _timeToSpend * 1000l ;
        nanosleep( &sleepNanoTime, NULL );
#endif
      }
    }
  }
  // store the call date for next call
  _lastCallDate = newCallDate;

  ExtensibleSimulatedObject::compute();
}
//===================================================================

---