papi_test.h File Reference

Go to the source code of this file.

Data Structures
struct	test_events_t

Macros
#define	MASK_FP_OPS   0x80000
#define	MASK_L1_DCA   0x40000 /* three new events for POWER4 */
#define	MASK_L1_DCW   0x20000
#define	MASK_L1_DCR   0x10000
#define	MASK_TOT_IIS   0x04000 /* Try this if TOT_INS won't work */
#define	MASK_BR_PRC   0x02000
#define	MASK_BR_MSP   0x01000
#define	MASK_BR_CN   0x00800
#define	MASK_L2_TCH   0x00400
#define	MASK_L2_TCA   0x00200
#define	MASK_L2_TCM   0x00100
#define	MASK_L1_DCM   0x00040
#define	MASK_L1_ICM   0x00020
#define	MASK_L1_TCM   0x00010
#define	MASK_FP_INS   0x00004
#define	MASK_TOT_INS   0x00002
#define	MASK_TOT_CYC   0x00001
#define	MAX_TEST_EVENTS   18
#define	ONEHDR   " %12s"
#define	TAB2HDR   "%s %12s %12s\n"
#define	TAB3HDR   "%s %12s %12s %12s\n"
#define	TAB4HDR   "%s %12s %12s %12s %12s\n"
#define	ONENUM   " %12lld"
#define	TAB1   "%-12s %12lld\n"
#define	TAB2   "%-12s %12lld %12lld\n"
#define	TAB3   "%-12s %12lld %12lld %12lld\n"
#define	TAB4   "%-12s %12lld %12lld %12lld %12lld\n"
#define	TAB5   "%-12s %12lld %12lld %12lld %12lld %12lld\n"
#define	TWO12   "%12lld %12lld %s"
#define	LLDFMT   "%lld"
#define	LLDFMT10   "%10lld"
#define	LLDFMT12   "%12lld"
#define	LLDFMT15   "%15lld"

Functions
void	validate_string (const char *name, char *s)
void *	get_overflow_address (void *context)
void	free_test_space (long long **values, int num_tests)
long long **	allocate_test_space (int num_tests, int num_events)
int	add_test_events (int *number, int *mask, int allow_derived)
int	add_two_events (int *num_events, int *papi_event, int *mask)
int	add_two_nonderived_events (int *num_events, int *papi_event, int *mask)
int	add_test_events_r (int *number, int *mask, void *handle)
int	find_nonderived_event (void)
int	enum_add_native_events (int *num_events, int **evtcodes, int need_interrupts, int no_software_events, int cidx)
int	remove_test_events (int *EventSet, int mask)
char *	stringify_domain (int domain)
char *	stringify_all_domains (int domains)
char *	stringify_granularity (int granularity)
char *	stringify_all_granularities (int granularities)
int	tests_quiet (int argc, char **argv)
void	test_pass (const char *filename)
void	test_fail (const char *file, int line, const char *call, int retval)
void	test_skip (const char *file, int line, const char *call, int retval)
void	test_warn (const char *file, int line, const char *call, int retval)
void	test_print_event_header (const char *call, int evset)
int	approx_equals (double a, double b)

Variables
struct test_events_t	test_events []
int	TESTS_QUIET

Macro Definition Documentation

LLDFMT

#define LLDFMT   "%lld"

Definition at line 94 of file papi_test.h.

LLDFMT10

#define LLDFMT10   "%10lld"

Definition at line 95 of file papi_test.h.

LLDFMT12

#define LLDFMT12   "%12lld"

Definition at line 96 of file papi_test.h.

LLDFMT15

#define LLDFMT15   "%15lld"

Definition at line 97 of file papi_test.h.

MASK_BR_CN

#define MASK_BR_CN   0x00800

Definition at line 31 of file papi_test.h.

MASK_BR_MSP

#define MASK_BR_MSP   0x01000

Definition at line 30 of file papi_test.h.

MASK_BR_PRC

#define MASK_BR_PRC   0x02000

Definition at line 29 of file papi_test.h.

MASK_FP_INS

#define MASK_FP_INS   0x00004

