syncgrp.cpp File Reference

#include "iocinf.h"
#include "oldAccess.h"
#include "syncGroup.h"

Include dependency graph for syncgrp.cpp:

Go to the source code of this file.

Macros
#define	epicsAssertAuthor   "Jeff Hill johill@lanl.gov"

Functions
int epicsStdCall	ca_sg_create (CA_SYNC_GID *pgid)
int	ca_sync_group_destroy (CallbackGuard &cbGuard, epicsGuard< epicsMutex > &guard, ca_client_context &cac, const CA_SYNC_GID gid)
int epicsStdCall	ca_sg_delete (const CA_SYNC_GID gid)
void	sync_group_reset (ca_client_context &client, CASG &sg)
int epicsStdCall	ca_sg_block (const CA_SYNC_GID gid, ca_real timeout)
int epicsStdCall	ca_sg_reset (const CA_SYNC_GID gid)
int epicsStdCall	ca_sg_stat (const CA_SYNC_GID gid)
int epicsStdCall	ca_sg_test (const CA_SYNC_GID gid)
int epicsStdCall	ca_sg_array_put (const CA_SYNC_GID gid, chtype type, arrayElementCount count, chid pChan, const void *pValue)
int epicsStdCall	ca_sg_array_get (const CA_SYNC_GID gid, chtype type, arrayElementCount count, chid pChan, void *pValue)

Macro Definition Documentation

#define epicsAssertAuthor   "Jeff Hill johill@lanl.gov"

Definition at line 15 of file syncgrp.cpp.

Function Documentation

int epicsStdCall ca_sg_array_get	(	const CA_SYNC_GID	gid,
		chtype	type,
		arrayElementCount	count,
		chid	pChan,
		void *	pValue
	)

Definition at line 308 of file syncgrp.cpp.

{
    ca_client_context *pcac;

    int caStatus = fetchClientContext ( &pcac );
    if ( caStatus != ECA_NORMAL ) {
        return caStatus;
    }

    epicsGuard < epicsMutex > guard ( pcac->mutexRef() );
    CASG * const pcasg = pcac->lookupCASG ( guard, gid );
    if ( ! pcasg ) {
        return ECA_BADSYNCGRP;
    }

    try {
        pcasg->get ( guard, pChan, type,
            static_cast < unsigned > ( count ), pValue );
        return ECA_NORMAL;
    }
    catch ( cacChannel::badString & )
    {
        return ECA_BADSTR;
    }
    catch ( cacChannel::badType & )
    {
        return ECA_BADTYPE;
    }
    catch ( cacChannel::outOfBounds & )
    {
        return ECA_BADCOUNT;
    }
    catch ( cacChannel::noReadAccess & )
    {
        return ECA_NORDACCESS;
    }
    catch ( cacChannel::notConnected & )
    {
        return ECA_DISCONN;
    }
    catch ( cacChannel::unsupportedByService & )
    {
        return ECA_UNAVAILINSERV;
    }
    catch ( std::bad_alloc & )
    {
        return ECA_ALLOCMEM;
    }
    catch ( ... )
    {
        return ECA_INTERNAL;
    }
}

int epicsStdCall ca_sg_array_put	(	const CA_SYNC_GID	gid,
		chtype	type,
		arrayElementCount	count,
		chid	pChan,
		const void *	pValue
	)

Definition at line 246 of file syncgrp.cpp.

