timerQueue Class Reference

#include "timerPrivate.h"

Inheritance diagram for timerQueue:

Collaboration diagram for timerQueue:

Public Member Functions
	timerQueue (epicsTimerQueueNotify &notify)
virtual	~timerQueue ()
epicsTimer &	createTimer ()
epicsTimerForC &	createTimerForC (epicsTimerCallback pCallback, void *pArg)
double	process (const epicsTime &currentTime)
void	show (unsigned int level) const

Friends
class	timer
struct	epicsTimerForC

Detailed Description

Definition at line 88 of file timerPrivate.h.

Constructor & Destructor Documentation

timerQueue::timerQueue

(

epicsTimerQueueNotify &

notify

)

Definition at line 26 of file timerQueue.cpp.

                                                          :
    mutex(__FILE__, __LINE__),
    notify ( notifyIn ),
    pExpireTmr ( 0 ),
    processThread ( 0 ),
    exceptMsgTimeStamp (
        epicsTime :: getCurrent () - exceptMsgMinPeriod ),
    cancelPending ( false )
{
}

timerQueue::~timerQueue ( )

virtual

Definition at line 37 of file timerQueue.cpp.

{
    timer *pTmr;
    while ( ( pTmr = this->timerList.get () ) ) {
        pTmr->curState = timer::stateLimbo;
    }
}

Member Function Documentation

epicsTimer & timerQueue::createTimer

(

)

Definition at line 204 of file timerQueue.cpp.

{
    return * new ( this->timerFreeList ) timer ( * this );
}

epicsTimerForC & timerQueue::createTimerForC	(	epicsTimerCallback	pCallback,
		void *	pArg
	)

Definition at line 209 of file timerQueue.cpp.

{
    return * new ( this->timerForCFreeList ) epicsTimerForC ( *this, pCallback, pArg );
}

double timerQueue::process

(

const epicsTime &

currentTime

)

Definition at line 78 of file timerQueue.cpp.

{
    epicsGuard < epicsMutex > guard ( this->mutex );

    if ( this->pExpireTmr ) {
        // if some other thread is processing the queue
        // (or if this is a recursive call)
        timer * pTmr = this->timerList.first ();
        if ( pTmr ) {
            double delay = pTmr->exp - currentTime;
            if ( delay < 0.0 ) {
                delay = 0.0;
            }
            return delay;
        }
        else {
            return DBL_MAX;
        }
    }

    //
    // Tag current epired tmr so that we can detect if call back
    // is in progress when canceling the timer.
    //
    if ( this->timerList.first () ) {
        if ( currentTime >= this->timerList.first ()->exp ) {
            this->pExpireTmr = this->timerList.first ();
            this->timerList.remove ( *this->pExpireTmr );
            this->pExpireTmr->curState = timer::stateActive;
            this->processThread = epicsThreadGetIdSelf ();
#           ifdef DEBUG
                this->pExpireTmr->show ( 0u );
#           endif
        }
        else {
            double delay = this->timerList.first ()->exp - currentTime;
            debugPrintf ( ( "no activity process %f to next\n", delay ) );
            return delay;
        }
    }
    else {
        return DBL_MAX;
    }

#   ifdef DEBUG
        unsigned N = 0u;
#   endif

    double delay = DBL_MAX;
    while ( true ) {
        epicsTimerNotify *pTmpNotify = this->pExpireTmr->pNotify;
        this->pExpireTmr->pNotify = 0;
        epicsTimerNotify::expireStatus expStat ( epicsTimerNotify::noRestart );

        {
            epicsGuardRelease < epicsMutex > unguard ( guard );

            debugPrintf ( ( "%5u expired \"%s\" with error %f sec\n",
                N++, typeid ( this->pExpireTmr->notify ).name (),
                currentTime - this->pExpireTmr->exp ) );
            try {
                expStat = pTmpNotify->expire ( currentTime );
            }
            catch ( std::exception & except ) {
                printExceptMsg ( except.what (), typeid ( except ) );
            }
            catch ( ... ) {
                printExceptMsg ( "non-standard exception", typeid ( void ) );
            }
        }

        //
        // only restart if they didnt cancel() the timer
        // while the call back was running
        //
        if ( this->cancelPending ) {
            // 1) if another thread is canceling then cancel() waits for
            // the event below
            // 2) if this thread is canceling in the timer callback then
            // dont touch timer or notify here because the cancel might
            // have occurred because they destroyed the timer in the
            // callback
            this->cancelPending = false;
            this->cancelBlockingEvent.signal ();
        }
        else {
            this->pExpireTmr->curState = timer::stateLimbo;
            if ( this->pExpireTmr->pNotify ) {
                // pNotify was cleared above so if it is valid now we know that
                // someone has started the timer from another thread and that
                // predominates over the restart parameters from expire.
                this->pExpireTmr->privateStart (
                    *this->pExpireTmr->pNotify, this->pExpireTmr->exp );
            }
            else if ( expStat.restart() ) {
                // restart as nec
                this->pExpireTmr->privateStart (
                    *pTmpNotify, currentTime + expStat.expirationDelay() );
            }
        }
        this->pExpireTmr = 0;

        if ( this->timerList.first () ) {
            if ( currentTime >= this->timerList.first ()->exp ) {
                this->pExpireTmr = this->timerList.first ();
                this->timerList.remove ( *this->pExpireTmr );
                this->pExpireTmr->curState = timer::stateActive;
#               ifdef DEBUG
                    this->pExpireTmr->show ( 0u );
#               endif
            }
            else {
                delay = this->timerList.first ()->exp - currentTime;
                this->processThread = 0;
                break;
            }
        }
        else {
            this->processThread = 0;
            delay = DBL_MAX;
            break;
        }
    }
    return delay;
}

void timerQueue::show

(

unsigned int

level

)

const

Definition at line 214 of file timerQueue.cpp.

{
    epicsGuard < epicsMutex > locker ( this->mutex );
    printf ( "epicsTimerQueue with %u items pending\n", this->timerList.count () );
    if ( level >= 1u ) {
        tsDLIterConst < timer > iter = this->timerList.firstIter ();
        while ( iter.valid () ) {
            iter->show ( level - 1u );
            ++iter;
        }
    }
}

Friends And Related Function Documentation

friend struct epicsTimerForC

friend

Definition at line 113 of file timerPrivate.h.

friend class timer

friend

Definition at line 112 of file timerPrivate.h.

---

The documentation for this class was generated from the following files:

• modules/libcom/src/timer/timerPrivate.h
• modules/libcom/src/timer/timerQueue.cpp