Definition at line 38 of file papi_test.h.

MASK_FP_OPS

#define MASK_FP_OPS   0x80000

Definition at line 24 of file papi_test.h.

MASK_L1_DCA

#define MASK_L1_DCA   0x40000 /* three new events for POWER4 */

Definition at line 25 of file papi_test.h.

MASK_L1_DCM

#define MASK_L1_DCM   0x00040

Definition at line 35 of file papi_test.h.

MASK_L1_DCR

#define MASK_L1_DCR   0x10000

Definition at line 27 of file papi_test.h.

MASK_L1_DCW

#define MASK_L1_DCW   0x20000

Definition at line 26 of file papi_test.h.

MASK_L1_ICM

#define MASK_L1_ICM   0x00020

Definition at line 36 of file papi_test.h.

MASK_L1_TCM

#define MASK_L1_TCM   0x00010

Definition at line 37 of file papi_test.h.

MASK_L2_TCA

#define MASK_L2_TCA   0x00200

Definition at line 33 of file papi_test.h.

MASK_L2_TCH

#define MASK_L2_TCH   0x00400

Definition at line 32 of file papi_test.h.

MASK_L2_TCM

#define MASK_L2_TCM   0x00100

Definition at line 34 of file papi_test.h.

MASK_TOT_CYC

#define MASK_TOT_CYC   0x00001

Definition at line 40 of file papi_test.h.

MASK_TOT_IIS

#define MASK_TOT_IIS   0x04000 /* Try this if TOT_INS won't work */

Definition at line 28 of file papi_test.h.

MASK_TOT_INS

#define MASK_TOT_INS   0x00002

Definition at line 39 of file papi_test.h.

MAX_TEST_EVENTS

#define MAX_TEST_EVENTS   18

Definition at line 42 of file papi_test.h.

ONEHDR

#define ONEHDR   " %12s"

Definition at line 83 of file papi_test.h.

ONENUM

#define ONENUM   " %12lld"

Definition at line 87 of file papi_test.h.

TAB1

#define TAB1   "%-12s %12lld\n"

Definition at line 88 of file papi_test.h.

TAB2

#define TAB2   "%-12s %12lld %12lld\n"

Definition at line 89 of file papi_test.h.

TAB2HDR

#define TAB2HDR   "%s %12s %12s\n"

Definition at line 84 of file papi_test.h.

TAB3

#define TAB3   "%-12s %12lld %12lld %12lld\n"

Definition at line 90 of file papi_test.h.

TAB3HDR

#define TAB3HDR   "%s %12s %12s %12s\n"

Definition at line 85 of file papi_test.h.

TAB4

#define TAB4   "%-12s %12lld %12lld %12lld %12lld\n"

Definition at line 91 of file papi_test.h.

TAB4HDR

#define TAB4HDR   "%s %12s %12s %12s %12s\n"

Definition at line 86 of file papi_test.h.

TAB5

#define TAB5   "%-12s %12lld %12lld %12lld %12lld %12lld\n"

Definition at line 92 of file papi_test.h.

TWO12

#define TWO12   "%12lld %12lld %s"

Definition at line 93 of file papi_test.h.

Function Documentation

add_test_events()

int add_test_events	(	int *	number,
		int *	mask,
		int	allow_derived
	)

Definition at line 152 of file test_utils.c.

{
    int retval,i;
    int EventSet = PAPI_NULL;
    char name_string[BUFSIZ];

    *number = 0;

    /* create the eventset */
    retval = PAPI_create_eventset( &EventSet );
    if ( retval != PAPI_OK ) {
        test_fail(__FILE__,__LINE__,"Trouble creating eventset",retval);
    }


    /* check all the masks */
    for(i=0;i<MAX_TEST_EVENTS;i++) {

        if ( *mask & test_events[i].mask ) {

            /* remove any derived events if told to */
            if ((is_event_derived(test_events[i].event)) &&
                (!allow_derived)) {
                *mask = *mask ^ test_events[i].mask;
                continue;
            }

            retval = PAPI_add_event( EventSet,
                test_events[i].event );

            if ( retval == PAPI_OK ) {
                ( *number )++;
            }
            else {
                if ( !TESTS_QUIET ) {
                PAPI_event_code_to_name(test_events[i].event,
                            name_string);
                fprintf( stdout, "%#x %s is not available.\n",
                    test_events[i].event,name_string);
                }
                *mask = *mask ^ test_events[i].mask;
            }
        }
    }

    return EventSet;
}

