C:/Active/libraries/cxutils/2.0/src/cxutils/timer.cpp

Go to the documentation of this file.

#include "cxutils/timer.h"
#include "cxutils/time.h"
#include <cxutils/math/cxmath.h>
#include <assert.h>

#ifdef WIN32
#include <windows.h>
#include <mmsystem.h>
#else
#include <sys/time.h>
#endif

using namespace CxUtils;


Timer::Callback::Function::Function(void (*func)(void* args), void* fargs)
{
    mpFunctionPtr = func;
    mpFunctionArgs = fargs;
}


Timer::Callback::Function::~Function()
{
}


void Timer::Callback::Function::Run()
{
    if(mpFunctionPtr)
    {
        mpFunctionPtr(mpFunctionArgs);
    }
}


#ifdef WIN32
class Timer::Data
{
public:
    Data()
    {
        mResult = 0;
        mLeaveFlag = true;
        mEnteredFlag = false;
        mStopCounter = -1;
        mKillTimer = false;
        InitializeCriticalSection(&mCritSection);
        InitializeCriticalSection(&mDelayCritSection);
    }
    ~Data()
    {
        if(mResult)
            mResult = timeKillEvent(mResult);
        DeleteCriticalSection(&mCritSection);
        DeleteCriticalSection(&mDelayCritSection);
    }
    Timer* mpTimer;
    static void CALLBACK PauseTimerProcedure(UINT id, UINT msg, DWORD_PTR user, DWORD_PTR one, DWORD_PTR two);
    static void CALLBACK TimerProcedure(UINT id, UINT msg, DWORD_PTR user, DWORD_PTR one, DWORD_PTR two);
    MMRESULT          mResult;              
    CRITICAL_SECTION  mCritSection;         
    CRITICAL_SECTION  mDelayCritSection;    
    volatile bool     mEnteredFlag;         
    volatile bool     mLeaveFlag;           
    volatile int      mStopCounter;         
    volatile bool     mKillTimer;           
};
#endif



Timer::Timer()
{
#ifdef WIN32
    mpTimerData = new Timer::Data();
    ((Timer::Data*)(mpTimerData))->mpTimer = this;
#endif
    mTimerActive = false;
    mDelayTimeMs = 0;
    mShutdownFlag = false;
}


Timer::~Timer()
{
    Stop();
#ifdef WIN32
    delete mpTimerData;
#endif
}


int Timer::Start(const double frequencyHz,
                 const double hptThresholdHz)
{
    Stop(); // Stops the active timer if running.
    
    mShutdownFlag = false;
    
    // Calculate delay time (avoid divide by 0).
    mDelayTimeMs = (unsigned int)(1000.0/(frequencyHz + CX_EPSILON));
    if(mDelayTimeMs == 0)
    {
        mDelayTimeMs = 1;
    }
#ifdef WIN32
    if(frequencyHz > hptThresholdHz)
    {
        ((Timer::Data *)(mpTimerData))->mKillTimer = false;
        ((Timer::Data *)(mpTimerData))->mResult = timeSetEvent(mDelayTimeMs, 
                                                             0, 
                                                             &Timer::Data::TimerProcedure, 
                                                             (DWORD_PTR)this->mpTimerData,
                                                             TIME_PERIODIC);
        if( ((Timer::Data *)(mpTimerData))->mResult != NULL ) 
        {
            mTimerActive = true;
            return 1;
        }
    }
    else
    {
        if(mTimerEventThread.CreateThread(&TimerEventThread, this)) 
        {
            mTimerEventThread.SetThreadPriority(50);
            mTimerActive = true;
            return 1;
        }
    }
#else
    if(mTimerEventThread.CreateThread(&TimerEventThread, this)) 
    {
        mTimerEventThread.SetThreadPriority(50);
        mTimerActive = true;
        return 1;
    }
#endif

    return 0;
}



void Timer::Stop()
{
    mShutdownFlag = true;
#ifdef WIN32
    if(((Timer::Data *)(mpTimerData))->mResult) 
    {
        ((Timer::Data *)(mpTimerData))->mKillTimer = true;
        ((Timer::Data *)(mpTimerData))->mResult = timeKillEvent(((Timer::Data *)(mpTimerData))->mResult);
        return;
    }
    ((Timer::Data *)(mpTimerData))->mKillTimer = false;    
#endif
    mTimerEventThread.StopThread(1000);

    mTimerActive = false;
}


