bhe Class Reference

#include "bhe.h"

Inheritance diagram for bhe:

Collaboration diagram for bhe:

Public Member Functions
LIBCA_API	bhe (epicsMutex &, const epicsTime &initialTimeStamp, unsigned initialBeaconNumber, const inetAddrID &addr)
LIBCA_API	~bhe ()
LIBCA_API bool	updatePeriod (epicsGuard< epicsMutex > &, const epicsTime &programBeginTime, const epicsTime &currentTime, ca_uint32_t beaconNumber, unsigned protocolRevision)
LIBCA_API double	period (epicsGuard< epicsMutex > &) const
LIBCA_API epicsTime	updateTime (epicsGuard< epicsMutex > &) const
LIBCA_API void	show (unsigned level) const
LIBCA_API void	show (epicsGuard< epicsMutex > &, unsigned) const
LIBCA_API void	registerIIU (epicsGuard< epicsMutex > &, tcpiiu &)
LIBCA_API void	unregisterIIU (epicsGuard< epicsMutex > &, tcpiiu &)
LIBCA_API void *	operator new (size_t size, bheMemoryManager &)
Public Member Functions inherited from tsSLNode< bhe >
	tsSLNode ()
tsSLNode< bhe > &	operator= (const tsSLNode< bhe > &)
Public Member Functions inherited from inetAddrID
	inetAddrID (const struct sockaddr_in &addrIn)
bool	operator== (const inetAddrID &) const
resTableIndex	hash () const
void	name (char *pBuf, unsigned bufSize) const

Detailed Description

Definition at line 45 of file bhe.h.

Constructor & Destructor Documentation

bhe::bhe	(	epicsMutex &	mutexIn,
		const epicsTime &	initialTimeStamp,
		unsigned	initialBeaconNumber,
		const inetAddrID &	addr
	)

Definition at line 48 of file bhe.cpp.

                                                                  :
    inetAddrID ( addr ), timeStamp ( initialTimeStamp ), averagePeriod ( - DBL_MAX ),
    mutex ( mutexIn ), pIIU ( 0 ), lastBeaconNumber ( initialBeaconNumber )
{
#   ifdef DEBUG
    {
        char name[64];
        addr.name ( name, sizeof ( name ) );
        ::printf ( "created beacon entry for %s\n", name );
    }
#   endif
}

bhe::~bhe

(

)

Definition at line 62 of file bhe.cpp.

{
}

Member Function Documentation

void * bhe::operator new ( size_t  size, bheMemoryManager &  mgr  )

inline

Definition at line 96 of file bhe.h.

{
    return mgr.allocate ( size );
}

double bhe::period

(

epicsGuard< epicsMutex > &

guard

)

const

Definition at line 302 of file bhe.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    return this->averagePeriod;
}

void bhe::registerIIU	(	epicsGuard< epicsMutex > &	guard,
		tcpiiu &	iiu
	)

Definition at line 314 of file bhe.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    this->pIIU = & iiu;
}

void bhe::show

(

unsigned

level

)

const

Definition at line 276 of file bhe.cpp.

{
    epicsGuard < epicsMutex > guard ( this->mutex );
    this->show ( guard, level );
}

void bhe::show	(	epicsGuard< epicsMutex > &	,
		unsigned	level
	)		const

Definition at line 282 of file bhe.cpp.

{
    char host [64];
    this->name ( host, sizeof ( host ) );
    if ( this->averagePeriod == -DBL_MAX ) {
        ::printf ( "CA beacon hash entry for %s <no period estimate>\n",
            host );
    }
    else {
        ::printf ( "CA beacon hash entry for %s with period estimate %f\n",
            host, this->averagePeriod );
    }
    if ( level > 0u ) {
        char date[64];
        this->timeStamp.strftime ( date, sizeof ( date ), "%a %b %d %Y %H:%M:%S");
        ::printf ( "\tbeacon number %u, on %s\n",
            this->lastBeaconNumber, date );
    }
}

void bhe::unregisterIIU	(	epicsGuard< epicsMutex > &	guard,
		tcpiiu &	iiu
	)

Definition at line 321 of file bhe.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    if ( this->pIIU == & iiu ) {
        this->pIIU = 0;
        this->timeStamp = epicsTime();
        this->averagePeriod = - DBL_MAX;
        logBeacon ( "ui", this->averagePeriod, epicsTime::getCurrent () );
    }
}

bool bhe::updatePeriod	(	epicsGuard< epicsMutex > &	guard,
		const epicsTime &	programBeginTime,
		const epicsTime &	currentTime,
		ca_uint32_t	beaconNumber,
		unsigned	protocolRevision
	)

