papi_hl.c

Go to the documentation of this file.

/****************************/
/* THIS IS OPEN SOURCE CODE */
/****************************/

#include "papi.h"
#include "papi_internal.h"
#include "papi_memory.h"
#include <string.h>

/* high level papi functions*/

/*
 * Which high-level interface are we using?
 */
#define HL_STOP     0
#define HL_START    1
#define HL_FLIP     2
#define HL_FLOP     3
#define HL_IPC      4
#define HL_EPC      5
#define HL_READ     6
#define HL_ACCUM    7

typedef struct _HighLevelInfo
{
    int EventSet;                   
    short int num_evts;             
    short int running;              
    long long initial_real_time;    
    long long initial_proc_time;    
    long long last_real_time;       
    long long last_proc_time;       
    long long total_ins;            
} HighLevelInfo;

int _hl_rate_calls( float *real_time, float *proc_time, int *events, 
                    long long *values, long long *ins, float *rate, int mode );
void _internal_cleanup_hl_info( HighLevelInfo * state );
int _internal_check_state( HighLevelInfo ** state );
int _internal_start_hl_counters( HighLevelInfo * state );
int _internal_hl_read_cnts( long long *values, int array_len, int flag );

/* CHANGE LOG:
  - ksl 10/17/03
   Pretty much a complete rewrite of the high level interface.  Now
   the interface is thread safe and you don't have to worry as much
   about mixing the various high level calls.

  - dkt 11/19/01:
   After much discussion with users and developers, removed FMA and SLOPE
   fudge factors. SLOPE was not being used, and we decided the place to
   apply FMA was at a higher level where there could be a better understanding
   of platform discrepancies and code implications.
   ALL PAPI CALLS NOW RETURN EXACTLY WHAT THE HARDWARE REPORTS
  - dkt 08/14/01:
   Added reinitialization of values and proc_time to new reinit code.
   Added SLOPE and FMA constants to correct for systemic errors on a
   platform-by-platform basis.
   SLOPE is a factor subtracted from flpins on each call to compensate
   for platform overhead in the call.
   FMA is a shifter that doubles floating point counts on platforms that
   count FMA as one op instead of two.
   NOTE: We are making the FLAWED assumption that ALL flpins are FMA!
   This will result in counts that are TOO HIGH on the affected platforms
   in instances where the code is NOT mostly FMA.
  - dkt 08/01/01:
   NOTE: Calling semantics have changed!
   Now, if flpins < 0 (an invalid value) a PAPI_reset is issued to reset the
   counter values. The internal start time is also reset. This should be a 
   benign change, exept in the rare case where a user passes an uninitialized
   (and possibly negative) value for flpins to the routine *AFTER* it has been
   called the first time. This is unlikely, since the first call clears and
   returns th is value.
  - dkt 08/01/01:
   Internal sequencing changes:
   -- initial PAPI_get_real_usec() call moved above PAPI_start to avoid unwanted flops.
   -- PAPI_accum() replaced with PAPI_start() / PAPI_stop pair for same reason.
*/

int
_internal_check_state( HighLevelInfo ** outgoing )
{
    int retval;
    HighLevelInfo *state = NULL;

    /* Only allow one thread at a time in here */
    if ( init_level == PAPI_NOT_INITED ) {
        retval = PAPI_library_init( PAPI_VER_CURRENT );
        if ( retval != PAPI_VER_CURRENT ) {
            return ( retval );
        } else {
            _papi_hwi_lock( HIGHLEVEL_LOCK );
            init_level = PAPI_HIGH_LEVEL_INITED;
            _papi_hwi_unlock( HIGHLEVEL_LOCK );
        }
    }

    /*
     * Do we have the thread specific data setup yet?
     */
    if ( ( retval =
           PAPI_get_thr_specific( PAPI_HIGH_LEVEL_TLS, ( void ** ) &state ) )
         != PAPI_OK || state == NULL ) {
        state = ( HighLevelInfo * ) papi_malloc( sizeof ( HighLevelInfo ) );
        if ( state == NULL )
            return ( PAPI_ENOMEM );

        memset( state, 0, sizeof ( HighLevelInfo ) );
        state->EventSet = -1;

        if ( ( retval = PAPI_create_eventset( &state->EventSet ) ) != PAPI_OK )
            return ( retval );

        if ( ( retval =
               PAPI_set_thr_specific( PAPI_HIGH_LEVEL_TLS,
                                      state ) ) != PAPI_OK )
            return ( retval );
    }
    *outgoing = state;
    return ( PAPI_OK );
}

int
_internal_start_hl_counters( HighLevelInfo * state )
{
    return ( PAPI_start( state->EventSet ) );
}

