ctests/overflow_pthreads.c

Go to the documentation of this file.

/* This file performs the following test: overflow dispatch with pthreads

   - This tests the dispatch of overflow calls from PAPI. These are counted
   in the default counting domain and default granularity, depending on
   the platform. Usually this is the user domain (PAPI_DOM_USER) and
   thread context (PAPI_GRN_THR).

     The Eventset contains:
     + PAPI_FP_INS (overflow monitor)
     + PAPI_TOT_CYC

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

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

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

static const PAPI_hw_info_t *hw_info = NULL;
static int total[NUM_THREADS];
static int expected[NUM_THREADS];
static pthread_t myid[NUM_THREADS];

static void
handler( int EventSet, void *address, long long overflow_vector, void *context )
{
#if 0
    printf( "handler(%d,%#lx,%llx) Overflow %d in thread %lx\n",
            EventSet, ( unsigned long ) address, overflow_vector,
            total[EventSet], PAPI_thread_id(  ) );
    printf( "%lx vs %lx\n", myid[EventSet], PAPI_thread_id(  ) );
#else  /* eliminate unused parameter warning message */
    ( void ) address;
    ( void ) overflow_vector;
    ( void ) context;
#endif
    total[EventSet]++;
}

static long long mythreshold=0;

static void *
Thread( void *arg )
{
    int retval, num_tests = 1;
    int EventSet1 = PAPI_NULL;
    int mask1, papi_event;
    int num_events1;
    long long **values;
    long long elapsed_us, elapsed_cyc;
    char event_name[PAPI_MAX_STR_LEN];

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

    /* add PAPI_TOT_CYC and one of the events in PAPI_FP_INS, PAPI_FP_OPS or
       PAPI_TOT_INS, depends on the availability of the event on the 
       platform */
    EventSet1 =
        add_two_nonderived_events( &num_events1, &papi_event, &mask1 );

    if (EventSet1 < 0) return NULL;

    /* Wait, we're indexing a per-thread array with the EventSet number? */
    /* does that make any sense at all???? -- vmw                        */
    expected[EventSet1] = *( int * ) arg / mythreshold;
    myid[EventSet1] = PAPI_thread_id(  );

    values = allocate_test_space( num_tests, num_events1 );

    elapsed_us = PAPI_get_real_usec(  );

    elapsed_cyc = PAPI_get_real_cyc(  );

    if ((retval = PAPI_overflow( EventSet1, papi_event, 
                     mythreshold, 0, handler ) ) != PAPI_OK ) {
       test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );
    }

    /* start_timer(1); */
    if ( ( retval = PAPI_start( EventSet1 ) ) != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_start", retval );

    do_stuff(  );

    if ( ( retval = PAPI_stop( EventSet1, values[0] ) ) != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_stop", retval );

    elapsed_us = PAPI_get_real_usec(  ) - elapsed_us;

    elapsed_cyc = PAPI_get_real_cyc(  ) - elapsed_cyc;

    retval = PAPI_overflow( EventSet1, papi_event, 0, 0, NULL );
    if (retval != PAPI_OK ) {
        test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );
    }

    remove_test_events( &EventSet1, mask1 );

    retval = PAPI_event_code_to_name( papi_event, event_name );
    if (retval != PAPI_OK ) {
        test_fail( __FILE__, __LINE__, "PAPI_event_code_to_name", retval );
    }

    if ( !TESTS_QUIET ) {
        printf( "Thread %#x %s : \t%lld\n", ( int ) pthread_self(  ),
                event_name, ( values[0] )[0] );
        printf( "Thread %#x PAPI_TOT_CYC: \t%lld\n", ( int ) pthread_self(  ),
                ( values[0] )[1] );
        printf( "Thread %#x Real usec   : \t%lld\n", ( int ) pthread_self(  ),
                elapsed_us );
        printf( "Thread %#x Real cycles : \t%lld\n", ( int ) pthread_self(  ),
                elapsed_cyc );
    }
    free_test_space( values, num_tests );
    retval = PAPI_unregister_thread(  );
    if ( retval != PAPI_OK )
        test_fail( __FILE__, __LINE__, "PAPI_unregister_thread", retval );
    return ( NULL );
}

int
main( int argc, char **argv )
{
    pthread_t id[NUM_THREADS];
    int flops[NUM_THREADS];
    int i, rc, retval;
    pthread_attr_t attr;
    float ratio;
    int quiet;

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

    memset( total, 0x0, NUM_THREADS * sizeof ( *total ) );
    memset( expected, 0x0, NUM_THREADS * sizeof ( *expected ) );
    memset( myid, 0x0, NUM_THREADS * sizeof ( *myid ) );

    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", 2 );
    }

    retval = PAPI_thread_init( ( unsigned long ( * )( void ) )
                    ( pthread_self ) );
    if (retval != PAPI_OK ) {
        if ( retval == PAPI_ECMP )
            test_skip( __FILE__, __LINE__, "PAPI_thread_init", retval );
        else
            test_fail( __FILE__, __LINE__, "PAPI_thread_init", retval );
    }
#if defined(linux)
    mythreshold = ((long long)hw_info->cpu_max_mhz) * 10000 * 2;
#else
    mythreshold = THRESHOLD * 2;
#endif

    pthread_attr_init( &attr );
#ifdef PTHREAD_CREATE_UNDETACHED
    pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_UNDETACHED );
#endif
#ifdef PTHREAD_SCOPE_SYSTEM
    retval = pthread_attr_setscope( &attr, PTHREAD_SCOPE_SYSTEM );
    if ( retval != 0 )
        test_skip( __FILE__, __LINE__, "pthread_attr_setscope", retval );
#endif

    for ( i = 0; i < NUM_THREADS; i++ ) {
        flops[i] = NUM_FLOPS * ( i + 1 );
        rc = pthread_create( &id[i], &attr, Thread, ( void * ) &flops[i] );
        if ( rc )
            test_fail( __FILE__, __LINE__, "pthread_create", PAPI_ESYS );
    }
    for ( i = 0; i < NUM_THREADS; i++ )
        pthread_join( id[i], NULL );

    pthread_attr_destroy( &attr );

    {
        long long t = 0, r = 0;
        for ( i = 0; i < NUM_THREADS; i++ ) {
            t += ( NUM_FLOPS * ( i + 1 ) ) / mythreshold;
            r += total[i];
        }
        if (!quiet) {
            printf( "Expected total overflows: %lld\n", t );
            printf( "Received total overflows: %lld\n", r );
        }
    }
// FIXME: are we actually testing this properly?

/*   ratio = (float)total[0] / (float)expected[0]; */
/*   printf("Ratio of total to expected: %f\n",ratio); */
    ratio = 1.0;
    for ( i = 0; i < NUM_THREADS; i++ ) {
        if (!quiet) printf( "Overflows thread %d: %d, expected %d\n",
                i, total[i], ( int ) ( ratio * ( float ) expected[i] ) );
    }

    for ( i = 0; i < NUM_THREADS; i++ ) {
        if ( total[i] < ( int ) ( ( ratio * ( float ) expected[i] ) / 2.0 ) )
            test_fail( __FILE__, __LINE__, "not enough overflows", PAPI_EMISC );
    }

    test_pass( __FILE__ );

    pthread_exit( NULL );

    return 0;

}