Definition at line 124 of file bhe.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );

    //
    // this block is enetered if the beacon was created as a side effect of
    // creating a connection and so we dont yet know the first beacon time
    // and  sequence number
    //
    if ( this->timeStamp == epicsTime () ) {
        if ( CA_V410 ( protocolRevision ) ) {
            this->lastBeaconNumber = beaconNumber;
        }

        this->beaconAnomalyNotify ( guard );

        /*
         * this is the 1st beacon seen - the beacon time stamp
         * was not initialized during BHE create because
         * a TCP/IP connection created the beacon.
         * (nothing to do but set the beacon time stamp and return)
         */
        this->timeStamp = currentTime;

        logBeacon ( "fb", - DBL_MAX, currentTime );

        return false;
    }

    // 1) detect beacon duplications due to redundant routes
    // 2) detect lost beacons due to input queue overrun or damage
    if ( CA_V410 ( protocolRevision ) ) {
        unsigned beaconSeqAdvance;
        if ( beaconNumber >= this->lastBeaconNumber ) {
            beaconSeqAdvance = beaconNumber - this->lastBeaconNumber;
        }
        else {
            beaconSeqAdvance = ( ca_uint32_max - this->lastBeaconNumber ) + beaconNumber;
        }
        this->lastBeaconNumber = beaconNumber;

        // throw out sequence numbers just prior to, or the same as, the last one received
        // (this situation is probably caused by a temporary duplicate route )
        if ( beaconSeqAdvance == 0 ||  beaconSeqAdvance > ca_uint32_max - 256 ) {
            logBeaconDiscard ( beaconSeqAdvance, currentTime );
            return false;
        }

        // throw out sequence numbers that jump forward by only a few numbers
        // (this situation is probably caused by a duplicate route
        // or a beacon due to input queue overun)
        if ( beaconSeqAdvance > 1 &&  beaconSeqAdvance < 4 ) {
            logBeaconDiscard ( beaconSeqAdvance, currentTime );
            return false;
        }
    }

    // compute the beacon period (if we have seen at least two beacons)
    bool netChange = false;
    double currentPeriod = currentTime - this->timeStamp;

    if ( this->averagePeriod < 0.0 ) {
        double totalRunningTime;

        this->beaconAnomalyNotify ( guard );

        /*
         * this is the 2nd beacon seen. We cant tell about
         * the change in period at this point so we just
         * initialize the average period and return.
         */
        this->averagePeriod = currentPeriod;

        logBeacon ( "fp", currentPeriod, currentTime );


        /*
         * ignore beacons seen for the first time shortly after
         * init, but do not ignore beacons arriving with a short
         * period because the IOC was rebooted soon after the
         * client starts up.
         */
        totalRunningTime = this->timeStamp - programBeginTime;
        if ( currentPeriod <= totalRunningTime ) {
            netChange = true;
        }
    }
    else {

        /*
         * Is this an IOC seen because of a restored
         * network segment?
         *
         * It may be possible to get false triggers here
         * if the client is busy, but this does not cause
         * problems because the echo response will tell us
         * that the server is available
         */
        if ( currentPeriod >= this->averagePeriod * 1.25 ) {

            /*
             * trigger on any missing beacon
             * if connected to this server
             */
            this->beaconAnomalyNotify ( guard );

            if ( currentPeriod >= this->averagePeriod * 3.25 ) {
                /*
                 * trigger on any 3 contiguous missing beacons
                 * if not connected to this server
                 */
                netChange = true;
            }
            logBeacon ( "bah", currentPeriod, currentTime );
        }

        /*
         * Is this an IOC seen because of an IOC reboot
         * (beacon come at a higher rate just after the
         * IOC reboots). Lower tolarance here because we
         * dont have to worry about lost beacons.
         *
         * It may be possible to get false triggers here
         * if the client is busy, but this does not cause
         * problems because the echo response will tell us
         * that the server is available
         */
        else if ( currentPeriod <= this->averagePeriod * 0.80 ) {
            this->beaconAnomalyNotify ( guard );
            netChange = true;
            logBeacon ( "bal", currentPeriod, currentTime );
        }
        else if ( this->pIIU ) {
            // update state of health for active virtual circuits
            // if the beacon looks ok
            this->pIIU->beaconArrivalNotify ( guard );
            logBeacon ( "vb", currentPeriod, currentTime );
        }

        // update a running average period
        this->averagePeriod = currentPeriod * 0.125 +
            this->averagePeriod * 0.875;
    }

    this->timeStamp = currentTime;

    return netChange;
}

epicsTime bhe::updateTime

(

epicsGuard< epicsMutex > &

guard

)

const

Definition at line 308 of file bhe.cpp.

{
    guard.assertIdenticalMutex ( this->mutex );
    return this->timeStamp;
}

---

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

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