void
_internal_cleanup_hl_info( HighLevelInfo * state )
{
    state->num_evts = 0;
    state->running = HL_STOP;
    state->initial_real_time = -1;
    state->initial_proc_time = -1;
    state->total_ins = 0;
    return;
}

int
PAPI_flips( float *rtime, float *ptime, long long *flpins, float *mflips )
{
    int retval;
    int events[1] = {PAPI_FP_INS};
    long long values = 0;

    if ( rtime == NULL || ptime == NULL ||
            flpins == NULL || mflips == NULL ) {
        return PAPI_EINVAL;
    }

    retval = _hl_rate_calls( rtime, ptime, events,
            &values, flpins, mflips, HL_FLIP );

    return ( retval );
}

int
PAPI_flops( float *rtime, float *ptime, long long *flpops, float *mflops )
{
    int retval;
   int events[1] = {PAPI_FP_OPS};
    long long values = 0;

    if ( rtime == NULL || ptime == NULL || flpops == NULL || mflops == NULL )
        return PAPI_EINVAL;

   retval = _hl_rate_calls( rtime, ptime, events, &values, flpops, mflops, HL_FLOP );
    return ( retval );
}

int
PAPI_ipc( float *rtime, float *ptime, long long *ins, float *ipc )
{
    long long values[2] = { 0, 0 };
    int events[2] = {PAPI_TOT_INS, PAPI_TOT_CYC};
    int retval = 0;

    if ( rtime == NULL || ptime == NULL || ins == NULL || ipc == NULL )
        return PAPI_EINVAL;

    retval = _hl_rate_calls( rtime, ptime, events, values, ins, ipc, HL_IPC );
    return ( retval );
}

int
PAPI_epc( int event, float *rtime, float *ptime, long long *ref, long long *core, long long *evt, float *epc )
{
    long long values[3] = { 0, 0, 0 };
    int events[3] = {PAPI_TOT_INS, PAPI_TOT_CYC, PAPI_REF_CYC};
    int retval = 0;

    if ( rtime == NULL || ptime == NULL || ref == NULL ||core == NULL || evt == NULL || epc == NULL )
        return PAPI_EINVAL;

    // if an event is provided, use it; otherwise use TOT_INS
    if (event != 0 ) events[0] = event;
    
    if ( PAPI_query_event( ( int ) PAPI_REF_CYC ) != PAPI_OK )
        events[2] = 0;

    retval = _hl_rate_calls( rtime, ptime, events, values, evt, epc, HL_EPC );
    *core = values[1];
    *ref = values[2];
    return ( retval );
}

int
_hl_rate_calls( float *real_time, float *proc_time, int *events,
        long long *values, long long *ins, float *rate, int mode )
{
    long long rt, pt; // current elapsed real and process times in usec
    int num_events = 2;
    int retval = 0;
    HighLevelInfo *state = NULL;

    if ( ( retval = _internal_check_state( &state ) ) != PAPI_OK ) {
        return ( retval );
    }

    if ( state->running != HL_STOP && state->running != mode ) {
        return PAPI_EINVAL;
    }

    if ( state->running == HL_STOP ) {

        switch (mode) {
            case HL_FLOP:
            case HL_FLIP:
                num_events = 1;
                break;
            case HL_IPC:
                break;
            case HL_EPC:
                if ( events[2] != 0 ) num_events = 3;
                break;
            default:
                return PAPI_EINVAL;
        }
        if (( retval = PAPI_add_events( state->EventSet, events, num_events )) != PAPI_OK ) {
            _internal_cleanup_hl_info( state );
            PAPI_cleanup_eventset( state->EventSet );
            return retval;
        }

        state->total_ins = 0;
        state->initial_real_time = state->last_real_time = PAPI_get_real_usec( );
        state->initial_proc_time = state->last_proc_time = PAPI_get_virt_usec( );

        if ( ( retval = PAPI_start( state->EventSet ) ) != PAPI_OK ) {
            return retval;
        }

        /* Initialize the interface */
        state->running = mode;
        *real_time  = 0.0;
        *proc_time  = 0.0;
        *rate       = 0.0;

    } else {
        if ( ( retval = PAPI_stop( state->EventSet, values ) ) != PAPI_OK ) {
            state->running = HL_STOP;
            return retval;
        }

        /* Read elapsed real and process times  */
        rt = PAPI_get_real_usec();
        pt = PAPI_get_virt_usec();

        /* Convert to seconds with multiplication because it is much faster */
        *real_time = ((float)( rt - state->initial_real_time )) * .000001;
        *proc_time = ((float)( pt - state->initial_proc_time )) * .000001;

        state->total_ins += values[0];

        switch (mode) {
            case HL_FLOP:
            case HL_FLIP:
                /* Calculate MFLOP and MFLIP rates */
                if ( pt > 0 ) {
                     *rate = (float)values[0] / (pt - state->last_proc_time);
                } else *rate = 0;
                break;
            case HL_IPC:
            case HL_EPC:
                /* Calculate IPC */
                if (values[1]!=0) {
                    *rate = (float) ((float)values[0] / (float) ( values[1]));
                }
                break;
            default:
                return PAPI_EINVAL;
        }
        state->last_real_time = rt;
        state->last_proc_time = pt;

        if ( ( retval = PAPI_start( state->EventSet ) ) != PAPI_OK ) {
            state->running = HL_STOP;
            return retval;
        }
    }
    *ins = state->total_ins;
    return PAPI_OK;
}

