overflow.c File Reference

Include dependency graph for overflow.c:

Go to the source code of this file.

Macros
#define	OVER_FMT   "handler(%d ) Overflow at %p! bit=%#llx \n"
#define	OUT_FMT   "%-12s : %16lld%16lld\n"

Functions
void	handler (int EventSet, void *address, long long overflow_vector, void *context)
int	main (int argc, char **argv)

Variables
static int	total = 0

Macro Definition Documentation

OUT_FMT

#define OUT_FMT   "%-12s : %16lld%16lld\n"

Definition at line 31 of file overflow.c.

OVER_FMT

#define OVER_FMT   "handler(%d ) Overflow at %p! bit=%#llx \n"

Definition at line 30 of file overflow.c.

Function Documentation

handler()

void handler	(	int	EventSet,
		void *	address,
		long long	overflow_vector,
		void *	context
	)

Definition at line 37 of file overflow.c.

{
    ( void ) context;

    if ( !TESTS_QUIET ) {
        fprintf( stderr, OVER_FMT, EventSet, address, overflow_vector );
    }
    total++;
}

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 48 of file overflow.c.

{
    int EventSet = PAPI_NULL;
    long long ( values[2] )[2];
    long long min, max;
    int num_flops = NUM_FLOPS, retval;
    int PAPI_event, mythreshold = THRESHOLD;
    char event_name1[PAPI_MAX_STR_LEN];
    const PAPI_hw_info_t *hw_info = NULL;
    int num_events, mask;
    int quiet;

    /* Set TESTS_QUIET variable */
    quiet = tests_quiet( argc, argv );

    /* Init PAPI */
    retval = PAPI_library_init( PAPI_VER_CURRENT );
    if ( retval != PAPI_VER_CURRENT ) {
        test_fail( __FILE__, __LINE__, "PAPI_library_init", retval );
    }

    /* Get hardware info */
    hw_info = PAPI_get_hardware_info(  );
    if ( hw_info == NULL ) {
        test_fail( __FILE__, __LINE__, "PAPI_get_hardware_info", 2 );
    }

    /* add PAPI_TOT_CYC and one of the events in     */
        /*     PAPI_FP_INS, PAPI_FP_OPS or PAPI_TOT_INS, */
    /* depending on the availability of the event on */
    /* the platform */
    EventSet = add_two_nonderived_events( &num_events, &PAPI_event, &mask );

    if (num_events==0) {
        if (!quiet) printf("Trouble adding event!\n");
        test_skip(__FILE__,__LINE__,"Event add",1);
    }

    if (!quiet) {
        printf("Using %#x for the overflow event\n",PAPI_event);
    }

    if ( PAPI_event == PAPI_FP_INS ) {
        mythreshold = THRESHOLD;
    }
    else {
#if defined(linux)
        mythreshold = ( int ) hw_info->cpu_max_mhz * 20000;
#else
        mythreshold = THRESHOLD * 2;
#endif
    }

    /* Start the run calibration run */
    retval = PAPI_start( EventSet );
    if ( retval != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_start", retval );

    do_flops( NUM_FLOPS );

    /* stop the calibration run */
    retval = PAPI_stop( EventSet, values[0] );
    if ( retval != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_stop", retval );


    /* set up overflow handler */
    retval = PAPI_overflow( EventSet, PAPI_event, mythreshold, 0, handler );
    if ( retval != PAPI_OK ) {
       test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );
    }

    /* Start overflow run */
    retval = PAPI_start( EventSet );
    if ( retval != PAPI_OK ) {
       test_fail( __FILE__, __LINE__, "PAPI_start", retval );
    }

    do_flops( num_flops );

    /* stop overflow run */
    retval = PAPI_stop( EventSet, values[1] );
    if ( retval != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
    retval = PAPI_overflow( EventSet, PAPI_event, 0, 0, handler );
    if ( retval != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );

    if ( !TESTS_QUIET ) {
        retval = PAPI_event_code_to_name( PAPI_event, event_name1 );
        if (retval != PAPI_OK ) {
            test_fail( __FILE__, __LINE__, "PAPI_event_code_to_name", retval );
        }

        printf( "Test case: Overflow dispatch of 2nd event in set with 2 events.\n" );
        printf( "---------------------------------------------------------------\n" );
        printf( "Threshold for overflow is: %d\n", mythreshold );
        printf( "Using %d iterations of c += a*b\n", num_flops );
        printf( "-----------------------------------------------\n" );

        printf( "Test type    : %16d%16d\n", 1, 2 );
        printf( OUT_FMT, event_name1, ( values[0] )[1], ( values[1] )[1] );
        printf( OUT_FMT, "PAPI_TOT_CYC", ( values[0] )[0], ( values[1] )[0] );
        printf( "Overflows    : %16s%16d\n", "", total );
        printf( "-----------------------------------------------\n" );
    }

    retval = PAPI_cleanup_eventset( EventSet );
    if ( retval != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_cleanup_eventset", retval );

    retval = PAPI_destroy_eventset( &EventSet );
    if ( retval != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_destroy_eventset", retval );

    if ( !TESTS_QUIET ) {
        printf( "Verification:\n" );
#if defined(linux) || defined(__ia64__) || defined(_POWER4)
        num_flops *= 2;
#endif
        if ( PAPI_event == PAPI_FP_INS || PAPI_event == PAPI_FP_OPS ) {
            printf( "Row 1 approximately equals %d %d\n", num_flops,
                    num_flops );
        }
        printf( "Column 1 approximately equals column 2\n" );
        printf( "Row 3 approximately equals %u +- %u %%\n",
                ( unsigned ) ( ( values[0] )[1] / ( long long ) mythreshold ),
                ( unsigned ) ( OVR_TOLERANCE * 100.0 ) );
    }
/*
  min = (long long)((values[0])[1]*(1.0-TOLERANCE));
  max = (long long)((values[0])[1]*(1.0+TOLERANCE));
  if ( (values[0])[1] > max || (values[0])[1] < min )
    test_fail(__FILE__, __LINE__, event_name, 1);
*/

    min =
        ( long long ) ( ( ( double ) values[0][1] * ( 1.0 - OVR_TOLERANCE ) ) /
                        ( double ) mythreshold );
    max =
        ( long long ) ( ( ( double ) values[0][1] * ( 1.0 + OVR_TOLERANCE ) ) /
                        ( double ) mythreshold );
    if (!quiet) {
        printf( "Overflows: total(%d) > max(%lld) || "
            "total(%d) < min(%lld) \n", total, max, total, min );
    }
    if ( total > max || total < min ) {
        test_fail( __FILE__, __LINE__, "Overflows", 1 );
    }

    test_pass( __FILE__ );
    return 0;

}

Here is the call graph for this function:

Variable Documentation

total

int total = 0

static

Definition at line 33 of file overflow.c.