sdsc2.c

Go to the documentation of this file.

/*
 * Test example for multiplex functionality, originally
 * provided by Timothy Kaiser, SDSC. It was modified to fit the
 * PAPI test suite by Nils Smeds, <smeds@pdc.kth.se>.
 *
 * This example verifies the PAPI_reset function for
 * multiplexed events
 */

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

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

#include "testcode.h"

#define REPEATS 5
#define MAXEVENTS 9
#define SLEEPTIME 100
#define MINCOUNTS 100000
#define MPX_TOLERANCE   0.20
#define NUM_FLOPS  20000000


int
main( int argc, char **argv )
{
    PAPI_event_info_t info;
    int i, j, retval;
    int iters = NUM_FLOPS;
    double x = 1.1, y, dtmp;
    long long t1, t2;
    long long values[MAXEVENTS];
    int sleep_time = SLEEPTIME;
#ifdef STARTSTOP
    long long dummies[MAXEVENTS];
#endif
    double valsample[MAXEVENTS][REPEATS];
    double valsum[MAXEVENTS];
    double avg[MAXEVENTS];
    double spread[MAXEVENTS];
    int nevents = MAXEVENTS;
    int eventset = PAPI_NULL;
    int events[MAXEVENTS];
    int fails;
    int quiet;

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

    /* Parse command line */
    if ( argc > 1 ) {
        if ( !strcmp( argv[1], "TESTS_QUIET" ) ) {
        }
        else {
            sleep_time = atoi( argv[1] );
            if ( sleep_time <= 0 )
                sleep_time = SLEEPTIME;
        }
    }

    events[0] = PAPI_FP_INS;
    events[1] = PAPI_TOT_INS;
    events[2] = PAPI_INT_INS;
    events[3] = PAPI_TOT_CYC;
    events[4] = PAPI_STL_CCY;
    events[5] = PAPI_BR_INS;
    events[6] = PAPI_SR_INS;
    events[7] = PAPI_LD_INS;
    events[8] = PAPI_TOT_IIS;

    for ( i = 0; i < MAXEVENTS; i++ ) {
        values[i] = 0;
        valsum[i] = 0;
    }


    if ( !quiet ) {
        printf( "\nAccuracy check of multiplexing routines.\n" );
        printf( "Investigating the variance of multiplexed measurements.\n\n" );
    }

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

#ifdef MPX
    retval = PAPI_multiplex_init(  );
    if ( retval != PAPI_OK ) {
        test_fail( __FILE__, __LINE__,
                "PAPI multiplex init fail\n", retval );
    }
#endif

    if ( ( retval = PAPI_create_eventset( &eventset ) ) ) {
        test_fail( __FILE__, __LINE__, "PAPI_create_eventset", retval );
    }

#ifdef MPX

    /* In Component PAPI, EventSets must be assigned a component index
       before you can fiddle with their internals.
       0 is always the cpu component */
    retval = PAPI_assign_eventset_component( eventset, 0 );
    if ( retval != PAPI_OK ) {
        test_fail( __FILE__, __LINE__, "PAPI_assign_eventset_component",
                   retval );
    }

    if ( ( retval = PAPI_set_multiplex( eventset ) ) ) {
            if ( retval == PAPI_ENOSUPP) {
               test_skip(__FILE__, __LINE__, "Multiplex not supported", 1);
        }
        test_fail( __FILE__, __LINE__, "PAPI_set_multiplex", retval );
    }
#endif

    /* Iterate through event list and remove those that aren't available */
    nevents = MAXEVENTS;
    for ( i = 0; i < nevents; i++ ) {
        if ( ( retval = PAPI_add_event( eventset, events[i] ) ) ) {
           for ( j = i; j < MAXEVENTS-1; j++ ) {
                events[j] = events[j + 1];
           }
           nevents--;
           i--;
        }
    }

    /* Skip test if not enough events available */
    if ( nevents < 2 ) {
        test_skip( __FILE__, __LINE__, "Not enough events left...", 0 );
    }

    /* Find a reasonable number of iterations (each
     * event active 20 times) during the measurement
     */

    /* Target: 10000 usec/multiplex, 20 repeats */
    t2 = 10000 * 20 * nevents;
    if ( t2 > 30e6 ) {
        test_skip( __FILE__, __LINE__, "This test takes too much time",
                   retval );
    }

    /* Measure time of one iteration */
    t1 = PAPI_get_real_usec(  );
    y = do_flops3( x, iters, 1 );
    t1 = PAPI_get_real_usec(  ) - t1;

    /* Scale up execution time to match t2 */
    if ( t2 > t1 ) {
        iters = iters * ( int ) ( t2 / t1 );
    }
    /* Make sure execution time is < 30s per repeated test */
    else if ( t1 > 30e6 ) {
        test_skip( __FILE__, __LINE__, "This test takes too much time",
                   retval );
    }

    if ( ( retval = PAPI_start( eventset ) ) ) {
        test_fail( __FILE__, __LINE__, "PAPI_start", retval );
    }

    for ( i = 1; i <= REPEATS; i++ ) {
        x = 1.0;

#ifndef STARTSTOP
        if ( ( retval = PAPI_reset( eventset ) ) )
            test_fail( __FILE__, __LINE__, "PAPI_reset", retval );
#else
        if ( ( retval = PAPI_stop( eventset, dummies ) ) )
            test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
        if ( ( retval = PAPI_start( eventset ) ) )
            test_fail( __FILE__, __LINE__, "PAPI_start", retval );
#endif

        if ( !quiet ) {
            printf( "\nTest %d (of %d):\n", i, REPEATS );
        }

        t1 = PAPI_get_real_usec(  );
        y = do_flops3( x, iters, 1 );
        PAPI_read( eventset, values );
        t2 = PAPI_get_real_usec(  );

        if ( !quiet ) {
            printf( "\n(calculated independent of PAPI)\n" );
            printf( "\tOperations= %.1f Mflop", y * 1e-6 );
            printf( "\t(%g Mflop/s)\n\n",
                ( y / ( double ) ( t2 - t1 ) ) );
            printf( "PAPI measurements:\n" );

            for ( j = 0; j < nevents; j++ ) {
                PAPI_get_event_info( events[j], &info );
                printf( "%20s = ", info.short_descr );
                printf( "%lld", values[j] );
                printf( "\n" );
            }
            printf( "\n" );
        }

        /* Calculate values */
        for ( j = 0; j < nevents; j++ ) {
            dtmp = ( double ) values[j];
            valsum[j] += dtmp;
            valsample[j][i - 1] = dtmp;
        }
    }

    if ( ( retval = PAPI_stop( eventset, values ) ) )
        test_fail( __FILE__, __LINE__, "PAPI_stop", retval );

    if ( !quiet ) {
        printf( "\n\nEstimated variance relative "
            "to average counts:\n" );
        for ( j = 0; j < nevents; j++ )
            printf( "   Event %.2d", j );
        printf( "\n" );
    }

    fails = nevents;
    /* Due to limited precision of floating point cannot really use
       typical standard deviation compuation for large numbers with
       very small variations. Instead compute the std devation
       problems with precision.
     */
    for ( j = 0; j < nevents; j++ ) {
        avg[j] = valsum[j] / REPEATS;
        spread[j] = 0;
        for ( i = 0; i < REPEATS; ++i ) {
            double diff = ( valsample[j][i] - avg[j] );
            spread[j] += diff * diff;
        }
        spread[j] = sqrt( spread[j] / REPEATS ) / avg[j];
        if ( !quiet )
            printf( "%9.2g  ", spread[j] );
        /* Make sure that NaN get counted as errors */
        if ( spread[j] < MPX_TOLERANCE ) {
            --fails;
        }
        /* Neglect inprecise results with low counts */
        else if ( valsum[j] < MINCOUNTS ) {
            --fails;
        }
    }

    if ( !quiet ) {
        printf( "\n\n" );
        for ( j = 0; j < nevents; j++ ) {
            PAPI_get_event_info( events[j], &info );
            printf( "Event %.2d: mean=%10.0f, "
                "sdev/mean=%7.2g nrpt=%2d -- %s\n",
                j, avg[j], spread[j],
                REPEATS, info.short_descr );
        }
        printf( "\n\n" );
    }

    if ( fails ) {
        test_fail( __FILE__, __LINE__,
                "Values outside threshold", fails );
    }

    test_pass( __FILE__ );

    return 0;
}