overflow_allcounters.c

Go to the documentation of this file.

/*
* File:    overflow_allcounters.c
* Author:  Haihang You
*          you@cs.utk.edu
* Mods:    Vince Weaver
*          vweaver1@eecs.utk.edu
*/

/* This file performs the following test: overflow all counters
   to test availability of overflow of all counters

   - Start eventset 1
   - Do flops
   - Stop and measure eventset 1
   - Set up overflow on eventset 1
   - Start eventset 1
   - Do flops
   - Stop eventset 1
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "papi.h"
#include "papi_test.h"

#include "do_loops.h"

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

static int total = 0;                  /* total overflows */


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

    ( void ) context;

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

int
main( int argc, char **argv )
{
    int EventSet = PAPI_NULL;
    long long *values;
    int num_flops, retval, i, j;
    int *events, mythreshold;
    char **names;
    const PAPI_hw_info_t *hw_info = NULL;
    int num_events, *ovt;
    char name[PAPI_MAX_STR_LEN];
    int using_perfmon = 0;
    int using_aix = 0;
    int cid;
    int quiet;
    long long value;

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

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

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

        cid = PAPI_get_component_index("perfmon");
    if (cid>=0) using_perfmon = 1;

        cid = PAPI_get_component_index("aix");
    if (cid>=0) using_aix = 1;

    /* add PAPI_TOT_CYC and one of the events in */
    /* PAPI_FP_INS, PAPI_FP_OPS PAPI_TOT_INS,    */
        /* depending on the availability of the event*/
    /* on the platform */
    EventSet = enum_add_native_events( &num_events, &events, 1 , 1, 0);

    if (num_events==0) {
        if (!quiet) printf("No events found\n");
        test_skip(__FILE__,__LINE__,"No events found",0);
    }

    if (!quiet) printf("Trying %d events\n",num_events);

    names = ( char ** ) calloc( ( unsigned int ) num_events,
                    sizeof ( char * ) );

    for ( i = 0; i < num_events; i++ ) {
       if ( PAPI_event_code_to_name( events[i], name ) != PAPI_OK ) {
          test_fail( __FILE__, __LINE__,"PAPI_event_code_to_name", retval);
       }
       else {
          names[i] = strdup( name );
          if (!quiet) printf("%i: %s\n",i,names[i]);
       }
    }

    values = ( long long * )
        calloc( ( unsigned int ) ( num_events * ( num_events + 1 ) ),
                sizeof ( long long ) );
    ovt = ( int * ) calloc( ( unsigned int ) num_events, sizeof ( int ) );

#if defined(linux)
    {
        char *tmp = getenv( "THRESHOLD" );
        if ( tmp ) {
            mythreshold = atoi( tmp );
        }
        else if (hw_info->cpu_max_mhz!=0) {
           mythreshold = ( int ) hw_info->cpu_max_mhz * 20000;
          if (!quiet) printf("Using a threshold of %d (20,000 * MHz)\n",mythreshold);

        }
        else {
          if (!quiet) printf("Using default threshold of %d\n",THRESHOLD);
           mythreshold = THRESHOLD;
        }
    }
#else
    mythreshold = THRESHOLD;
#endif

    num_flops = NUM_FLOPS * 2;

       /* initial test to make sure they all work */
    if (!quiet) printf("Testing that the events all work with no overflow\n");

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

    do_flops( num_flops );

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

    /* done with initial test */

    /* keep adding events? */
    for ( i = 0; i < num_events; i++ ) {

          /* Enable overflow */
       if (!quiet) printf("Testing with overflow set on %s\n",
                   names[i]);

       retval = PAPI_overflow( EventSet, events[i],
                    mythreshold, 0, handler );
       if ( retval != PAPI_OK ) {
          test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );
       }

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

       do_flops( num_flops );

       retval = PAPI_stop( EventSet, values + ( i + 1 ) * num_events );
       if ( retval != PAPI_OK ) {
          test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
       }

          /* Disable overflow */
       retval = PAPI_overflow( EventSet, events[i], 0, 0, handler );
       if ( retval != PAPI_OK ) {
          test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );
       }
       ovt[i] = total;
       total = 0;
    }

    if ( !quiet ) {

       printf("\nResults in Matrix-view:\n");
       printf( "Test Overflow on %d counters with %d events.\n", 
           num_events,num_events );
       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                   : " );
       for ( i = 0; i < num_events + 1; i++ ) {
           printf( "%16d", i );
       }
       printf( "\n" );
       for ( j = 0; j < num_events; j++ ) {
           printf( "%-27s : ", names[j] );
           for ( i = 0; i < num_events + 1; i++ ) {
           printf( "%16lld", *( values + j + num_events * i ) );
           }
           printf( "\n" );
       }
       printf( "Overflows                   : %16s", "" );
       for ( i = 0; i < num_events; i++ ) {
           printf( "%16d", ovt[i] );
       }
       printf( "\n" );
       printf( "-----------------------------------------------\n" );
    }

    /* validation */

    if ( !quiet ) {
       printf("\nResults broken out for validation\n");
    }

    if (!quiet) {

    for ( j = 0; j < num_events+1; j++ ) {
      if (j==0) {
             printf("Test results, no overflow:\n\t");
      }
      else {
        printf("Overflow of event %d, %s\n\t",j-1,names[j-1]);
      }
      for(i=0; i < num_events; i++) {
        if (i==j-1) {
          printf("*%lld* ",values[(num_events*j)+i]);
        }
        else {
          printf("%lld ",values[(num_events*j)+i]);
        }
      }
          printf("\n");
      if (j!=0) {
         printf("\tOverflow should be %lld / %d = %lld\n",
         values[(num_events*j)+(j-1)],
         mythreshold,
         values[(num_events*j)+(j-1)]/mythreshold);
         printf("\tOverflow was %d\n",ovt[j-1]);
      }
    }
    }

    for ( j = 0; j < num_events; j++ ) {
        //printf("Validation: %lld / %d != %d (%lld)\n",
        //       *( values + j + num_events * (j+1) ) ,
        //       mythreshold,
        //       ovt[j],
        //       *(values+j+num_events*(j+1))/mythreshold);

        value = values[j+num_events*(j+1)];

        if ( value / mythreshold != ovt[j] ) {
            char error_string[BUFSIZ];

            if ( using_perfmon )
                test_warn( __FILE__, __LINE__,
                           "perfmon component handles overflow differently than perf_events",
                           1 );
            else if ( using_aix )
                test_warn( __FILE__, __LINE__,
                           "AIX (pmapi) component handles overflow differently than various other components",
                           1 );
            else {
                sprintf( error_string,
                    "Overflow value differs from expected %lld / %d should be %lld, we got %d",
                    value , mythreshold,
                    value / mythreshold,
                    ovt[j] );
                test_fail( __FILE__, __LINE__, error_string, 1 );
            }
        }
    }

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

    free( ovt );
    for ( i = 0; i < num_events; i++ )
        free( names[i] );
    free( names );
    free( events );
    free( values );

    test_pass( __FILE__ );

    return 0;
}