Here is the call graph for this function:

add_test_events_r()

int add_test_events_r	(	int *	number,
		int *	mask,
		void *	handle
	)

add_two_events()

int add_two_events	(	int *	num_events,
		int *	papi_event,
		int *	mask
	)

Definition at line 617 of file test_utils.c.

                                                              {

    int retval;
    int EventSet = PAPI_NULL;

    *num_events=2;
    *papi_event=PAPI_TOT_INS;
    (void)mask;

    /* create the eventset */
    retval = PAPI_create_eventset( &EventSet );
    if ( retval != PAPI_OK ) {
        test_fail( __FILE__, __LINE__, "PAPI_create_eventset", retval );
    }

    retval = PAPI_add_named_event( EventSet, "PAPI_TOT_CYC");
    if ( retval != PAPI_OK ) {
        if (!TESTS_QUIET) printf("Couldn't add PAPI_TOT_CYC\n");
        test_skip(__FILE__,__LINE__,"Couldn't add PAPI_TOT_CYC",0);
    }

    retval = PAPI_add_named_event( EventSet, "PAPI_TOT_INS");
    if ( retval != PAPI_OK ) {
        if (!TESTS_QUIET) printf("Couldn't add PAPI_TOT_CYC\n");
        test_skip(__FILE__,__LINE__,"Couldn't add PAPI_TOT_CYC",0);
    }

    return EventSet;
}

Here is the call graph for this function:

add_two_nonderived_events()

int add_two_nonderived_events	(	int *	num_events,
		int *	papi_event,
		int *	mask
	)

Definition at line 648 of file test_utils.c.

                                                                         {

    /* query and set up the right event to monitor */
    int EventSet = PAPI_NULL;
    int retval;

    *num_events=0;

#define POTENTIAL_EVENTS 3

    unsigned int potential_evt_to_add[POTENTIAL_EVENTS][2] =
        { {( unsigned int ) PAPI_FP_INS, MASK_FP_INS},
          {( unsigned int ) PAPI_FP_OPS, MASK_FP_OPS},
          {( unsigned int ) PAPI_TOT_INS, MASK_TOT_INS}
        };

    int i;

    *mask = 0;

    /* could leak up to two event sets. */
    for(i=0;i<POTENTIAL_EVENTS;i++) {
        retval = PAPI_query_event( ( int ) potential_evt_to_add[i][0] );
        if (retval  == PAPI_OK ) {
            if ( !is_event_derived(potential_evt_to_add[i][0])) {
                *papi_event = ( int ) potential_evt_to_add[i][0];
                *mask = ( int ) potential_evt_to_add[i][1] | MASK_TOT_CYC;
                EventSet = add_test_events( num_events, mask, 0 );
                if ( *num_events == 2 ) break;
            }
        }
    }

    return EventSet;
}

Here is the call graph for this function:

allocate_test_space()

long long** allocate_test_space	(	int	num_tests,
		int	num_events
	)

Definition at line 46 of file test_utils.c.

{
    long long **values;
    int i;

    values =
        ( long long ** ) malloc( ( size_t ) num_tests *
                                 sizeof ( long long * ) );
    if ( values == NULL )
        exit( 1 );
    memset( values, 0x0, ( size_t ) num_tests * sizeof ( long long * ) );

    for ( i = 0; i < num_tests; i++ ) {
        values[i] =
            ( long long * ) malloc( ( size_t ) num_events *
                                    sizeof ( long long ) );
        if ( values[i] == NULL )
            exit( 1 );
        memset( values[i], 0x00, ( size_t ) num_events * sizeof ( long long ) );
    }
    return ( values );
}

Here is the call graph for this function:

approx_equals()

