caDiagnostics.h File Reference

#include "cadef.h"

Include dependency graph for caDiagnostics.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	CATIME_OK   0
#define	CATIME_ERROR   -1

Enumerations
enum	appendNumberFlag { appendNumber, dontAppendNumber }

Functions
int	catime (const char *channelName, unsigned channelCount, enum appendNumberFlag appNF)
int	acctst (const char *pname, unsigned logggingInterestLevel, unsigned channelCount, unsigned repetitionCount, enum ca_preemptive_callback_select select)
void	caConnTest (const char *pNameIn, unsigned channelCountIn, double delayIn)

Macro Definition Documentation

#define CATIME_ERROR   -1

Definition at line 27 of file caDiagnostics.h.

#define CATIME_OK   0

Definition at line 26 of file caDiagnostics.h.

Enumeration Type Documentation

enum appendNumberFlag

Enumerator
appendNumber
dontAppendNumber

Definition at line 19 of file caDiagnostics.h.

{appendNumber, dontAppendNumber};

Function Documentation

int acctst	(	const char *	pname,
		unsigned	logggingInterestLevel,
		unsigned	channelCount,
		unsigned	repetitionCount,
		enum ca_preemptive_callback_select	select
	)

Definition at line 3398 of file acctst.c.

{
    chid chan;
    int status;
    unsigned i;
    appChan *pChans;
    unsigned connections;
    unsigned maxArrayBytes = 10000000;

    printf ( "CA Client V%s, channel name \"%s\", timeout %g\n",
        ca_version (), pName, timeoutToPendIO );
    if ( select == ca_enable_preemptive_callback ) {
        printf ( "Preemptive call back is enabled.\n" );
    }

    {
        char tmpString[32];
        sprintf ( tmpString, "%u", maxArrayBytes );
        epicsEnvSet ( "EPICS_CA_MAX_ARRAY_BYTES", tmpString );
    }

    /*
     * this test creates, and then destroys, a private CA context
     */
    multiSubscrDestroyNoLateCallbackTest ( pName, interestLevel );

    status = ca_context_create ( select );
    SEVCHK ( status, NULL );

    verifyDisconnect ( pName, interestLevel );
    verifyImmediateTearDown ( pName, select, interestLevel );
    verifyTearDownWhenChannelConnected ( pName, select, interestLevel );

    verifyDataTypeMacros ();

    connections = ca_get_ioc_connection_count ();
    verify ( connections == 0u );
    unequalServerBufferSizeTest ( pName, interestLevel );
    clearChannelInGetCallbackTest ( pName, interestLevel );
    clearChannelInPutCallbackTest ( pName, interestLevel );
    clearChannelInSubscrCallbackTest ( pName, interestLevel );
    monitorAddConnectionCallbackTest ( pName, interestLevel );

    showProgressBegin ( "connecting to test channel", interestLevel );
    status = ca_search ( pName, & chan );
    SEVCHK ( status, NULL );
    status = ca_pend_io ( timeoutToPendIO );
    SEVCHK ( status, NULL );
    showProgressEnd ( interestLevel );

    printf ( "native type was %s, native count was %lu\n",
        dbf_type_to_text ( ca_field_type ( chan ) ),
        ca_element_count ( chan ) );

    connections = ca_get_ioc_connection_count ();
    verify ( connections == 1u || connections == 0u );
    if ( connections == 0u ) {
        printf ( "testing with a local channel\n" );
    }

    verifyName ( pName, interestLevel );
    verifyConnectWithDisconnectedChannels ( pName, interestLevel );
    grEnumTest ( chan, interestLevel );
    test_sync_groups ( chan, interestLevel );
    verifyChannelPriorities ( pName, interestLevel );
    verifyTimeStamps ( chan, interestLevel );
    verifyOldPend ( interestLevel );
    exceptionTest ( chan, interestLevel );
    arrayTest ( chan, maxArrayBytes, interestLevel );
    verifyMonitorSubscriptionFlushIO ( chan, interestLevel );
    monitorSubscriptionFirstUpdateTest ( pName, chan, interestLevel );
    ctrlDoubleTest ( chan, interestLevel );
    verifyBlockInPendIO ( chan, interestLevel );
    verifyAnalogIO ( chan, DBR_FLOAT, FLT_MIN, FLT_MAX,
               FLT_MIN_EXP, FLT_MAX_EXP, FLT_EPSILON, interestLevel );
    verifyAnalogIO ( chan, DBR_DOUBLE, DBL_MIN, DBL_MAX,
               DBL_MIN_EXP, DBL_MAX_EXP, DBL_EPSILON, interestLevel );
    verifyLongIO ( chan, interestLevel );
    verifyShortIO ( chan, interestLevel );
    multiSubscriptionDeleteTest ( chan, interestLevel );
    singleSubscriptionDeleteTest ( chan, interestLevel );
    channelClearWithEventTrafficTest ( pName, interestLevel );
    eventClearAndMultipleMonitorTest ( chan, interestLevel );
    verifyHighThroughputRead ( chan, interestLevel );
    verifyHighThroughputWrite ( chan, interestLevel );
    verifyHighThroughputReadCallback ( chan, interestLevel );
    verifyHighThroughputWriteCallback ( chan, interestLevel );
    verifyBadString ( chan, interestLevel );
    verifyMultithreadSubscr ( pName, interestLevel );
    if ( select != ca_enable_preemptive_callback ) {
        fdManagerVerify ( pName, interestLevel );
    }

    /*
     * CA pend event delay accuracy test
     * (CA asssumes that search requests can be sent
     * at least every 25 mS on all supported os)
     */
    printf ( "\n" );
    pend_event_delay_test ( 1.0 );
    pend_event_delay_test ( 0.1 );
    pend_event_delay_test ( 0.25 );

    /* ca_channel_status ( 0 ); */
    ca_client_status ( 0 );
    /* ca_client_status ( 6u ); info about each channel */

    pChans = calloc ( channelCount, sizeof ( *pChans ) );
    verify ( pChans );

    for ( i = 0; i < channelCount; i++ ) {
        strncpy ( pChans[ i ].name, pName, sizeof ( pChans[ i ].name ) );
        pChans[ i ].name[ sizeof ( pChans[i].name ) - 1 ] = '\0';
    }

    verifyConnectionHandlerConnect ( pChans, channelCount, repetitionCount, interestLevel );
    verifyBlockingConnect ( pChans, channelCount, repetitionCount, interestLevel );
    verifyClear ( pChans, interestLevel );

    verifyReasonableBeaconPeriod ( chan, interestLevel );

    /*
     * Verify that we can do IO with the new types for ALH
     */
#if 0
    if ( ca_read_access (chan) && ca_write_access (chan) ) {
    {
        dbr_put_ackt_t acktIn = 1u;
        dbr_put_acks_t acksIn = 1u;
        struct dbr_stsack_string stsackOut;

        SEVCHK ( ca_put ( DBR_PUT_ACKT, chan, &acktIn ), NULL );
        SEVCHK ( ca_put ( DBR_PUT_ACKS, chan, &acksIn ), NULL );
        SEVCHK ( ca_get ( DBR_STSACK_STRING, chan, &stsackOut ), NULL );
        SEVCHK ( ca_pend_io ( timeoutToPendIO ), NULL );
    }
#endif

    /* test that ca_task_exit () works when there is still one channel remaining */
    /* status = ca_clear_channel ( chan ); */
    /* SEVCHK ( status, NULL ); */

    caTaskExitTest ( interestLevel );

    verifyContextRundownFlush ( pName, interestLevel );
    verifyContextRundownChanStillExist ( pName, interestLevel );

    free ( pChans );

    printf ( "\nTest Complete\n" );

    epicsExit ( EXIT_SUCCESS );

    return 0;
}

void caConnTest	(	const char *	pNameIn,
		unsigned	channelCountIn,
		double	delayIn
	)

Definition at line 58 of file caConnTest.cpp.

{
    unsigned iteration = 0u;
    int status;
    unsigned i;
    chid *pChans;

    channelCount = channelCountIn;

    pChans = new chid [channelCount];

    while ( 1 ) {
        connCount = 0u;
        subsequentConnect = false;
        begin = epicsTime::getCurrent ();

        printf ( "initializing CA client library\n" );

        status = ca_task_initialize();
        SEVCHK ( status, "CA init failed" );

        printf ( "creating channels\n" );

        for ( i = 0u; i < channelCount; i++ ) {
            status = ca_search_and_connect ( pNameIn,
                &pChans[i], caConnTestConnHandler, 0 );
            SEVCHK ( status, "CA search problems" );
        }

        printf ( "all channels were created\n" );

        ca_pend_event ( delayIn );

        if ( iteration & 1 ) {
            for ( i = 0u; i < channelCount; i++ ) {
                status = ca_clear_channel ( pChans[i] );
                SEVCHK ( status, "ca_clear_channel() problems" );
            }
            printf ( "all channels were destroyed\n" );
        }

        printf ( "shutting down CA client library\n" );

        status = ca_task_exit ();
        SEVCHK ( status, "task exit problems" );

        iteration++;
    }

    //delete [] pChans;
}

int catime	(	const char *	channelName,
		unsigned	channelCount,
		enum appendNumberFlag	appNF
	)

Definition at line 531 of file catime.c.

{
    unsigned i;
    int j;
    unsigned strsize;
    unsigned nBytesSent, nBytesRecv;
    ti *pItemList;

    if ( channelCount == 0 ) {
        printf ( "channel count was zero\n" );
        return 0;
    }

    pItemList = calloc ( channelCount, sizeof (ti) );
    if ( ! pItemList ) {
        return -1;
    }

    SEVCHK ( ca_context_create ( ca_disable_preemptive_callback ),
        "Unable to initialize" );

    if ( appNF == appendNumber ) {
        printf ( "Testing with %u channels named %snnn\n",
            channelCount, channelName );
    }
    else {
        printf ( "Testing with %u channels named %s\n",
             channelCount, channelName );
    }

    strsize = sizeof ( pItemList[0].name ) - 1;
    nBytesSent = 0;
    nBytesRecv = 0;
    for ( i=0; i < channelCount; i++ ) {
        if ( appNF == appendNumber ) {
            sprintf ( pItemList[i].name,"%.*s%.6u",
                (int) (strsize - 15u), channelName, i );
        }
        else {
            strncpy ( pItemList[i].name, channelName, strsize);
        }
        pItemList[i].name[strsize]= '\0';
        pItemList[i].count = 0;
        pItemList[i].pValue = 0;
        nBytesSent += 2 * ( CA_MESSAGE_ALIGN ( strlen ( pItemList[i].name ) )
                            + sizeof (caHdr) );
        nBytesRecv += 2 * sizeof (caHdr);
    }

    printf ( "Channel Connect Test\n" );
    printf ( "--------------------\n" );
    timeIt ( test_search, pItemList, channelCount, nBytesSent, nBytesRecv );
    printSearchStat ( pItemList, channelCount );

    for ( i = 0; i < channelCount; i++ ) {
        size_t count = ca_element_count ( pItemList[i].chix );
        size_t size = sizeof ( dbr_string_t ) * count;
        pItemList[i].count = count;
        pItemList[i].pValue = malloc ( size );
        assert ( pItemList[i].pValue );
    }

    printf (
        "channel name=%s, native type=%d, native count=%u\n",
        ca_name (pItemList[0].chix),
        ca_field_type (pItemList[0].chix),
        pItemList[0].count );

    printf ("Pend Event Test\n");
    printf ( "----------------\n" );
    timeIt ( test_pend, NULL, 100, 0, 0 );

    for ( i = 0; i < channelCount; i++ ) {
        dbr_float_t * pFltVal = ( dbr_float_t * ) pItemList[i].pValue;
        double val = i;
        val /= channelCount;
        for ( j = 0; j < pItemList[i].count; j++ ) {
            pFltVal[j] = (dbr_float_t) val;
        }
        pItemList[i].type = DBR_FLOAT;
    }
    printf ( "DBR_FLOAT Test\n" );
    printf ( "--------------\n" );
    test ( pItemList, channelCount );

    for ( i = 0; i < channelCount; i++ ) {
        dbr_double_t * pDblVal = ( dbr_double_t * ) pItemList[i].pValue;
        double val = i;
        val /= channelCount;
        for ( j = 0; j < pItemList[i].count; j++ ) {
            pDblVal[j] = (dbr_double_t) val;
        }
        pItemList[i].type = DBR_DOUBLE;
    }
    printf ( "DBR_DOUBLE Test\n" );
    printf ( "---------------\n" );
    test ( pItemList, channelCount );


    for ( i = 0; i < channelCount; i++ ) {
        dbr_string_t * pStrVal = ( dbr_string_t * ) pItemList[i].pValue;
        double val = i;
        val /= channelCount;
        for ( j = 0; j < pItemList[i].count; j++ ) {
            sprintf ( pStrVal[j], "%f", val );
        }
        pItemList[i].type = DBR_STRING;
    }
    printf ( "DBR_STRING Test\n" );
    printf ( "---------------\n" );
    test ( pItemList, channelCount );

    for ( i = 0; i < channelCount; i++ ) {
        dbr_int_t * pIntVal = ( dbr_int_t * ) pItemList[i].pValue;
        double val = i;
        val /= channelCount;
        for ( j = 0; j < pItemList[i].count; j++ ) {
            pIntVal[j] = (dbr_int_t) val;
        }
        pItemList[i].type = DBR_INT;
    }
    printf ( "DBR_INT Test\n" );
    printf ( "------------\n" );
    test ( pItemList, channelCount );

    printf ( "Get Latency Test\n" );
    printf ( "----------------\n" );
    for ( i = 0; i < channelCount; i++ ) {
        dbr_double_t * pDblVal = ( dbr_double_t * ) pItemList[i].pValue;
        for ( j = 0; j < pItemList[i].count; j++ ) {
            pDblVal[j] = 0;
        }
        pItemList[i].type = DBR_DOUBLE;
    }
    measure_get_latency ( pItemList, channelCount );

    printf ( "Free Channel Test\n" );
    printf ( "-----------------\n" );
    timeIt ( test_free, pItemList, channelCount, 0, 0 );

    SEVCHK ( ca_task_exit (), "Unable to free resources at exit" );

    for ( i = 0; i < channelCount; i++ ) {
        free ( pItemList[i].pValue );
    }

    free ( pItemList );

    return CATIME_OK;
}