int
PAPI_num_counters( void )
{
    int retval;
    HighLevelInfo *tmp = NULL;

    /* Make sure the Library is initialized, etc... */
    if ( ( retval = _internal_check_state( &tmp ) ) != PAPI_OK )
        return ( retval );

    return ( PAPI_get_opt( PAPI_MAX_HWCTRS, NULL ) );
}

int
PAPI_start_counters( int *events, int array_len )
{
    int i, retval;
    HighLevelInfo *state = NULL;

    if ( events == NULL || array_len <= 0 )
        return PAPI_EINVAL;

    if ( ( retval = _internal_check_state( &state ) ) != PAPI_OK )
        return ( retval );

    if ( state->running != 0 )
        return ( PAPI_EINVAL );

    /* load events to the new EventSet */
    for ( i = 0; i < array_len; i++ ) {
        retval = PAPI_add_event( state->EventSet, events[i] );
        if ( retval == PAPI_EISRUN )
            return ( retval );

        if ( retval ) {
            /* remove any prior events that may have been added 
             * and cleanup the high level information
             */
            _internal_cleanup_hl_info( state );
            PAPI_cleanup_eventset( state->EventSet );
            return ( retval );
        }
    }
    /* start the EventSet */
    if ( ( retval = _internal_start_hl_counters( state ) ) == PAPI_OK ) {
        state->running = HL_START;
        state->num_evts = ( short ) array_len;
    }
    return ( retval );
}

/*========================================================================*/
/* int PAPI_read_counters(long long *values, int array_len)      */
/*                                                                        */
/* Read the running counters into the values array. This call             */
/* implicitly initializes the internal counters to zero and allows        */
/* them continue to run upon return.                                      */
/*========================================================================*/

int
_internal_hl_read_cnts( long long *values, int array_len, int flag )
{
    int retval;
    HighLevelInfo *state = NULL;

    if ( ( retval = _internal_check_state( &state ) ) != PAPI_OK )
        return ( retval );

    if ( state->running != HL_START || array_len < state->num_evts )
        return ( PAPI_EINVAL );

    if ( flag == HL_ACCUM )
        return ( PAPI_accum( state->EventSet, values ) );
    else if ( flag == HL_READ ) {
        if ( ( retval = PAPI_read( state->EventSet, values ) ) != PAPI_OK )
            return ( retval );
        return ( PAPI_reset( state->EventSet ) );
    }

    /* Invalid flag passed in */
    return ( PAPI_EINVAL );
}

int
PAPI_read_counters( long long *values, int array_len )
{
    return ( _internal_hl_read_cnts( values, array_len, HL_READ ) );
}


int
PAPI_accum_counters( long long *values, int array_len )
{
    if ( values == NULL || array_len <= 0 )
        return PAPI_EINVAL;

    return ( _internal_hl_read_cnts( values, array_len, HL_ACCUM ) );
}

int
PAPI_stop_counters( long long *values, int array_len )
{
    int retval;
    HighLevelInfo *state = NULL;

    if ( ( retval = _internal_check_state( &state ) ) != PAPI_OK )
        return ( retval );

    if ( state->running == 0 )
        return ( PAPI_ENOTRUN );

    if ( state->running == HL_START ) {
        if ( array_len < state->num_evts  || values == NULL) {
            return ( PAPI_EINVAL );
        } else {
            retval = PAPI_stop( state->EventSet, values );
        }
    }

    if ( state->running > HL_START ) {
        long long tmp_values[3];
        retval = PAPI_stop( state->EventSet, tmp_values );
    }
    
    if ( retval == PAPI_OK ) {
        _internal_cleanup_hl_info( state );
        PAPI_cleanup_eventset( state->EventSet );
    }
    APIDBG( "PAPI_stop_counters returns %d\n", retval );
    return retval;
}

void
_papi_hwi_shutdown_highlevel(  )
{
    HighLevelInfo *state = NULL;

    if ( PAPI_get_thr_specific( PAPI_HIGH_LEVEL_TLS, ( void ** ) &state ) ==
         PAPI_OK ) {
        if ( state )
            papi_free( state );
    }
}