int approx_equals	(	double	a,
		double	b
	)

Definition at line 33 of file test_utils.c.

{
    if ( ( a >= b * ( 1.0 - TOLERANCE ) ) && ( a <= b * ( 1.0 + TOLERANCE ) ) )
        return 1;
    else {
        printf( "Out of tolerance range %2.2f: %.0f vs %.0f [%.0f,%.0f]\n",
                TOLERANCE, a, b, b * ( 1.0 - TOLERANCE ),
                b * ( 1.0 + TOLERANCE ) );
        return 0;
    }
}

enum_add_native_events()

int enum_add_native_events	(	int *	num_events,
		int **	evtcodes,
		int	need_interrupts,
		int	no_software_events,
		int	cidx
	)

Definition at line 686 of file test_utils.c.

{
    /* query and set up the right event to monitor */

    int EventSet = PAPI_NULL;
    int i = 0, k, event_code, retval;
    int counters, event_found = 0;
    PAPI_event_info_t info;
    const PAPI_component_info_t *s = NULL;
    const PAPI_hw_info_t *hw_info = NULL;

    *num_events=0;

    s = PAPI_get_component_info( cidx );
    if ( s == NULL ) {
        test_fail( __FILE__, __LINE__,
                "PAPI_get_component_info", PAPI_ECMP );
    }

    hw_info = PAPI_get_hardware_info(  );
    if ( hw_info == NULL ) {
        test_fail( __FILE__, __LINE__, "PAPI_get_hardware_info", 2 );
    }

    counters = PAPI_num_hwctrs(  );
    if (counters<1) {
        if (!TESTS_QUIET) printf("No counters available\n");
        return EventSet;
    }

    if (!TESTS_QUIET) {
        printf("Trying to fill %d hardware counters...\n", counters);
    }

    if (need_interrupt) {
        if ( (!strcmp(hw_info->model_string,"POWER6")) ||
            (!strcmp(hw_info->model_string,"POWER5")) ) {

            test_warn(__FILE__, __LINE__,
                    "Limiting num_counters because of "
                    "LIMITED_PMC on Power5 and Power6",1);
            counters=4;
        }
    }

    ( *evtcodes ) = ( int * ) calloc( counters, sizeof ( int ) );

    retval = PAPI_create_eventset( &EventSet );
    if ( retval != PAPI_OK ) {
        test_fail( __FILE__, __LINE__, "PAPI_create_eventset", retval );
    }

    /* For platform independence, always ASK FOR the first event */
    /* Don't just assume it'll be the first numeric value */
    i = 0 | PAPI_NATIVE_MASK;
    retval = PAPI_enum_cmp_event( &i, PAPI_ENUM_FIRST, cidx );
    if ( retval != PAPI_OK ) {
        test_fail( __FILE__, __LINE__, "PAPI_enum_cmp_event", retval );
    }

     do {
        retval = PAPI_get_event_info( i, &info );

    /* HACK! FIXME */
        if (no_software_events && ( strstr(info.symbol,"PERF_COUNT_SW") || strstr(info.long_descr, "PERF_COUNT_SW") ) ) {
       if (!TESTS_QUIET) {
          printf("Blocking event %s as a SW event\n", info.symbol);
       }
       continue;
    }

    if ( s->cntr_umasks ) {
       k = i;

       if ( PAPI_enum_cmp_event( &k, PAPI_NTV_ENUM_UMASKS, cidx ) == PAPI_OK ) {
          do {
             retval = PAPI_get_event_info( k, &info );
         event_code = ( int ) info.event_code;

         retval = PAPI_add_event( EventSet, event_code );
         if ( retval == PAPI_OK ) {
            ( *evtcodes )[event_found] = event_code;
            if ( !TESTS_QUIET ) {
               printf( "event_code[%d] = %#x (%s)\n",
                   event_found, event_code, info.symbol );
            }
            event_found++;
         } else {
            if ( !TESTS_QUIET ) {
               printf( "%#x (%s) can't be added to the EventSet.\n",
                   event_code, info.symbol );
            }
         }
          } while ( PAPI_enum_cmp_event( &k, PAPI_NTV_ENUM_UMASKS, cidx ) == PAPI_OK
                        && event_found < counters );
       } else {
          event_code = ( int ) info.event_code;
          retval = PAPI_add_event( EventSet, event_code );
          if ( retval == PAPI_OK ) {
          ( *evtcodes )[event_found] = event_code;
          if ( !TESTS_QUIET ) {
             printf( "event_code[%d] = %#x (%s)\n",
                   event_found, event_code, info.symbol );
          }
          event_found++;
          }
       }
       if ( !TESTS_QUIET && retval == PAPI_OK ) {
         /* */
       }
    } else {
            event_code = ( int ) info.event_code;
            retval = PAPI_add_event( EventSet, event_code );
            if ( retval == PAPI_OK ) {
                ( *evtcodes )[event_found] = event_code;
                event_found++;
            } else {
                if ( !TESTS_QUIET )
                    fprintf( stdout, "%#x is not available.\n", event_code );
            }
        }
    }
     while ( PAPI_enum_cmp_event( &i, PAPI_ENUM_EVENTS, cidx ) == PAPI_OK &&
            event_found < counters );

    *num_events = ( int ) event_found;

    if (!TESTS_QUIET) printf("Tried to fill %d counters with events, "
                 "found %d\n",counters,event_found);

    return EventSet;
}