bool Timer::RegisterTimerEvent(Timer::Callback* timerCallback)
{
    bool result = false;
    Callback::Set::iterator cb;
    mCallbacksMutex.Lock();
    cb = mCallbackObjects.find(timerCallback);
    if(cb == mCallbackObjects.end())
    {
        mCallbackObjects.insert(timerCallback);
        result = true;
    }
    mCallbacksMutex.Unlock();
    return result;
}


bool Timer::RegisterTimerEvent(void (*func)(void *args), void* fargs)
{
    bool result = true;
    mCallbacksMutex.Lock();
    mCallbackFunctions.push_back(Timer::Callback::Function(func, fargs));
    mCallbacksMutex.Unlock();
    return result;
}


void Timer::RemoveTimerEvent(Timer::Callback* timerCallback)
{
    Callback::Set::iterator cb;
    mCallbacksMutex.Lock();
    cb = mCallbackObjects.find(timerCallback);
    if(cb != mCallbackObjects.end())
    {
        mCallbackObjects.erase(cb);
    }
    mCallbacksMutex.Unlock();
}


void Timer::RemoveTimerEvent(void (*func)(void *args), void* fargs)
{
    Callback::Function::List::iterator cb;
    mCallbacksMutex.Lock();
    for(cb = mCallbackFunctions.begin();
        cb != mCallbackFunctions.end();
        cb++)
    {
        if(cb->mpFunctionPtr == func && cb->mpFunctionArgs == fargs)
        {
            mCallbackFunctions.erase(cb);
            break;
        }
    }
    mCallbacksMutex.Unlock();
}


void Timer::Pause(const unsigned int ms)
{
    if(ms > 0) 
    { 
#ifdef WIN32
        Timer timer;
        EnterCriticalSection( &((Timer::Data *)(timer.mpTimerData))->mDelayCritSection );

        if (((Timer::Data *)(timer.mpTimerData))->mResult == NULL) 
        {
            ((Timer::Data *)(timer.mpTimerData))->mResult = timeSetEvent(1, 
                                                                       0, 
                                                                       &Timer::Data::PauseTimerProcedure, 
                                                                       (DWORD_PTR)timer.mpTimerData,
                                                                       TIME_PERIODIC);
            assert(((Timer::Data *)(timer.mpTimerData))->mResult);
        }

        ((Timer::Data *)(timer.mpTimerData))->mStopCounter = (int)ms;
        ((Timer::Data *)(timer.mpTimerData))->mLeaveFlag = false;
        ((Timer::Data *)(timer.mpTimerData))->mEnteredFlag = false;
        while(!((Timer::Data *)(timer.mpTimerData))->mEnteredFlag) {}
        //Perform the delay using Critical Sections.
        EnterCriticalSection(&((Timer::Data *)(timer.mpTimerData))->mCritSection);
        LeaveCriticalSection(&((Timer::Data *)(timer.mpTimerData))->mCritSection);
        LeaveCriticalSection(&((Timer::Data *)(timer.mpTimerData))->mDelayCritSection );
#else
        usleep(ms*1000);
#endif
    }
}


double Timer::GetTimeMs()
{
#ifdef WIN32
    LARGE_INTEGER count;
    static LARGE_INTEGER freq;
    
    if(freq.QuadPart == 0) 
    {
        if(QueryPerformanceFrequency(&freq))
        {
            freq.QuadPart /= 1000;
        }
        else
        {
            // High performance timer not available on system.
            freq.QuadPart = 0;
            return (double)CxUtils::GetTimeMs();
        }
    }
    if(freq.QuadPart != 0)
    {
        if(QueryPerformanceCounter(&count)) 
        {
            return (double)count.QuadPart/(double)freq.QuadPart;
        }
        else
        {
            return (double)CxUtils::GetTimeMs();
        }
    }  
    return (double)CxUtils::GetTimeMs();
#else
    return (double)CxUtils::GetTimeMs();
#endif
}


