catime.c File Reference

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <float.h>
#include <limits.h>
#include "epicsAssert.h"
#include "epicsTime.h"
#include "cadef.h"
#include "caProto.h"
#include "caDiagnostics.h"

Include dependency graph for catime.c:

Go to the source code of this file.

Classes
struct	testItem

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

Typedefs
typedef struct testItem	ti
typedef void	tf(ti *pItems, unsigned iterations, unsigned *pInlineIter)

Functions
void	timeIt (tf *pfunc, ti *pItems, unsigned iterations, unsigned nBytesSent, unsigned nBytesRecv)
int	catime (const char *channelName, unsigned channelCount, enum appendNumberFlag appNF)

Macro Definition Documentation

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

Definition at line 28 of file catime.c.

#define NULL   0

Definition at line 38 of file catime.c.

#define WAIT_FOR_ACK

Definition at line 41 of file catime.c.

Typedef Documentation

typedef void tf(ti *pItems, unsigned iterations, unsigned *pInlineIter)

Definition at line 51 of file catime.c.

typedef struct testItem ti

Function Documentation

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;
}

void timeIt	(	tf *	pfunc,
		ti *	pItems,
		unsigned	iterations,
		unsigned	nBytesSent,
		unsigned	nBytesRecv
	)

Definition at line 447 of file catime.c.

{
    epicsTimeStamp      end_time;
    epicsTimeStamp      start_time;
    double              delay;
    unsigned            inlineIter;

    epicsTimeGetCurrent ( &start_time );
    (*pfunc) ( pItems, iterations, &inlineIter );
    epicsTimeGetCurrent ( &end_time );
    delay = epicsTimeDiffInSeconds ( &end_time, &start_time );
    if ( delay > 0.0 ) {
        double freq = ( iterations * inlineIter ) / delay;
        printf ( "Per Op, %8.4f uS ( %8.4f MHz )",
            1e6 / freq, freq / 1e6 );
        if ( pItems != NULL ) {
            printf(", %8.4f snd Mbps, %8.4f rcv Mbps\n",
                (inlineIter*nBytesSent*CHAR_BIT)/(delay*1e6),
                (inlineIter*nBytesRecv*CHAR_BIT)/(delay*1e6) );
        }
        else {
            printf ("\n");
        }
    }
}