{
    ca_client_context *pcac;

    int caStatus = fetchClientContext ( &pcac );
    if ( caStatus != ECA_NORMAL ) {
        return caStatus;
    }

    epicsGuard < epicsMutex > guard ( pcac->mutexRef() );
    CASG * const pcasg = pcac->lookupCASG ( guard, gid );
    if ( ! pcasg ) {
        return ECA_BADSYNCGRP;
    }

    try {
        pcasg->put ( guard, pChan, type,
            static_cast < unsigned > ( count ), pValue );
        return ECA_NORMAL;
    }
    catch ( cacChannel::badString & )
    {
        return ECA_BADSTR;
    }
    catch ( cacChannel::badType & )
    {
        return ECA_BADTYPE;
    }
    catch ( cacChannel::outOfBounds & )
    {
        return ECA_BADCOUNT;
    }
    catch ( cacChannel::noWriteAccess & )
    {
        return ECA_NOWTACCESS;
    }
    catch ( cacChannel::notConnected & )
    {
        return ECA_DISCONN;
    }
    catch ( cacChannel::unsupportedByService & )
    {
        return ECA_UNAVAILINSERV;
    }
    catch ( cacChannel::requestTimedOut & )
    {
        return ECA_TIMEOUT;
    }
    catch ( std::bad_alloc & )
    {
        return ECA_ALLOCMEM;
    }
    catch ( ... )
    {
        return ECA_INTERNAL;
    }
}

int epicsStdCall ca_sg_block	(	const CA_SYNC_GID	gid,
		ca_real	timeout
	)

Definition at line 127 of file syncgrp.cpp.

{
    ca_client_context *pcac;
    int status = fetchClientContext ( &pcac );
    if ( status == ECA_NORMAL ) {
        CASG * pcasg;
        {
            epicsGuard < epicsMutex > guard ( pcac->mutex );
            pcasg = pcac->lookupCASG ( guard, gid );
            if ( pcasg ) {
                status = pcasg->block (
                    pcac->pCallbackGuard.get (), guard, timeout );
            }
            else {
                status = ECA_BADSYNCGRP;
            }
        }
        if ( pcasg ) {
            sync_group_reset ( *pcac, *pcasg );
        }
    }
    return status;
}

int epicsStdCall ca_sg_create

(

CA_SYNC_GID *

pgid

)

Definition at line 24 of file syncgrp.cpp.

{
    ca_client_context * pcac;
    int caStatus;
    CASG * pcasg;

    caStatus = fetchClientContext ( &pcac );
    if ( caStatus != ECA_NORMAL ) {
        return caStatus;
    }

    try {
        epicsGuard < epicsMutex > guard ( pcac->mutexRef() );
        pcasg = new ( pcac->casgFreeList ) CASG ( guard, *pcac );
        *pgid = pcasg->getId ();
        return ECA_NORMAL;
    }
    catch ( std::bad_alloc & ) {
        return ECA_ALLOCMEM;
    }
    catch ( ... ) {
        return ECA_INTERNAL;
    }
}

int epicsStdCall ca_sg_delete

(

const CA_SYNC_GID

gid

)

Definition at line 68 of file syncgrp.cpp.

{
    ca_client_context * pcac;
    int caStatus = fetchClientContext ( & pcac );
    if ( caStatus == ECA_NORMAL ) {
        if ( pcac->pCallbackGuard.get() &&
            pcac->createdByThread == epicsThreadGetIdSelf () ) {
          epicsGuard < epicsMutex > guard ( pcac->mutex );
          caStatus = ca_sync_group_destroy ( *pcac->pCallbackGuard.get(),
                                          guard, *pcac, gid );
        }
        else {
          //
          // we will definately stall out here if all of the
          // following are true
          //
          // o user creates non-preemtive mode client library context
          // o user doesnt periodically call a ca function
          // o user calls this function from an auxiillary thread
          //
          CallbackGuard cbGuard ( pcac->cbMutex );
          epicsGuard < epicsMutex > guard ( pcac->mutex );
          caStatus = ca_sync_group_destroy ( cbGuard, guard, *pcac, gid );
        }
    }
    return caStatus;
}

int epicsStdCall ca_sg_reset

(

const CA_SYNC_GID

gid

)

Definition at line 155 of file syncgrp.cpp.