Here is the call graph for this function:

find_nonderived_event()

int find_nonderived_event

(

void

)

Definition at line 98 of file test_utils.c.

{
    /* query and set up the right event to monitor */
    PAPI_event_info_t info;
    int potential_evt_to_add[3] = { PAPI_FP_OPS, PAPI_FP_INS, PAPI_TOT_INS };
    int i;

    for ( i = 0; i < 3; i++ ) {
        if ( PAPI_query_event( potential_evt_to_add[i] ) == PAPI_OK ) {
            if ( PAPI_get_event_info( potential_evt_to_add[i], &info ) ==
                 PAPI_OK ) {
                if ( ( info.count > 0 ) &&
                     !strcmp( info.derived, "NOT_DERIVED" ) )
                    return ( potential_evt_to_add[i] );
            }
        }
    }
    return ( 0 );
}

Here is the call graph for this function:

free_test_space()

void free_test_space	(	long long **	values,
		int	num_tests
	)

Definition at line 70 of file test_utils.c.

{
    int i;

    for ( i = 0; i < num_tests; i++ )
        free( values[i] );
    free( values );
}

get_overflow_address()

void* get_overflow_address

(

void *

context

)

remove_test_events()

int remove_test_events	(	int *	EventSet,
		int	mask
	)

Definition at line 201 of file test_utils.c.

