searchTimer Class Reference

#include "searchTimer.h"

Inheritance diagram for searchTimer:

Collaboration diagram for searchTimer:

Public Member Functions
	searchTimer (class searchTimerNotify &, epicsTimerQueue &, const unsigned index, epicsMutex &, bool boostPossible)
virtual	~searchTimer ()
void	start (epicsGuard< epicsMutex > &)
void	shutdown (epicsGuard< epicsMutex > &cbGuard, epicsGuard< epicsMutex > &guard)
void	moveChannels (epicsGuard< epicsMutex > &, searchTimer &dest)
void	installChannel (epicsGuard< epicsMutex > &, nciu &)
void	uninstallChan (epicsGuard< epicsMutex > &, nciu &)
void	uninstallChanDueToSuccessfulSearchResponse (epicsGuard< epicsMutex > &, nciu &, ca_uint32_t respDatagramSeqNo, bool seqNumberIsValid, const epicsTime &currentTime)
void	show (unsigned level) const

Detailed Description

Definition at line 52 of file searchTimer.h.

Constructor & Destructor Documentation

searchTimer::searchTimer	(	class searchTimerNotify &	iiuIn,
		epicsTimerQueue &	queueIn,
		const unsigned	index,
		epicsMutex &	mutexIn,
		bool	boostPossible
	)

Definition at line 38 of file searchTimer.cpp.

                               :
    timeAtLastSend ( epicsTime::getCurrent () ),
    timer ( queueIn.createTimer () ),
    iiu ( iiuIn ),
    mutex ( mutexIn ),
    framesPerTry ( initialTriesPerFrame ),
    framesPerTryCongestThresh ( DBL_MAX ),
    retry ( 0 ),
    searchAttempts ( 0u ),
    searchResponses ( 0u ),
    index ( indexIn ),
    dgSeqNoAtTimerExpireBegin ( 0u ),
    dgSeqNoAtTimerExpireEnd ( 0u ),
    boostPossible ( boostPossibleIn ),
    stopped ( false )
{
}

searchTimer::~searchTimer ( )

virtual

Definition at line 67 of file searchTimer.cpp.

{
    assert ( this->chanListReqPending.count() == 0 );
    assert ( this->chanListRespPending.count() == 0 );
    this->timer.destroy ();
}

Member Function Documentation

void searchTimer::installChannel	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan
	)

Definition at line 99 of file searchTimer.cpp.

{
    this->chanListReqPending.add ( chan );
    chan.channelNode::setReqPendingState ( guard, this->index );
}

void searchTimer::moveChannels	(	epicsGuard< epicsMutex > &	guard,
		searchTimer &	dest
	)

Definition at line 106 of file searchTimer.cpp.

{
    while ( nciu * pChan = this->chanListRespPending.get () ) {
        if ( this->searchAttempts > 0 ) {
            this->searchAttempts--;
        }
        dest.installChannel ( guard, *pChan );
    }
    while ( nciu * pChan = this->chanListReqPending.get () ) {
        dest.installChannel ( guard, *pChan );
    }
}

void searchTimer::show

(

unsigned

level

)

const

Definition at line 289 of file searchTimer.cpp.

{
    epicsGuard < epicsMutex > guard ( this->mutex );
    ::printf ( "searchTimer with period %f\n", this->period ( guard ) );
    if ( level > 0 ) {
        ::printf ( "channels with search request pending = %u\n",
            this->chanListReqPending.count () );
        if ( level > 1u ) {
            tsDLIterConst < nciu > pChan =
                this->chanListReqPending.firstIter ();
            while ( pChan.valid () ) {
                pChan->show ( level - 2u );
                pChan++;
            }
        }
        ::printf ( "channels with search response pending = %u\n",
            this->chanListRespPending.count () );
        if ( level > 1u ) {
            tsDLIterConst < nciu > pChan =
                this->chanListRespPending.firstIter ();
            while ( pChan.valid () ) {
                pChan->show ( level - 2u );
                pChan++;
            }
        }
    }
}

void searchTimer::shutdown	(	epicsGuard< epicsMutex > &	cbGuard,
		epicsGuard< epicsMutex > &	guard
	)

Definition at line 74 of file searchTimer.cpp.

{
    this->stopped = true;
    {
        epicsGuardRelease < epicsMutex > unguard ( guard );
        {
            epicsGuardRelease < epicsMutex > cbUnguard ( cbGuard );
            this->timer.cancel ();
        }
    }

    while ( nciu * pChan = this->chanListReqPending.get () ) {
        pChan->channelNode::listMember =
            channelNode::cs_none;
        pChan->serviceShutdownNotify ( cbGuard, guard );
    }
    while ( nciu * pChan = this->chanListRespPending.get () ) {
        pChan->channelNode::listMember =
            channelNode::cs_none;
        pChan->serviceShutdownNotify ( cbGuard, guard );
    }
}

void searchTimer::start

(

epicsGuard< epicsMutex > &

guard

)

Definition at line 61 of file searchTimer.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    this->timer.start ( *this, this->period ( guard ) );
}

void searchTimer::uninstallChan	(	epicsGuard< epicsMutex > &	cacGuard,
		nciu &	chan
	)

Definition at line 363 of file searchTimer.cpp.

{
    cacGuard.assertIdenticalMutex ( this->mutex );
    unsigned ulistmem =
        static_cast <unsigned> ( chan.channelNode::listMember );
    unsigned uReqBase =
        static_cast <unsigned> ( channelNode::cs_searchReqPending0 );
    if ( ulistmem == this->index + uReqBase ) {
        this->chanListReqPending.remove ( chan );
    }
    else {
        unsigned uRespBase =
            static_cast <unsigned > (
                channelNode::cs_searchRespPending0 );
        if ( ulistmem == this->index + uRespBase ) {
            this->chanListRespPending.remove ( chan );
        }
        else {
            throw std::runtime_error (
                "uninstalling channel search timer, but channel "
                "state is wrong" );
        }
    }
    chan.channelNode::listMember = channelNode::cs_none;
}

void searchTimer::uninstallChanDueToSuccessfulSearchResponse	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan,
		ca_uint32_t	respDatagramSeqNo,
		bool	seqNumberIsValid,
		const epicsTime &	currentTime
	)

Definition at line 322 of file searchTimer.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    this->uninstallChan ( guard, chan );

    if ( this->stopped ) {
        return;
    }

    bool validResponse = true;
    if ( seqNumberIsValid ) {
        validResponse =
            this->dgSeqNoAtTimerExpireBegin <= respDatagramSeqNo &&
                this->dgSeqNoAtTimerExpireEnd >= respDatagramSeqNo;
    }

    // if we receive a successful response then reset to a
    // reasonable timer period
    if ( validResponse ) {
        double measured = currentTime - this->timeAtLastSend;
        this->iiu.updateRTTE ( guard, measured );

        if ( this->searchResponses < UINT_MAX ) {
            this->searchResponses++;
            if ( this->searchResponses == this->searchAttempts ) {
                if ( this->chanListReqPending.count () ) {
                    //
                    // when we get 100% success immediately
                    // send another search request
                    //
                    debugPrintf ( ( "All requests succesful, set timer delay to zero\n" ) );
                    this->timer.start ( *this, currentTime );
                }
            }
        }
    }
}

---

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

• modules/ca/src/client/searchTimer.h
• modules/ca/src/client/searchTimer.cpp