{
    ca_client_context *pcac;
    int caStatus = fetchClientContext (&pcac);
    if ( caStatus == ECA_NORMAL ) {
        CASG * pcasg;
        {
            epicsGuard < epicsMutex > guard ( pcac->mutex );
            pcasg = pcac->lookupCASG ( guard, gid );
        }
        if ( pcasg ) {
            sync_group_reset ( *pcac, *pcasg );
            caStatus = ECA_NORMAL;
        }
        else {
            caStatus = ECA_BADSYNCGRP;
        }
    }
    return caStatus;
}

int epicsStdCall ca_sg_stat

(

const CA_SYNC_GID

gid

)

Definition at line 179 of file syncgrp.cpp.

{
    ca_client_context * pcac;
    int caStatus = fetchClientContext ( &pcac );
    if ( caStatus != ECA_NORMAL ) {
        return caStatus;
    }

    epicsGuard < epicsMutex > guard ( pcac->mutexRef() );

    CASG * pcasg = pcac->lookupCASG ( guard, gid );
    if ( ! pcasg ) {
        ::printf ( "Bad Sync Group Id\n");
        return ECA_BADSYNCGRP;
    }
    pcasg->show ( guard, 1000u );

    return ECA_NORMAL;
}

int epicsStdCall ca_sg_test

(

const CA_SYNC_GID

gid

)

Definition at line 202 of file syncgrp.cpp.

{
    ca_client_context * pcac;
    int caStatus = fetchClientContext ( &pcac );
    if ( caStatus == ECA_NORMAL ) {
        epicsGuard < epicsMutex > guard ( pcac->mutexRef() );
        CASG * pcasg = pcac->lookupCASG ( guard, gid );
        if ( pcasg ) {
            bool isComplete;
            if ( pcac->pCallbackGuard.get() &&
                pcac->createdByThread == epicsThreadGetIdSelf () ) {
              epicsGuard < epicsMutex > guard ( pcac->mutex );
              isComplete = pcasg->ioComplete ( *pcac->pCallbackGuard.get(), guard );
            }
            else {
              //
              // we will definately stall out here if all of the
              // following are true
              //
              // o user creates non-preemtive mode client library context
              // o user doesnt periodically call a ca function
              // o user calls this function from an auxiillary thread
              //
              CallbackGuard cbGuard ( pcac->cbMutex );
              epicsGuard < epicsMutex > guard ( pcac->mutex );
              isComplete = pcasg->ioComplete ( cbGuard, guard );
            }
            if ( isComplete ) {
                caStatus = ECA_IODONE;
            }
            else{
                caStatus = ECA_IOINPROGRESS;
            }
        }
        else {
            caStatus = ECA_BADSYNCGRP;
        }
    }
    return caStatus;
}

int ca_sync_group_destroy	(	CallbackGuard &	cbGuard,
		epicsGuard< epicsMutex > &	guard,
		ca_client_context &	cac,
		const CA_SYNC_GID	gid
	)

Definition at line 49 of file syncgrp.cpp.

{
    int caStatus;
    CASG * pcasg = cac.lookupCASG ( guard, gid );
    if ( pcasg ) {
        pcasg->destructor ( cbGuard, guard );
        cac.casgFreeList.release ( pcasg );
        caStatus = ECA_NORMAL;
    }
    else {
        caStatus = ECA_BADSYNCGRP;
    }
    return caStatus;
}

void sync_group_reset	(	ca_client_context &	client,
		CASG &	sg
	)

Definition at line 96 of file syncgrp.cpp.

{
    if ( client.pCallbackGuard.get() &&
        client.createdByThread == epicsThreadGetIdSelf () ) {
        epicsGuard < epicsMutex > guard ( client.mutex );
        sg.reset ( *client.pCallbackGuard.get(), guard );
    }
    else {
        //
        // we will definately stall out here if all of the
        // following are true
        //
        // o user creates non-preemtive mode client library context
        // o user doesnt periodically call a ca function
        // o user calls this function from an auxiillary thread
        //
        CallbackGuard cbGuard ( client.cbMutex );
        epicsGuard < epicsMutex > guard ( client.mutex );
        sg.reset ( cbGuard, guard );
    }
}