{
    int retval = PAPI_OK;

    if ( mask & MASK_L1_DCA ) {
        retval = PAPI_remove_event( *EventSet, PAPI_L1_DCA );
        if ( retval < PAPI_OK )
            return ( retval );
    }

    if ( mask & MASK_L1_DCW ) {
        retval = PAPI_remove_event( *EventSet, PAPI_L1_DCW );
        if ( retval < PAPI_OK )
            return ( retval );
    }

    if ( mask & MASK_L1_DCR ) {
        retval = PAPI_remove_event( *EventSet, PAPI_L1_DCR );
        if ( retval < PAPI_OK )
            return ( retval );
    }

    if ( mask & MASK_L2_TCH ) {
        retval = PAPI_remove_event( *EventSet, PAPI_L2_TCH );
        if ( retval < PAPI_OK )
            return ( retval );
    }

    if ( mask & MASK_L2_TCA ) {
        retval = PAPI_remove_event( *EventSet, PAPI_L2_TCA );
        if ( retval < PAPI_OK )
            return ( retval );
    }

    if ( mask & MASK_L2_TCM ) {
        retval = PAPI_remove_event( *EventSet, PAPI_L2_TCM );
        if ( retval < PAPI_OK )
            return ( retval );
    }

    if ( mask & MASK_L1_DCM ) {
        retval = PAPI_remove_event( *EventSet, PAPI_L1_DCM );
        if ( retval < PAPI_OK )
            return ( retval );
    }

    if ( mask & MASK_L1_ICM ) {
        retval = PAPI_remove_event( *EventSet, PAPI_L1_ICM );
        if ( retval < PAPI_OK )
            return ( retval );
    }

    if ( mask & MASK_L1_TCM ) {
        retval = PAPI_remove_event( *EventSet, PAPI_L1_TCM );
        if ( retval < PAPI_OK )
            return ( retval );
    }

    if ( mask & MASK_FP_OPS ) {
        retval = PAPI_remove_event( *EventSet, PAPI_FP_OPS );
        if ( retval < PAPI_OK )
            return ( retval );
    }

    if ( mask & MASK_FP_INS ) {
        retval = PAPI_remove_event( *EventSet, PAPI_FP_INS );
        if ( retval < PAPI_OK )
            return ( retval );
    }

    if ( mask & MASK_TOT_INS ) {
        retval = PAPI_remove_event( *EventSet, PAPI_TOT_INS );
        if ( retval < PAPI_OK )
            return ( retval );
    }

    if ( mask & MASK_TOT_IIS ) {
        retval = PAPI_remove_event( *EventSet, PAPI_TOT_IIS );
        if ( retval < PAPI_OK )
            return ( retval );
    }

    if ( mask & MASK_TOT_CYC ) {
        retval = PAPI_remove_event( *EventSet, PAPI_TOT_CYC );
        if ( retval < PAPI_OK )
            return ( retval );
    }

    return ( PAPI_destroy_eventset( EventSet ) );
}

Here is the call graph for this function:

stringify_all_domains()

char* stringify_all_domains

(

int

domains

)

Definition at line 293 of file test_utils.c.

{
    static char buf[PAPI_HUGE_STR_LEN];
    int i, did = 0;
    buf[0] = '\0';

    for ( i = PAPI_DOM_MIN; i <= PAPI_DOM_MAX; i = i << 1 )
        if ( domains & i ) {
            if ( did )
                strcpy( buf + strlen( buf ), "|" );
            strcpy( buf + strlen( buf ), stringify_domain( domains & i ) );
            did++;
        }
    if ( did == 0 )
        test_fail( __FILE__, __LINE__, "Unrecognized domains!", 0 );
    return ( buf );
}

Here is the call graph for this function:

stringify_all_granularities()

char* stringify_all_granularities

(

int

granularities

)

Definition at line 332 of file test_utils.c.

{
    static char buf[PAPI_HUGE_STR_LEN];
    int i, did = 0;

    buf[0] = '\0';
    for ( i = PAPI_GRN_MIN; i <= PAPI_GRN_MAX; i = i << 1 )
        if ( granularities & i ) {
            if ( did )
                strcpy( buf + strlen( buf ), "|" );
            strcpy( buf + strlen( buf ),
                    stringify_granularity( granularities & i ) );
            did++;
        }
    if ( did == 0 )
        test_fail( __FILE__, __LINE__, "Unrecognized granularity!", 0 );

    return ( buf );
}

Here is the call graph for this function:

stringify_domain()

char* stringify_domain

(

int

domain

)

Definition at line 312 of file test_utils.c.

{
    switch ( domain ) {
    case PAPI_DOM_SUPERVISOR:
        return ( "PAPI_DOM_SUPERVISOR" );
    case PAPI_DOM_USER:
        return ( "PAPI_DOM_USER" );
    case PAPI_DOM_KERNEL:
        return ( "PAPI_DOM_KERNEL" );
    case PAPI_DOM_OTHER:
        return ( "PAPI_DOM_OTHER" );
    case PAPI_DOM_ALL:
        return ( "PAPI_DOM_ALL" );
    default:
        test_fail( __FILE__, __LINE__, "Unrecognized domains!", 0 );
    }
    return ( NULL );
}

Here is the call graph for this function:

stringify_granularity()

char* stringify_granularity

(

int

granularity

)

Definition at line 353 of file test_utils.c.