double Timer::GetTimeSeconds() { return GetTimeMs()/1000.0; }

#ifdef WIN32


void CALLBACK  Timer::Data::PauseTimerProcedure(UINT id, 
                                   UINT msg, 
                                   DWORD_PTR user, 
                                   DWORD_PTR one, 
                                   DWORD_PTR two)
{
    Timer::Data* pData = (Timer::Data*)user;
    if(pData) 
    {
        //  Block using the critical section. 
        if (!pData->mEnteredFlag && !pData->mLeaveFlag) 
        {
            EnterCriticalSection(&pData->mCritSection);
            pData->mEnteredFlag = true;   
            --pData->mStopCounter;
        }        
        //  Otherwise decrement the stop counter. 
        else if  (pData->mEnteredFlag && !pData->mLeaveFlag && pData->mStopCounter > 0) 
        {
            --pData->mStopCounter;
            // Unlock the critical section if the counter has
            // expired. 
            if (pData->mStopCounter == 0 || pData->mKillTimer) 
            {                 
                LeaveCriticalSection(&pData->mCritSection);
                pData->mLeaveFlag = true;
                pData->mKillTimer = false;
            }
        }
    }
}


void CALLBACK Timer::Data::TimerProcedure(UINT id, 
                             UINT msg, 
                             DWORD_PTR user, 
                             DWORD_PTR one, 
                             DWORD_PTR two)
{
    Timer::Data* pData = (Timer::Data*)user;
    if (pData && !pData->mKillTimer) 
    {
        // Run Callbacks.
        pData->mpTimer->TriggerEvents();
    }
}

#endif

void Timer::TimerEventThread(void *args)
{
    Timer* pThis = (Timer*)args;
#ifdef WIN32
    double eventTimeMs = 0;
#endif

    while(!pThis->mTimerEventThread.QuitThreadFlag()) 
    {
#ifdef WIN32
        if(Timer::GetTimeMs() - eventTimeMs >= pThis->mDelayTimeMs)
        {
            // Run event callbacks.
            pThis->TriggerEvents();
            eventTimeMs = Timer::GetTimeMs();
        }
        Sleep(1);
#else
        
        pThis->mSleepMutex.Lock();
        unsigned int delayMs = (unsigned int)(pThis->mDelayTimeMs*1000);
        pThis->mSleepMutex.Unlock();
        usleep(delayMs);
        // Run event callbacks.
        pThis->TriggerEvents();
#endif
    }
}


void Timer::TriggerEvents()
{
    Callback::Set::iterator cbObject;
    Callback::Function::List::iterator cbFunction;

    mCallbacksMutex.Lock();
    for(cbObject = mCallbackObjects.begin();
        cbObject != mCallbackObjects.end() && mShutdownFlag == false;
        cbObject++)
    {
        (*cbObject)->ProcessTimerEvent();
    }

    for(cbFunction = mCallbackFunctions.begin();
        cbFunction != mCallbackFunctions.end() && mShutdownFlag == false;
        cbFunction++)
    {
        cbFunction->Run();
    }

    mCallbacksMutex.Unlock();
}


double Timer::GetFrequency() const 
{ 
    return 1.0/(CX_EPSILON + mDelayTimeMs/1000.0); 
}



bool Timer::ChangeFrequency(const double frequencyHz, const double hptThresholdHz)
{
    if(mTimerActive)
    {
#ifdef WIN32
        // Check for use/need for HPT.  If we are using the HPT we
        // must stop it and restart it.  Or if the desired freq is
        // >= hptThresholHz, we start over again.
        if(frequencyHz >= hptThresholdHz || mTimerEventThread.IsThreadActive() == false)
        {
            Stop();
            return Start(frequencyHz, hptThresholdHz) > 0 ? true : false;
        }
#endif
        Mutex::ScopedLock lock(&mSleepMutex);
        // Calculate delay time (avoid divide by 0).
        mDelayTimeMs = (unsigned int)(1000.0/(frequencyHz + CX_EPSILON));
        if(mDelayTimeMs == 0)
        {
            mDelayTimeMs = 1;
        }
        return true;
    }
    return false;
}


/*  End of File */