{
    switch ( granularity ) {
    case PAPI_GRN_THR:
        return ( "PAPI_GRN_THR" );
    case PAPI_GRN_PROC:
        return ( "PAPI_GRN_PROC" );
    case PAPI_GRN_PROCG:
        return ( "PAPI_GRN_PROCG" );
    case PAPI_GRN_SYS_CPU:
        return ( "PAPI_GRN_SYS_CPU" );
    case PAPI_GRN_SYS:
        return ( "PAPI_GRN_SYS" );
    default:
        test_fail( __FILE__, __LINE__, "Unrecognized granularity!", 0 );
    }
    return ( NULL );
}

Here is the call graph for this function:

test_fail()

void test_fail	(	const char *	file,
		int	line,
		const char *	call,
		int	retval
	)

Definition at line 468 of file test_utils.c.

{
//  int line_pad;
    char buf[128];

    (void)file;

//  line_pad=(60-strlen(file));
//  if (line_pad<0) line_pad=0;

//  fprintf(stdout,"%s",file);
//  print_spaces(line_pad);

    memset( buf, '\0', sizeof ( buf ) );

    if (TESTS_COLOR) fprintf(stdout,"%s",RED);
    fprintf( stdout, "FAILED!!!");
    if (TESTS_COLOR) fprintf(stdout,"%s",NORMAL);
    fprintf( stdout, "\nLine # %d ", line );

    if ( retval == PAPI_ESYS ) {
        sprintf( buf, "System error in %s", call );
        perror( buf );
    } else if ( retval > 0 ) {
        fprintf( stdout, "Error: %s\n", call );
    } else if ( retval == 0 ) {
#if defined(sgi)
        fprintf( stdout, "SGI requires root permissions for this test\n" );
#else
        fprintf( stdout, "Error: %s\n", call );
#endif
    } else {
        fprintf( stdout, "Error in %s: %s\n", call, PAPI_strerror( retval ) );
    }

   fprintf(stdout, "Some tests require special hardware, permissions, OS, compilers\n"
                   "or library versions. PAPI may still function perfectly on your \n"
                   "system without the particular feature being tested here.       \n");

    /* NOTE: Because test_fail is called from thread functions,
       calling PAPI_shutdown here could prevent some threads
       from being able to free memory they have allocated.
     */
    if ( PAPI_is_initialized(  ) ) {
        PAPI_shutdown(  );
    }

    /* This is stupid.  Threads are the rare case */
    /* and in any case an exit() should clear everything out */
    /* adding back the exit() call */

    exit(1);
}

Here is the call graph for this function:

test_pass()

void test_pass

(

const char *

filename

)

Definition at line 432 of file test_utils.c.

{
    (void)filename;

//  int line_pad;

//  line_pad=60-strlen(filename);
//  if (line_pad<0) line_pad=0;

//  fprintf(stdout,"%s",filename);
//  print_spaces(line_pad);

    if ( TEST_WARN ) {
        print_spaces(59);
        if (TESTS_COLOR) fprintf( stdout, "%s", YELLOW);
        fprintf( stdout, "PASSED with WARNING");
        if (TESTS_COLOR) fprintf( stdout, "%s", NORMAL);
        fprintf( stdout, "\n");
    }
    else {
        if (TESTS_COLOR) fprintf( stdout, "%s",GREEN);
        fprintf( stdout, "PASSED");
        if (TESTS_COLOR) fprintf( stdout, "%s",NORMAL);
        fprintf( stdout, "\n");
    }

    if ( PAPI_is_initialized(  ) ) {
        PAPI_shutdown(  );
    }

    exit( 0 );

}

Here is the call graph for this function:

test_print_event_header()

void test_print_event_header	(	const char *	call,
		int	evset
	)

Definition at line 582 of file test_utils.c.

{
        int *ev_ids;
    int i, nev;
    int retval;
    char evname[PAPI_MAX_STR_LEN];

    if ( *call )
        fprintf( stdout, "%s", call );

    if ((nev = PAPI_get_cmp_opt(PAPI_MAX_MPX_CTRS,NULL,0)) <= 0) {
        fprintf( stdout, "Can not list event names.\n" );
        return;
    }

    if ((ev_ids = calloc(nev,sizeof(int))) == NULL) {
        fprintf( stdout, "Can not list event names.\n" );
        return;
    }

    retval = PAPI_list_events( evset, ev_ids, &nev );

    if ( retval == PAPI_OK ) {
        for ( i = 0; i < nev; i++ ) {
            PAPI_event_code_to_name( ev_ids[i], evname );
            printf( ONEHDR, evname );
        }
    } else {
        fprintf( stdout, "Can not list event names." );
    }
    fprintf( stdout, "\n" );
    free(ev_ids);
}

Here is the call graph for this function:

test_skip()

void test_skip	(	const char *	file,
		int	line,
		const char *	call,
		int	retval
	)

Definition at line 561 of file test_utils.c.

{
//  int line_pad;

    (void)file;
    (void)line;
    (void)call;
    (void)retval;

//  line_pad=(60-strlen(file));

//  fprintf(stdout,"%s",file);
//  print_spaces(line_pad);

    fprintf( stdout, "SKIPPED\n");

    exit( 0 );
}

Here is the call graph for this function:

test_warn()

void test_warn	(	const char *	file,
		int	line,
		const char *	call,
		int	retval
	)

Definition at line 524 of file test_utils.c.

{

    (void)file;

//  int line_pad;

//  line_pad=60-strlen(file);
//  if (line_pad<0) line_pad=0;

    char buf[128];
    memset( buf, '\0', sizeof ( buf ) );

//  fprintf(stdout,"%s",file);
//  print_spaces(line_pad);

    if (TEST_WARN==0) fprintf(stdout,"\n");
    if (TESTS_COLOR) fprintf( stdout, "%s", YELLOW);
    fprintf( stdout, "WARNING ");
    if (TESTS_COLOR) fprintf( stdout, "%s", NORMAL);
    fprintf( stdout, "Line # %d ", line );

    if ( retval == PAPI_ESYS ) {
        sprintf( buf, "System warning in %s", call );
        perror( buf );
    } else if ( retval > 0 ) {
        fprintf( stdout, "Warning: %s\n", call );
    } else if ( retval == 0 ) {
        fprintf( stdout, "Warning: %s\n", call );
    } else {
        fprintf( stdout, "Warning in %s: %s\n", call, PAPI_strerror( retval ));
    }

    TEST_WARN++;
}

Here is the call graph for this function:

tests_quiet()

int tests_quiet	(	int	argc,
		char **	argv
	)

Definition at line 376 of file test_utils.c.

{
    char *value;
    int retval;

    if ( ( argc > 1 )
         && ( ( strcasecmp( argv[1], "TESTS_QUIET" ) == 0 )
              || ( strcasecmp( argv[1], "-q" ) == 0 ) ) ) {
        TESTS_QUIET = 1;
    }

    /* Always report PAPI errors when testing */
    /* Even in quiet mode */
    retval = PAPI_set_debug( PAPI_VERB_ECONT );
    if ( retval != PAPI_OK ) {
        test_fail( __FILE__, __LINE__, "PAPI_set_debug", retval );
    }

    value=getenv("TESTS_COLOR");
    if (value!=NULL) {
        if (value[0]=='y') {
            TESTS_COLOR=1;
        }
        else {
            TESTS_COLOR=0;
        }
    }

    /* Disable colors if sending to a file */
    if (!isatty(fileno(stdout))) {
        TESTS_COLOR=0;
    }

    return TESTS_QUIET;
}

Here is the call graph for this function:

validate_string()

void validate_string	(	const char *	name,
		char *	s
	)

Definition at line 23 of file test_utils.c.

{
    if ( ( s == NULL ) || ( strlen( s ) == 0 ) ) {
        char s2[1024] = "";
        sprintf( s2, "%s was NULL or length 0", name );
        test_fail( __FILE__, __LINE__, s2, 0 );
    }
}

Here is the call graph for this function:

Variable Documentation

test_events

struct test_events_t test_events[]

Definition at line 130 of file test_utils.c.

TESTS_QUIET

int TESTS_QUIET

Definition at line 18 of file test_utils.c.