papi.c

Go to the documentation of this file.

/****************************/
/* THIS IS OPEN SOURCE CODE */
/****************************/
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdbool.h>
#include <pthread.h>
 
#include "papi.h"
#include "papi_internal.h"
#include "papi_vector.h"
#include "papi_memory.h"
#include "papi_preset.h"
 
#include "cpus.h"
#include "extras.h"
#include "sw_multiplex.h"
 
 
/* simplified papi functions for event rates */
 
/* For dynamic linking to libpapi */
/* Weak symbol for pthread_once to avoid additional linking
 * against libpthread when not used. */
#pragma weak pthread_once
 
#define STOP      0
#define FLIP      1
#define FLOP      2
#define IPC       3
#define EPC       4
 
typedef struct _RateInfo
{
   int EventSet;                 
   int event_0;                  
   short int running;            
   long long last_real_time;     
   long long last_proc_time;     
} RateInfo;
 
THREAD_LOCAL_STORAGE_KEYWORD RateInfo *_rate_state = NULL;
bool _papi_rate_initiated = false;
 
static void _internal_papi_init(void);
static void _internal_onetime_papi_init(void);
static int _start_new_rate_call(float *real_time, float *proc_time, int *events,
                         int num_events, long long *ins, float *rate);
static int _rate_calls( float *real_time, float *proc_time, int *events, 
                 long long *values, long long *ins, float *rate, int mode );
static int _internal_check_rate_state();
 
 
static void _internal_papi_init(void)
{
   /* This function is only called by the first thread! */
   int retval;
 
   /* check if user has already initialzed PAPI with thread support */
   if ( init_level != ( PAPI_LOW_LEVEL_INITED | PAPI_THREAD_LEVEL_INITED ) ) {
      if ( ( retval = PAPI_library_init(PAPI_VER_CURRENT) ) != PAPI_VER_CURRENT ) {
         fprintf( stderr, "PAPI Error: PAPI_library_init failed with return value %d.\n", retval);
      } else {
      
         if ((retval = PAPI_thread_init(_papi_gettid)) != PAPI_OK) {
            fprintf( stderr, "PAPI Error: PAPI_thread_init failed with return value %d.\n", retval);
            fprintf( stderr, "PAPI Error: PAPI could not be initiated!\n");
         } else {
            _papi_rate_initiated = true;
         }
      }
   } else {
      _papi_rate_initiated = true;
   }
}
 
static void _internal_onetime_papi_init(void)
{
   static pthread_once_t library_is_initialized = PTHREAD_ONCE_INIT;
   if ( pthread_once ) {
      /* we assume that this function was called from a parallel region */
      pthread_once(&library_is_initialized, _internal_papi_init);
      /* wait until first thread has finished */
      int i = 0;
      /* give it 5 seconds in case PAPI_thread_init crashes */
      while ( !_papi_rate_initiated && (i++) < 500000 )
         usleep(10);
   } else {
      /* we assume that this function was called from a serial application
       * that was not linked against libpthread */
      _internal_papi_init();
   }
}
 
static int
_internal_check_rate_state()
{
   /* check if PAPI is initialized for rate functions */
   if ( _papi_rate_initiated == false ) {
      _internal_onetime_papi_init();
 
      if ( _papi_rate_initiated == false )
         return ( PAPI_EINVAL );
   }
 
   if ( _rate_state== NULL ) {
      _rate_state= ( RateInfo* ) papi_malloc( sizeof ( RateInfo ) );
      if ( _rate_state== NULL )
         return ( PAPI_ENOMEM );
      
      memset( _rate_state, 0, sizeof ( RateInfo ) );
      _rate_state->running = STOP;
   }
   return ( PAPI_OK );
}
 
int
PAPI_flips_rate( int event, float *rtime, float *ptime, long long *flpins, float *mflips )
{
   int retval;
 
   /* check event first */
   if ( event == PAPI_FP_INS || event == PAPI_VEC_DP || event == PAPI_VEC_SP ) {
 
      int events[1] = {event};
      long long values = 0;
 
      if ( rtime == NULL || ptime == NULL ||
            flpins == NULL || mflips == NULL ) {
         return PAPI_EINVAL;
      }
 
      retval = _rate_calls( rtime, ptime, events,
            &values, flpins, mflips, FLIP );
 
      return ( retval );
   }
   return ( PAPI_ENOEVNT );
}
 
int
PAPI_flops_rate( int event, float *rtime, float *ptime, long long *flpops, float *mflops )
{
   int retval;
 
   /* check event first */
   if ( event == PAPI_FP_OPS || event == PAPI_SP_OPS || event == PAPI_DP_OPS ) {
 
      int events[1] = {event};
      long long values = 0;
 
      if ( rtime == NULL || ptime == NULL ||
            flpops == NULL || mflops == NULL ) {
         return PAPI_EINVAL;
      }
 
      retval = _rate_calls( rtime, ptime, events,
            &values, flpops, mflops, FLOP );
 
      return ( retval );
   }
   return ( PAPI_ENOEVNT );
}
 
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 = _rate_calls( rtime, ptime, events, values, ins, ipc, 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;
 
   retval = _rate_calls( rtime, ptime, events, values, evt, epc, EPC );
   *ref = values[2];
   *core = values[1];
   return ( retval );
}
 
int
PAPI_rate_stop()
{
   int retval;
   long long tmp_values[3];
 
   if ( _papi_rate_events_running == 1 ) {
      if ( _rate_state!= NULL ) {
         if ( _rate_state->running > STOP ) {
            retval = PAPI_stop( _rate_state->EventSet, tmp_values );
            if ( retval == PAPI_OK ) {
               PAPI_cleanup_eventset( _rate_state->EventSet );
               _rate_state->running = STOP;
            }
            _papi_rate_events_running = 0;
            return retval;
         }
      }
   }
   return ( PAPI_ENOEVNT );
}
 
static int
_start_new_rate_call(float *real_time, float *proc_time, int *events,
                     int num_events, long long *ins, float *rate)
{
   int retval;
   _rate_state->EventSet = -1;
 
   if ( ( retval = PAPI_create_eventset( &_rate_state->EventSet ) ) != PAPI_OK )
      return ( retval );
   
   if (( retval = PAPI_add_events( _rate_state->EventSet, events, num_events )) != PAPI_OK )
      return retval;
 
   /* remember the event for subsequent calls of PAPI_flips_rate and PAPI_flops_rate */
   _rate_state->event_0 = events[0];
   *real_time  = 0.0;
   *proc_time  = 0.0;
   *rate       = 0.0;
   *ins        = 0;
 
   _rate_state->last_real_time = PAPI_get_real_usec( );
   _rate_state->last_proc_time = PAPI_get_virt_usec( );
 
   if ( ( retval = PAPI_start( _rate_state->EventSet ) ) != PAPI_OK ) {
      return retval;
   }
 
   return ( PAPI_OK );
}
 
static int
_rate_calls( float *real_time, float *proc_time, int *events,
             long long *values, long long *ins, float *rate, int mode )
{
 
   // printf("_rate_calls event %d, mode %d\n", events[0], mode);
 
   long long rt, pt; // current elapsed real and process times in usec
   int num_events = 2;
   int retval = 0;
 
   /* if a high-level event set is running stop it */
   if ( _papi_hl_events_running == 1 ) {
      if ( ( retval = PAPI_hl_stop() ) != PAPI_OK )
         return ( retval );
   }
 
   if ( ( retval = _internal_check_rate_state() ) != PAPI_OK ) {
      return ( retval );
   }
 
 
   switch (mode) {
      case FLOP:
      case FLIP:
         if ( (retval = PAPI_query_event(events[0])) != PAPI_OK)
            return retval;
         num_events = 1;
         break;
      case IPC:
         break;
      case EPC:
         if ( (retval = PAPI_query_event(events[0])) != PAPI_OK)
            return retval;
         if ( (retval = PAPI_query_event(events[2])) == PAPI_OK)
            num_events = 3;
         break;
      default:
         return PAPI_EINVAL;
   }
 
   /* STOP means the first call of a rate function */
   if ( _rate_state->running == STOP ) {
 
      if ( ( retval = _start_new_rate_call(real_time, proc_time, events, num_events, ins, rate)) != PAPI_OK )
         return retval;
      _rate_state->running = mode;
 
   } else {
      // check last mode
      // printf("current mode: %d, last mode: %d\n", mode, _rate_state->running);
      // printf("current event: %d, last event: %d\n", events[0], _rate_state->event_0);
 
      if ( mode != _rate_state->running || events[0] != _rate_state->event_0 ) {
              
         long long tmp_values[3];
         retval = PAPI_stop( _rate_state->EventSet, tmp_values );
         if ( retval == PAPI_OK ) {
            PAPI_cleanup_eventset( _rate_state->EventSet );
         } else {
            return retval;
         }
 
         if ( ( retval = _start_new_rate_call(real_time, proc_time, events, num_events, ins, rate)) != PAPI_OK )
            return retval;
         _rate_state->running = mode;
         _papi_rate_events_running = 1;
         return ( PAPI_OK );
      }
 
      if ( ( retval = PAPI_stop( _rate_state->EventSet, values ) ) != PAPI_OK ) {
         _rate_state->running = 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 - _rate_state->last_real_time )) * .000001;
      *proc_time = ((float)( pt - _rate_state->last_proc_time )) * .000001;
 
      *ins = values[0];
 
      switch (mode) {
         case FLOP:
         case FLIP:
            /* Calculate MFLOP and MFLIP rates */
            if ( pt > 0 ) {
                  *rate = (float)values[0] / (pt - _rate_state->last_proc_time);
            } else *rate = 0;
            break;
         case IPC:
         case EPC:
            /* Calculate IPC */
            if (values[1]!=0) {
               *rate = (float) ((float)values[0] / (float) ( values[1]));
            }
            break;
         default:
            return PAPI_EINVAL;
      }
      _rate_state->last_real_time = rt;
      _rate_state->last_proc_time = pt;
 
      if ( ( retval = PAPI_start( _rate_state->EventSet ) ) != PAPI_OK ) {
         _rate_state->running = STOP;
         return retval;
      }
   }
   _papi_rate_events_running = 1;
   return PAPI_OK;
}
 
 
/*******************************/
/* BEGIN EXTERNAL DECLARATIONS */
/*******************************/
 
 
extern hwi_presets_t user_defined_events[PAPI_MAX_USER_EVENTS];
extern int user_defined_events_count;
 
 
#ifdef DEBUG
#define papi_return(a) do { \
    int b = a; \
    if (b != PAPI_OK) {\
        _papi_hwi_errno = b;\
    } \
    APIDBG("EXIT: return: %d\n", b);\
    return((_papi_hwi_debug_handler ? _papi_hwi_debug_handler(b) : b)); \
} while (0)
#else
#define papi_return(a) do { \
    int b = a; \
    if (b != PAPI_OK) {\
        _papi_hwi_errno = b;\
    } \
    APIDBG("EXIT: return: %d\n", b);\
    return(b);\
} while(0)
#endif
 
 
/*
#ifdef DEBUG
#define papi_return(a) return((_papi_hwi_debug_handler ? _papi_hwi_debug_handler(a) : a))
#else
#define papi_return(a) return(a)
#endif
*/
 
#ifdef DEBUG
int _papi_hwi_debug;
#endif
 
 
static int init_retval = DEADBEEF;
 
inline_static int
valid_component( int cidx )
{
    if ( _papi_hwi_invalid_cmp( cidx ) )
        return ( PAPI_ENOCMP );
    return ( cidx );
}
 
inline_static int
valid_ESI_component( EventSetInfo_t * ESI )
{
    return ( valid_component( ESI->CmpIdx ) );
}
 
int
PAPI_thread_init( unsigned long int ( *id_fn ) ( void ) )
{
    /* Thread support not implemented on Alpha/OSF because the OSF pfm
     * counter device driver does not support per-thread counters.
     * When this is updated, we can remove this if statement
     */
    if ( init_level == PAPI_NOT_INITED )
        papi_return( PAPI_ENOINIT );
 
    if ( ( init_level & PAPI_THREAD_LEVEL_INITED ) )
        papi_return( PAPI_OK );
 
    init_level |= PAPI_THREAD_LEVEL_INITED;
    papi_return( _papi_hwi_set_thread_id_fn( id_fn ) );
}
 
unsigned long
PAPI_thread_id( void )
{
    if ( _papi_hwi_thread_id_fn != NULL )
        return ( ( *_papi_hwi_thread_id_fn ) (  ) );
    else
#ifdef DEBUG
    if ( _papi_hwi_debug_handler )
        return ( unsigned long ) _papi_hwi_debug_handler( PAPI_EMISC );
#endif
    return ( unsigned long ) PAPI_EMISC;
}
 
/* Thread Functions */
 
/* 
 * Notify PAPI that a thread has 'appeared'
 * We lookup the thread, if it does not exist we create it
 */
 
int
PAPI_register_thread( void )
{
    ThreadInfo_t *thread;
 
    if ( init_level == PAPI_NOT_INITED )
        papi_return( PAPI_ENOINIT );
    papi_return( _papi_hwi_lookup_or_create_thread( &thread, 0 ) );
}
 
/* 
 * Notify PAPI that a thread has 'disappeared'
 * We lookup the thread, if it does not exist we return an error
 */
int
PAPI_unregister_thread( void )
{
    ThreadInfo_t *thread = _papi_hwi_lookup_thread( 0 );
 
    if ( thread )
        papi_return( _papi_hwi_shutdown_thread( thread, 0 ) );
 
    papi_return( PAPI_EMISC );
}
 
int
PAPI_list_threads( PAPI_thread_id_t *tids, int *number )
{
    PAPI_all_thr_spec_t tmp;
    int retval;
 
    /* If tids == NULL, then just count the threads, don't gather a list. */
    /* If tids != NULL, then we need the length of the tids array in num. */
 
    if ( ( number == NULL ) || ( tids && ( *number <= 0 ) ) )
        papi_return( PAPI_EINVAL );
 
    memset( &tmp, 0x0, sizeof ( tmp ) );
 
    /* data == NULL, since we don't want the thread specific pointers. */
    /* tids may be NULL, if the user doesn't want the thread IDs. */
 
    tmp.num = *number;
    tmp.id = tids;
    tmp.data = NULL;
 
    retval = _papi_hwi_gather_all_thrspec_data( 0, &tmp );
    if ( retval == PAPI_OK )
        *number = tmp.num;
 
    papi_return( retval );
}
 
int
PAPI_get_thr_specific( int tag, void **ptr )
{
    ThreadInfo_t *thread;
    int doall = 0, retval = PAPI_OK;
 
    if ( init_level == PAPI_NOT_INITED )
        papi_return( PAPI_ENOINIT );
    if ( tag & PAPI_TLS_ALL_THREADS ) {
        tag = tag ^ PAPI_TLS_ALL_THREADS;
        doall = 1;
    }
    if ( ( tag < 0 ) || ( tag > PAPI_TLS_NUM ) )
        papi_return( PAPI_EINVAL );
 
    if ( doall )
        papi_return( _papi_hwi_gather_all_thrspec_data
                     ( tag, ( PAPI_all_thr_spec_t * ) ptr ) );
 
    retval = _papi_hwi_lookup_or_create_thread( &thread, 0 );
    if ( retval == PAPI_OK )
        *ptr = thread->thread_storage[tag];
    else
        papi_return( retval );
 
    return ( PAPI_OK );
}
 
int
PAPI_set_thr_specific( int tag, void *ptr )
{
    ThreadInfo_t *thread;
    int retval = PAPI_OK;
 
    if ( init_level == PAPI_NOT_INITED )
        papi_return( PAPI_ENOINIT );
    if ( ( tag < 0 ) || ( tag > PAPI_NUM_TLS ) )
        papi_return( PAPI_EINVAL );
 
    retval = _papi_hwi_lookup_or_create_thread( &thread, 0 );
    if ( retval == PAPI_OK ) {
       _papi_hwi_lock( THREADS_LOCK );
       thread->thread_storage[tag] = ptr;
       _papi_hwi_unlock( THREADS_LOCK );
    }
    else
        return ( retval );
 
    return ( PAPI_OK );
}
 
 
int
PAPI_library_init( int version )
{
    APIDBG( "Entry: version: %#x\n", version);
 
    int tmp = 0;
 
    /* This is a poor attempt at a lock. 
       For 3.1 this should be replaced with a 
       true UNIX semaphore. We cannot use PAPI
       locks here because they are not initialized yet */
    static int _in_papi_library_init_cnt = 0;
#ifdef DEBUG
    char *var;
#endif
    _papi_hwi_init_errors();
 
    if ( version != PAPI_VER_CURRENT )
        papi_return( PAPI_EINVAL );
 
    ++_in_papi_library_init_cnt;
    while ( _in_papi_library_init_cnt > 1 ) {
        PAPIERROR( "Multiple callers of PAPI_library_init" );
        sleep( 1 );
    }
 
    /* This checks to see if we have forked or called init more than once.
       If we have forked, then we continue to init. If we have not forked, 
       we check to see the status of initialization. */
 
    APIDBG( "Initializing library: current PID %d, old PID %d\n", 
                getpid(  ), _papi_hwi_system_info.pid );
 
    if ( _papi_hwi_system_info.pid == getpid(  ) ) {
        /* If the magic environment variable PAPI_ALLOW_STOLEN is set,
           we call shutdown if PAPI has been initialized. This allows
           tools that use LD_PRELOAD to run on applications that use PAPI.
           In this circumstance, PAPI_ALLOW_STOLEN will be set to 'stolen'
           so the tool can check for this case. */
 
        if ( getenv( "PAPI_ALLOW_STOLEN" ) ) {
            char buf[PAPI_HUGE_STR_LEN];
            if ( init_level != PAPI_NOT_INITED )
                PAPI_shutdown(  );
            sprintf( buf, "%s=%s", "PAPI_ALLOW_STOLEN", "stolen" );
            putenv( buf );
        }
 
        /* If the library has been successfully initialized *OR*
           the library attempted initialization but failed. */
 
        else if ( ( init_level != PAPI_NOT_INITED ) ||
                  ( init_retval != DEADBEEF ) ) {
            _in_papi_library_init_cnt--;
            if ( init_retval < PAPI_OK )
                papi_return( init_retval );
            else
                return ( init_retval );
        }
 
        APIDBG( "system_info was initialized, but init did not succeed\n" );
    }
#ifdef DEBUG
    var = ( char * ) getenv( "PAPI_DEBUG" );
    _papi_hwi_debug = 0;
 
    if ( var != NULL ) {
        if ( strlen( var ) != 0 ) {
            if ( strstr( var, "SUBSTRATE" ) )
                _papi_hwi_debug |= DEBUG_SUBSTRATE;
            if ( strstr( var, "API" ) )
                _papi_hwi_debug |= DEBUG_API;
            if ( strstr( var, "INTERNAL" ) )
                _papi_hwi_debug |= DEBUG_INTERNAL;
            if ( strstr( var, "THREADS" ) )
                _papi_hwi_debug |= DEBUG_THREADS;
            if ( strstr( var, "MULTIPLEX" ) )
                _papi_hwi_debug |= DEBUG_MULTIPLEX;
            if ( strstr( var, "OVERFLOW" ) )
                _papi_hwi_debug |= DEBUG_OVERFLOW;
            if ( strstr( var, "PROFILE" ) )
                _papi_hwi_debug |= DEBUG_PROFILE;
            if ( strstr( var, "MEMORY" ) )
                _papi_hwi_debug |= DEBUG_MEMORY;
            if ( strstr( var, "LEAK" ) )
                _papi_hwi_debug |= DEBUG_LEAK;
            if ( strstr( var, "HIGHLEVEL" ) )
                _papi_hwi_debug |= DEBUG_HIGHLEVEL;
            if ( strstr( var, "ALL" ) )
                _papi_hwi_debug |= DEBUG_ALL;
        }
 
        if ( _papi_hwi_debug == 0 )
            _papi_hwi_debug |= DEBUG_API;
    }
#endif
 
 
    /* Initialize internal globals */
    if ( _papi_hwi_init_global_internal(  ) != PAPI_OK ) {
        _in_papi_library_init_cnt--;
        papi_return( PAPI_EINVAL );
    }
 
    /* Initialize OS */
    tmp = _papi_hwi_init_os();
    if ( tmp ) {
       init_retval = tmp;
       _papi_hwi_shutdown_global_internal(  );
       _in_papi_library_init_cnt--;
       papi_return( init_retval );
    }
 
    /* Initialize component globals EXCEPT for perf_event, perf_event_uncore.
    * To avoid race conditions, these components use the thread local storage
    * construct initialized by _papi_hwi_init_global_threads(), from within 
    * their init_component(). So these must have init_component() run AFTER
    * _papi_hwi_init_global_threads. Other components demand that init threads
    * run AFTER init_component(), which sets up globals they need.
    */
 
    tmp = _papi_hwi_init_global( 0 ); /* Selector 0 to skip perf_event, perf_event_uncore */
    if ( tmp ) {
        init_retval = tmp;
        _papi_hwi_shutdown_global_internal(  );
        _in_papi_library_init_cnt--;
        papi_return( init_retval );
    }
    
   /* Initialize thread globals, including the main threads  */
 
    tmp = _papi_hwi_init_global_threads(  );
    if ( tmp ) {
        init_retval = tmp;
        _papi_hwi_shutdown_global_internal(  );
    _in_papi_library_init_cnt--;
        papi_return( init_retval );
    }
 
    /* Initialize perf_event, perf_event_uncore components */
 
    tmp = _papi_hwi_init_global( 1 ); /* Selector 1 for only perf_event, perf_event_uncore */
    if ( tmp ) {
        init_retval = tmp;
        _papi_hwi_shutdown_global_internal(  );
        _in_papi_library_init_cnt--;
        papi_return( init_retval );
    }
    
    init_level = PAPI_LOW_LEVEL_INITED;
    _in_papi_library_init_cnt--;
 
    return ( init_retval = PAPI_VER_CURRENT );
}
 
int
PAPI_query_event( int EventCode )
{
    APIDBG( "Entry: EventCode: %#x\n", EventCode);
    if ( IS_PRESET(EventCode) ) {
        EventCode &= PAPI_PRESET_AND_MASK;
        if ( EventCode < 0 || EventCode >= PAPI_MAX_PRESET_EVENTS )
            papi_return( PAPI_ENOTPRESET );
 
        if ( _papi_hwi_presets[EventCode].count )
                papi_return (PAPI_OK);
        else
            return PAPI_ENOEVNT;
    }
 
    if ( IS_NATIVE(EventCode) ) {
        papi_return( _papi_hwi_query_native_event
                     ( ( unsigned int ) EventCode ) );
    }
 
    if ( IS_USER_DEFINED(EventCode) ) {
      EventCode &= PAPI_UE_AND_MASK;
      if ( EventCode < 0 || EventCode >= PAPI_MAX_USER_EVENTS)
          papi_return ( PAPI_ENOEVNT );
 
        if ( user_defined_events[EventCode].count )
            papi_return (PAPI_OK);
        else
            papi_return (PAPI_ENOEVNT);
    }
 
    papi_return( PAPI_ENOEVNT );
}
 
int
PAPI_query_named_event( const char *EventName )
{
    int ret, code;
 
    ret = PAPI_event_name_to_code( EventName, &code );
    if ( ret == PAPI_OK ) ret = PAPI_query_event( code );
    papi_return( ret);
}
 
 
const PAPI_component_info_t *
PAPI_get_component_info( int cidx )
{
   APIDBG( "Entry: Component Index %d\n", cidx);
   if ( _papi_hwi_invalid_cmp( cidx ) )
      return ( NULL );
   else
      return ( &( _papi_hwd[cidx]->cmp_info ) );
}
 
/* PAPI_get_event_info:
   tests input EventCode and returns a filled in PAPI_event_info_t 
   structure containing descriptive strings and values for the 
   specified event. Handles both preset and native events by 
   calling either _papi_hwi_get_event_info or 
   _papi_hwi_get_native_event_info.
*/
int
PAPI_get_event_info( int EventCode, PAPI_event_info_t *info )
{
    APIDBG( "Entry: EventCode: 0x%x, info: %p\n", EventCode, info);
        int i;
 
    if ( info == NULL )
       papi_return( PAPI_EINVAL );
 
    if ( IS_PRESET(EventCode) ) {
           i = EventCode & PAPI_PRESET_AND_MASK;
       if ( i >= PAPI_MAX_PRESET_EVENTS )
          papi_return( PAPI_ENOTPRESET );
       papi_return( _papi_hwi_get_preset_event_info( EventCode, info ) );
    }
 
    if ( IS_NATIVE(EventCode) ) {
       papi_return( _papi_hwi_get_native_event_info
              ( ( unsigned int ) EventCode, info ) );
    }
 
    if ( IS_USER_DEFINED(EventCode) ) {
       papi_return( _papi_hwi_get_user_event_info( EventCode, info ));
    }
    papi_return( PAPI_ENOTPRESET );
}
 
 
int
PAPI_event_code_to_name( int EventCode, char *out )
{
    APIDBG( "Entry: EventCode: %#x, out: %p\n", EventCode, out);
    if ( out == NULL )
        papi_return( PAPI_EINVAL );
 
    if ( IS_PRESET(EventCode) ) {
        EventCode &= PAPI_PRESET_AND_MASK;
        if ( EventCode < 0 || EventCode >= PAPI_MAX_PRESET_EVENTS )
            papi_return( PAPI_ENOTPRESET );
 
        if (_papi_hwi_presets[EventCode].symbol == NULL )
            papi_return( PAPI_ENOTPRESET );
 
        strncpy( out, _papi_hwi_presets[EventCode].symbol, PAPI_MAX_STR_LEN-1 );
        out[PAPI_MAX_STR_LEN-1] = '\0';
        papi_return( PAPI_OK );
    }
 
    if ( IS_NATIVE(EventCode) ) {
        return ( _papi_hwi_native_code_to_name
                 ( ( unsigned int ) EventCode, out, PAPI_MAX_STR_LEN ) );
    }
 
    if ( IS_USER_DEFINED(EventCode) ) {
        EventCode &= PAPI_UE_AND_MASK;
 
        if ( EventCode < 0 || EventCode >= user_defined_events_count )
            papi_return( PAPI_ENOEVNT );
 
        if (user_defined_events[EventCode].symbol == NULL )
            papi_return( PAPI_ENOEVNT );
 
        strncpy( out, user_defined_events[EventCode].symbol, PAPI_MAX_STR_LEN-1);
        out[PAPI_MAX_STR_LEN-1] = '\0';
        papi_return( PAPI_OK );
    }
 
    papi_return( PAPI_ENOEVNT );
}
 
int
PAPI_event_name_to_code( const char *in, int *out )
{
   APIDBG("Entry: in: %p, name: %s, out: %p\n", in, in, out);
    int i;
 
    if ( ( in == NULL ) || ( out == NULL ) )
        papi_return( PAPI_EINVAL );
 
    if ( init_level == PAPI_NOT_INITED )
        papi_return( PAPI_ENOINIT );
 
    /* All presets start with "PAPI_" so no need to */
    /* do an exhaustive search if that's not there  */
    if (strncmp(in, "PAPI_", 5) == 0) {
       for(i = 0; i < PAPI_MAX_PRESET_EVENTS; i++ ) {
          if ( ( _papi_hwi_presets[i].symbol )
           && ( strcasecmp( _papi_hwi_presets[i].symbol, in ) == 0) ) {
         *out = ( int ) ( i | PAPI_PRESET_MASK );
         papi_return( PAPI_OK );
          }
       }
    }
 
    // check to see if it is a user defined event
    for ( i=0; i < user_defined_events_count ; i++ ) {
        APIDBG("&user_defined_events[%d]: %p, user_defined_events[%d].symbol: %s, user_defined_events[%d].count: %d\n",
                i, &user_defined_events[i], i, user_defined_events[i].symbol, i, user_defined_events[i].count);
        if (user_defined_events[i].symbol == NULL)
            break;
        if (user_defined_events[i].count == 0)
            break;
        if ( strcasecmp( user_defined_events[i].symbol, in ) == 0 ) {
            *out = (int) ( i | PAPI_UE_MASK );
            papi_return( PAPI_OK );
        }
    }
 
    // go look for native events defined by one of the components
    papi_return( _papi_hwi_native_name_to_code( in, out ) );
}
 
/* Updates EventCode to next valid value, or returns error; 
  modifier can specify {all / available} for presets, or other values for native tables 
  and may be platform specific (Major groups / all mask bits; P / M / E chip, etc) */
 
int
PAPI_enum_event( int *EventCode, int modifier )
{
    APIDBG( "Entry: EventCode: %#x, modifier: %d\n", *EventCode, modifier);
    int i = *EventCode;
    int retval;
    int cidx;
    int event_code;
    char *evt_name;
 
    cidx = _papi_hwi_component_index( *EventCode );
    if (cidx < 0) return PAPI_ENOCMP;
 
    /* Do we handle presets in componets other than CPU? */
    /* if (( IS_PRESET(i) ) && cidx > 0 )) return PAPI_ENOCMP; */
        
    if ( IS_PRESET(i) ) {
        if ( modifier == PAPI_ENUM_FIRST ) {
            *EventCode = ( int ) PAPI_PRESET_MASK;
            APIDBG("EXIT: *EventCode: %#x\n", *EventCode);
            return ( PAPI_OK );
        }
        i &= PAPI_PRESET_AND_MASK;
        while ( ++i < PAPI_MAX_PRESET_EVENTS ) {
            if ( _papi_hwi_presets[i].symbol == NULL ) {
                APIDBG("EXIT: PAPI_ENOEVNT\n");
                return ( PAPI_ENOEVNT );    /* NULL pointer terminates list */
            }
            if ( modifier & PAPI_PRESET_ENUM_AVAIL ) {
                if ( _papi_hwi_presets[i].count == 0 )
                    continue;
            }
            *EventCode = ( int ) ( i | PAPI_PRESET_MASK );
            APIDBG("EXIT: *EventCode: %#x\n", *EventCode);
            return ( PAPI_OK );
        }
        papi_return( PAPI_EINVAL );
    }
 
    if ( IS_NATIVE(i) ) {
        // save event code so components can get it with call to: _papi_hwi_get_papi_event_code()
        _papi_hwi_set_papi_event_code(*EventCode, 0);
 
        /* Should check against num native events here */
 
        event_code=_papi_hwi_eventcode_to_native((int)*EventCode);
        retval = _papi_hwd[cidx]->ntv_enum_events((unsigned int *)&event_code, modifier );
 
        if (retval!=PAPI_OK) {
           APIDBG("VMW: retval=%d\n",retval);
           return PAPI_EINVAL;
        }
 
        evt_name = _papi_hwi_get_papi_event_string();
        *EventCode = _papi_hwi_native_to_eventcode(cidx, event_code, -1, evt_name);
        _papi_hwi_free_papi_event_string();
 
        APIDBG("EXIT: *EventCode: %#x\n", *EventCode);
        return retval;
    }
 
    if ( IS_USER_DEFINED(i) ) {
        if (user_defined_events_count == 0) {
            APIDBG("EXIT: PAPI_ENOEVNT\n");
            return PAPI_ENOEVNT;
        }
        if ( modifier == PAPI_ENUM_FIRST ) {
            *EventCode = (int) (0 | PAPI_UE_MASK);
            APIDBG("EXIT: *EventCode: %#x\n", *EventCode);
            return ( PAPI_OK );
        }
 
        i &= PAPI_UE_AND_MASK;
        ++i;
 
        if ( i <= 0  ||  i >= user_defined_events_count ) {
            APIDBG("EXIT: PAPI_ENOEVNT\n");
            return ( PAPI_ENOEVNT );
        }
 
        // if next entry does not have an event name, we are done
        if (user_defined_events[i].symbol == NULL) {
            APIDBG("EXIT: PAPI_ENOEVNT\n");
            return ( PAPI_ENOEVNT );
        }
 
        // if next entry does not map to any other events, we are done
        if (user_defined_events[i].count == 0) {
            APIDBG("EXIT: PAPI_ENOEVNT\n");
            return ( PAPI_ENOEVNT );
        }
 
        *EventCode = (int) (i | PAPI_UE_MASK);
        APIDBG("EXIT: *EventCode: %#x\n", *EventCode);
        return ( PAPI_OK );
    }
 
    papi_return( PAPI_EINVAL );
}
 
 
int
PAPI_enum_cmp_event( int *EventCode, int modifier, int cidx )
{
    APIDBG( "Entry: EventCode: %#x, modifier: %d, cidx: %d\n", *EventCode, modifier, cidx);
    int i = *EventCode;
    int retval;
    int event_code;
    char *evt_name;
 
    if ( _papi_hwi_invalid_cmp(cidx) || ( (IS_PRESET(i)) && cidx > 0 ) ) {
        return PAPI_ENOCMP;
    }
 
    if (_papi_hwd[cidx]->cmp_info.disabled &&
        _papi_hwd[cidx]->cmp_info.disabled != PAPI_EDELAY_INIT) {
      return PAPI_ENOCMP;
    }
 
    if ( IS_PRESET(i) ) {
        if ( modifier == PAPI_ENUM_FIRST ) {
            *EventCode = ( int ) PAPI_PRESET_MASK;
            APIDBG("EXIT: *EventCode: %#x\n", *EventCode);
            return PAPI_OK;
        }
        i &= PAPI_PRESET_AND_MASK;
        while ( ++i < PAPI_MAX_PRESET_EVENTS ) {
            if ( _papi_hwi_presets[i].symbol == NULL ) {
                APIDBG("EXIT: PAPI_ENOEVNT\n");
                return ( PAPI_ENOEVNT );    /* NULL pointer terminates list */
            }
            if ( modifier & PAPI_PRESET_ENUM_AVAIL ) {
                if ( _papi_hwi_presets[i].count == 0 )
                    continue;
            }
            *EventCode = ( int ) ( i | PAPI_PRESET_MASK );
            APIDBG("EXIT: *EventCode: %#x\n", *EventCode);
            return PAPI_OK;
        }
        papi_return( PAPI_EINVAL );
    }
 
    if ( IS_NATIVE(i) ) {
        // save event code so components can get it with call to: _papi_hwi_get_papi_event_code()
        _papi_hwi_set_papi_event_code(*EventCode, 0);
 
        /* Should we check against num native events here? */
        event_code=_papi_hwi_eventcode_to_native(*EventCode);
        retval = _papi_hwd[cidx]->ntv_enum_events((unsigned int *)&event_code, modifier );
 
        if (retval!=PAPI_OK) {
           APIDBG("EXIT: PAPI_EINVAL retval=%d\n",retval);
           return PAPI_EINVAL;
        }
 
        evt_name = _papi_hwi_get_papi_event_string();
        *EventCode = _papi_hwi_native_to_eventcode(cidx, event_code, -1, evt_name);
        _papi_hwi_free_papi_event_string();
 
        APIDBG("EXIT: *EventCode: %#x\n", *EventCode);
        return retval;
    } 
 
    papi_return( PAPI_EINVAL );
}
 
int
PAPI_create_eventset( int *EventSet )
{
   APIDBG("Entry: EventSet: %p\n", EventSet);
 
    ThreadInfo_t *master;
    int retval;
 
    if ( init_level == PAPI_NOT_INITED )
        papi_return( PAPI_ENOINIT );
    retval = _papi_hwi_lookup_or_create_thread( &master, 0 );
    if ( retval )
        papi_return( retval );
 
    papi_return( _papi_hwi_create_eventset( EventSet, master ) );
}
 
int
PAPI_assign_eventset_component( int EventSet, int cidx )
{
    EventSetInfo_t *ESI;
    int retval;
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
/* validate cidx */
    retval = valid_component( cidx );
    if ( retval < 0 )
        papi_return( retval );
 
/* cowardly refuse to reassign eventsets */ 
    if ( ESI->CmpIdx >= 0 )
      return PAPI_EINVAL;
 
    return ( _papi_hwi_assign_eventset( ESI, cidx ) );
}
 
int
PAPI_get_eventset_component( int EventSet)
{
    EventSetInfo_t *ESI;
    int retval;
 
/* validate eventset */
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
/* check if a component has been assigned */ 
    if ( ESI->CmpIdx < 0 )
      papi_return( PAPI_ENOCMP );
 
/* validate CmpIdx */
    retval = valid_component( ESI->CmpIdx );
    if ( retval < 0 )
        papi_return( retval );
 
/* return the index */
    return ( ESI->CmpIdx );
}
 
 
int
PAPI_add_event( int EventSet, int EventCode )
{
   APIDBG("Entry: EventSet: %d, EventCode: %#x\n", EventSet, EventCode);
    EventSetInfo_t *ESI;
 
    /* Is the EventSet already in existence? */
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
    /* Check argument for validity */
 
    if ( ( ( EventCode & PAPI_PRESET_MASK ) == 0 ) &&
         ( EventCode & PAPI_NATIVE_MASK ) == 0 )
        papi_return( PAPI_EINVAL );
 
    /* Of course, it must be stopped in order to modify it. */
 
    if ( ESI->state & PAPI_RUNNING )
        papi_return( PAPI_EISRUN );
 
    /* Now do the magic. */
    int retval = _papi_hwi_add_event( ESI, EventCode );
    papi_return( retval );
}
 
int
PAPI_remove_event( int EventSet, int EventCode )
{
    APIDBG("Entry: EventSet: %d, EventCode: %#x\n", EventSet, EventCode);
    EventSetInfo_t *ESI;
    int i,retval;
 
    /* check for pre-existing ESI */
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
    /* Check argument for validity */
 
    if ( ( !IS_PRESET(EventCode) ) &&
        ( !IS_NATIVE(EventCode) ) &&
        ( !IS_USER_DEFINED(EventCode) ))
        papi_return( PAPI_EINVAL );
 
    /* Of course, it must be stopped in order to modify it. */
 
    if ( !( ESI->state & PAPI_STOPPED ) )
        papi_return( PAPI_EISRUN );
 
    /* if the state is PAPI_OVERFLOWING, you must first call
       PAPI_overflow with threshold=0 to remove the overflow flag */
 
    /* Turn off the event that is overflowing */
    if ( ESI->state & PAPI_OVERFLOWING ) {
       for ( i = 0; i < ESI->overflow.event_counter; i++ ) {
           if ( ESI->overflow.EventCode[i] == EventCode ) {
          retval = PAPI_overflow( EventSet, EventCode, 0, 0,
                      ESI->overflow.handler );
          if (retval!=PAPI_OK) return retval;
          break;
           }
       }
    }
 
    /* force the user to call PAPI_profil to clear the PAPI_PROFILING flag */
    if ( ESI->state & PAPI_PROFILING ) {
        for ( i = 0; i < ESI->profile.event_counter; i++ ) {
            if ( ESI->profile.EventCode[i] == EventCode ) {
                PAPI_sprofil( NULL, 0, EventSet, EventCode, 0, 0 );
                break;
            }
        }
    }
 
    /* Now do the magic. */
 
    papi_return( _papi_hwi_remove_event( ESI, EventCode ) );
}
 
int
PAPI_add_named_event( int EventSet, const char *EventName )
{
    APIDBG("Entry: EventSet: %d, EventName: %s\n", EventSet, EventName);
 
    int ret, code;
 
    ret = PAPI_event_name_to_code( EventName, &code );
    if ( ret != PAPI_OK ) {
        APIDBG("EXIT: return: %d\n", ret);
        return ret;   // do not use papi_return here because if there was an error PAPI_event_name_to_code already reported it
    }
 
    ret = PAPI_add_event( EventSet, code );
    APIDBG("EXIT: return: %d\n", ret);
    return ret;   // do not use papi_return here because if there was an error PAPI_add_event already reported it
}
 
int
PAPI_remove_named_event( int EventSet, const char *EventName )
{
    APIDBG("Entry: EventSet: %d, EventName: %s\n", EventSet, EventName);
    int ret, code;
 
    ret = PAPI_event_name_to_code( EventName, &code );
    if ( ret == PAPI_OK ) ret = PAPI_remove_event( EventSet, code );
    papi_return( ret );
 
}
 
int
PAPI_destroy_eventset( int *EventSet )
{
    APIDBG("Entry: EventSet: %p, *EventSet: %d\n", EventSet, *EventSet);
 
    EventSetInfo_t *ESI;
 
    /* check for pre-existing ESI */
 
    if ( EventSet == NULL )
        papi_return( PAPI_EINVAL );
 
    ESI = _papi_hwi_lookup_EventSet( *EventSet );
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
    if ( !( ESI->state & PAPI_STOPPED ) )
        papi_return( PAPI_EISRUN );
 
    if ( ESI->NumberOfEvents )
        papi_return( PAPI_EINVAL );
 
    _papi_hwi_remove_EventSet( ESI );
    *EventSet = PAPI_NULL;
 
    return PAPI_OK;
}
 
/* simply checks for valid EventSet, calls component start() call */
int
PAPI_start( int EventSet )
{
    APIDBG("Entry: EventSet: %d\n", EventSet);
 
    int is_dirty=0;
    int i,retval;
    EventSetInfo_t *ESI;
    ThreadInfo_t *thread = NULL;
    CpuInfo_t *cpu = NULL;
    hwd_context_t *context;
    int cidx;
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL ) {
       papi_return( PAPI_ENOEVST );
    }
 
    APIDBG("EventSet: %p\n", ESI);
 
    cidx = valid_ESI_component( ESI );
    if ( cidx < 0 ) {
       papi_return( cidx );
    }
 
    /* only one event set per thread  can be running at any time,    */
    /* so if another event set is running, the user must stop that   */
        /* event set explicitly */
 
    /* We used to check and not let multiple events be attached */
    /* to the same CPU, but this was unnecessary?               */
 
        thread = ESI->master;
    cpu = ESI->CpuInfo;
 
    if ( thread->running_eventset[cidx] ) {
           APIDBG("Thread Running already (Only one active Eventset per component)\n");
       papi_return( PAPI_EISRUN );
    }
 
    /* Check that there are added events */
    if ( ESI->NumberOfEvents < 1 ) {
       papi_return( PAPI_EINVAL );
    }
 
    /* If multiplexing is enabled for this eventset,
       call John May's code. */
 
    if ( _papi_hwi_is_sw_multiplex( ESI ) ) {
       retval = MPX_start( ESI->multiplex.mpx_evset );
       if ( retval != PAPI_OK ) {
          papi_return( retval );
       }
 
       /* Update the state of this EventSet */
       ESI->state ^= PAPI_STOPPED;
       ESI->state |= PAPI_RUNNING;
 
       return PAPI_OK;
    }
 
    /* get the context we should use for this event set */
    context = _papi_hwi_get_context( ESI, &is_dirty );
    if (is_dirty) {
       /* we need to reset the context state because it was last used   */
       /* for some other event set and does not contain the information */
           /* for our events.                                               */
       retval = _papi_hwd[ESI->CmpIdx]->update_control_state(
                                                        ESI->ctl_state,
                            ESI->NativeInfoArray,
                            ESI->NativeCount,
                            context);
       if ( retval != PAPI_OK ) {
          papi_return( retval );
       }
 
       //update_control_state disturbs the overflow settings so set 
       //it to initial values again
       if ( ESI->overflow.flags & PAPI_OVERFLOW_HARDWARE ) {
            for( i = 0; i < ESI->overflow.event_counter; i++ ) {
                    retval = _papi_hwd[ESI->CmpIdx]->set_overflow( ESI,
                                                                       ESI->overflow.EventIndex[i],
                                                                       ESI->overflow.threshold[i] );
                       if ( retval != PAPI_OK ) {
                            break;
                    }
            }
          } 
 
       /* now that the context contains this event sets information,    */
       /* make sure the position array in the EventInfoArray is correct */
 
       /* We have to do this because ->update_control_state() can */
       /* in theory re-order the native events out from under us. */
       _papi_hwi_map_events_to_native( ESI );
 
    }
 
    /* If overflowing is enabled, turn it on */
    if ( ( ESI->state & PAPI_OVERFLOWING ) &&
         !( ESI->overflow.flags & PAPI_OVERFLOW_HARDWARE ) ) {
       retval = _papi_hwi_start_signal( _papi_os_info.itimer_sig,
                        NEED_CONTEXT, cidx );
       if ( retval != PAPI_OK ) {
          papi_return( retval );
       }
 
       /* Update the state of this EventSet and thread */
       /* before to avoid races                        */
       ESI->state ^= PAPI_STOPPED;
       ESI->state |= PAPI_RUNNING;
           /* can not be attached to thread or cpu if overflowing */
       thread->running_eventset[cidx] = ESI;
 
       retval = _papi_hwd[cidx]->start( context, ESI->ctl_state );
       if ( retval != PAPI_OK ) {
          _papi_hwi_stop_signal( _papi_os_info.itimer_sig );
          ESI->state ^= PAPI_RUNNING;
          ESI->state |= PAPI_STOPPED;
          thread->running_eventset[cidx] = NULL;
          papi_return( retval );
       }
 
       retval = _papi_hwi_start_timer( _papi_os_info.itimer_num,
                       _papi_os_info.itimer_sig,
                       _papi_os_info.itimer_ns );
       if ( retval != PAPI_OK ) {
          _papi_hwi_stop_signal( _papi_os_info.itimer_sig );
          _papi_hwd[cidx]->stop( context, ESI->ctl_state );
          ESI->state ^= PAPI_RUNNING;
          ESI->state |= PAPI_STOPPED;
          thread->running_eventset[cidx] = NULL;
          papi_return( retval );
       }
    } else {
       /* Update the state of this EventSet and thread before */
       /* to avoid races                                      */
       ESI->state ^= PAPI_STOPPED;
       ESI->state |= PAPI_RUNNING;
 
       /* if not attached to cpu or another process */
       if ( !(ESI->state & PAPI_CPU_ATTACHED) ) {
          if ( !( ESI->state & PAPI_ATTACHED ) ) {
         thread->running_eventset[cidx] = ESI;
          }
       } else {
          cpu->running_eventset[cidx] = ESI;
       }
 
       retval = _papi_hwd[cidx]->start( context, ESI->ctl_state );
       if ( retval != PAPI_OK ) {
          _papi_hwd[cidx]->stop( context, ESI->ctl_state );
          ESI->state ^= PAPI_RUNNING;
          ESI->state |= PAPI_STOPPED;
          if ( !(ESI->state & PAPI_CPU_ATTACHED) ) {
         if ( !( ESI->state & PAPI_ATTACHED ) ) 
            thread->running_eventset[cidx] = NULL;
          } else {
         cpu->running_eventset[cidx] = NULL;
          }
          papi_return( retval );
       }
    }
 
    return retval;
}
 
/* checks for valid EventSet, calls component stop() function. */
int
PAPI_stop( int EventSet, long long *values )
{
   APIDBG("Entry: EventSet: %d, values: %p\n", EventSet, values);
    EventSetInfo_t *ESI;
    hwd_context_t *context;
    int cidx, retval;
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
    cidx = valid_ESI_component( ESI );
    if ( cidx < 0 )
        papi_return( cidx );
 
    if ( !( ESI->state & PAPI_RUNNING ) )
        papi_return( PAPI_ENOTRUN );
 
    /* If multiplexing is enabled for this eventset, turn if off */
 
    if ( _papi_hwi_is_sw_multiplex( ESI ) ) {
        retval = MPX_stop( ESI->multiplex.mpx_evset, values );
        if ( retval != PAPI_OK )
            papi_return( retval );
 
        /* Update the state of this EventSet */
 
        ESI->state ^= PAPI_RUNNING;
        ESI->state |= PAPI_STOPPED;
 
        return ( PAPI_OK );
    }
 
    /* get the context we should use for this event set */
    context = _papi_hwi_get_context( ESI, NULL );
    /* Read the current counter values into the EventSet */
    retval = _papi_hwi_read( context, ESI, ESI->sw_stop );
    if ( retval != PAPI_OK )
        papi_return( retval );
 
    /* Remove the control bits from the active counter config. */
    retval = _papi_hwd[cidx]->stop( context, ESI->ctl_state );
    if ( retval != PAPI_OK )
        papi_return( retval );
    if ( values )
        memcpy( values, ESI->sw_stop,
                ( size_t ) ESI->NumberOfEvents * sizeof ( long long ) );
 
    /* If kernel profiling is in use, flush and process the kernel buffer */
 
    if ( ESI->state & PAPI_PROFILING ) {
        if ( _papi_hwd[cidx]->cmp_info.kernel_profile &&
             !( ESI->profile.flags & PAPI_PROFIL_FORCE_SW ) ) {
            retval = _papi_hwd[cidx]->stop_profiling( ESI->master, ESI );
            if ( retval < PAPI_OK )
                papi_return( retval );
        }
    }
 
    /* If overflowing is enabled, turn it off */
 
    if ( ESI->state & PAPI_OVERFLOWING ) {
        if ( !( ESI->overflow.flags & PAPI_OVERFLOW_HARDWARE ) ) {
            retval = _papi_hwi_stop_timer( _papi_os_info.itimer_num,
                               _papi_os_info.itimer_sig );
            if ( retval != PAPI_OK )
                papi_return( retval );
            _papi_hwi_stop_signal( _papi_os_info.itimer_sig );
        }
    }
 
    /* Update the state of this EventSet */
 
    ESI->state ^= PAPI_RUNNING;
    ESI->state |= PAPI_STOPPED;
 
    /* Update the running event set for this thread */
    if ( !(ESI->state & PAPI_CPU_ATTACHED) ) {
        if ( !( ESI->state & PAPI_ATTACHED ))
            ESI->master->running_eventset[cidx] = NULL;
    } else {
        ESI->CpuInfo->running_eventset[cidx] = NULL;
    }
    
#if defined(DEBUG)
    if ( _papi_hwi_debug & DEBUG_API ) {
        int i;
        for ( i = 0; i < ESI->NumberOfEvents; i++ ) {
            APIDBG( "PAPI_stop ESI->sw_stop[%d]:\t%llu\n", i, ESI->sw_stop[i] );
        }
    }
#endif
 
    return ( PAPI_OK );
}
 
int
PAPI_reset( int EventSet )
{
    APIDBG("Entry: EventSet: %d\n", EventSet);
    int retval = PAPI_OK;
    EventSetInfo_t *ESI;
    hwd_context_t *context;
    int cidx;
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
    cidx = valid_ESI_component( ESI );
    if ( cidx < 0 )
        papi_return( cidx );
 
    if ( ESI->state & PAPI_RUNNING ) {
        if ( _papi_hwi_is_sw_multiplex( ESI ) ) {
            retval = MPX_reset( ESI->multiplex.mpx_evset );
        } else {
            /* If we're not the only one running, then just
               read the current values into the ESI->start
               array. This holds the starting value for counters
               that are shared. */
            /* get the context we should use for this event set */
            context = _papi_hwi_get_context( ESI, NULL );
            retval = _papi_hwd[cidx]->reset( context, ESI->ctl_state );
        }
    } else {
#ifdef __bgp__
        //  For BG/P, we always want to reset the 'real' hardware counters.  The counters
        //  can be controlled via multiple interfaces, and we need to ensure that the values
        //  are truly zero...
        /* get the context we should use for this event set */
        context = _papi_hwi_get_context( ESI, NULL );
        retval = _papi_hwd[cidx]->reset( context, ESI->ctl_state );
#endif
        memset( ESI->sw_stop, 0x00,
                ( size_t ) ESI->NumberOfEvents * sizeof ( long long ) );
    }
 
    APIDBG( "EXIT: retval %d\n", retval );
    papi_return( retval );
}
 
int
PAPI_read( int EventSet, long long *values )
{
    APIDBG( "Entry: EventSet: %d, values: %p\n", EventSet, values);
    EventSetInfo_t *ESI;
    hwd_context_t *context;
    int cidx, retval = PAPI_OK;
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
    cidx = valid_ESI_component( ESI );
    if ( cidx < 0 )
        papi_return( cidx );
 
    if ( values == NULL )
        papi_return( PAPI_EINVAL );
 
    if ( ESI->state & PAPI_RUNNING ) {
        if ( _papi_hwi_is_sw_multiplex( ESI ) ) {
          retval = MPX_read( ESI->multiplex.mpx_evset, values, 0 );
        } else {
            /* get the context we should use for this event set */
            context = _papi_hwi_get_context( ESI, NULL );
            retval = _papi_hwi_read( context, ESI, values );
        }
        if ( retval != PAPI_OK )
            papi_return( retval );
    } else {
        memcpy( values, ESI->sw_stop,
                ( size_t ) ESI->NumberOfEvents * sizeof ( long long ) );
    }
 
#if defined(DEBUG)
    if ( ISLEVEL( DEBUG_API ) ) {
        int i;
        for ( i = 0; i < ESI->NumberOfEvents; i++ ) {
            APIDBG( "PAPI_read values[%d]:\t%lld\n", i, values[i] );
        }
    }
#endif
 
    APIDBG( "PAPI_read returns %d\n", retval );
    return ( PAPI_OK );
}
 
int
PAPI_read_ts( int EventSet, long long *values, long long *cycles )
{
    APIDBG( "Entry: EventSet: %d, values: %p, cycles: %p\n", EventSet, values, cycles);
    EventSetInfo_t *ESI;
    hwd_context_t *context;
    int cidx, retval = PAPI_OK;
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
    cidx = valid_ESI_component( ESI );
    if ( cidx < 0 )
        papi_return( cidx );
 
    if ( values == NULL )
        papi_return( PAPI_EINVAL );
 
    if ( ESI->state & PAPI_RUNNING ) {
        if ( _papi_hwi_is_sw_multiplex( ESI ) ) {
          retval = MPX_read( ESI->multiplex.mpx_evset, values, 0 );
        } else {
            /* get the context we should use for this event set */
            context = _papi_hwi_get_context( ESI, NULL );
            retval = _papi_hwi_read( context, ESI, values );
        }
        if ( retval != PAPI_OK )
            papi_return( retval );
    } else {
        memcpy( values, ESI->sw_stop,
                ( size_t ) ESI->NumberOfEvents * sizeof ( long long ) );
    }
 
    *cycles = _papi_os_vector.get_real_cycles(  );
 
#if defined(DEBUG)
    if ( ISLEVEL( DEBUG_API ) ) {
        int i;
        for ( i = 0; i < ESI->NumberOfEvents; i++ ) {
            APIDBG( "PAPI_read values[%d]:\t%lld\n", i, values[i] );
        }
    }
#endif
 
    APIDBG( "PAPI_read_ts returns %d\n", retval );
    return PAPI_OK;
}
 
int
PAPI_accum( int EventSet, long long *values )
{
    APIDBG("Entry: EventSet: %d, values: %p\n", EventSet, values);
    EventSetInfo_t *ESI;
    hwd_context_t *context;
    int i, cidx, retval;
    long long a, b, c;
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
    cidx = valid_ESI_component( ESI );
    if ( cidx < 0 )
        papi_return( cidx );
 
    if ( values == NULL )
        papi_return( PAPI_EINVAL );
 
    if ( ESI->state & PAPI_RUNNING ) {
        if ( _papi_hwi_is_sw_multiplex( ESI ) ) {
          retval = MPX_read( ESI->multiplex.mpx_evset, ESI->sw_stop, 0 );
        } else {
            /* get the context we should use for this event set */
            context = _papi_hwi_get_context( ESI, NULL );
            retval = _papi_hwi_read( context, ESI, ESI->sw_stop );
        }
        if ( retval != PAPI_OK )
            papi_return( retval );
    }
 
    for ( i = 0; i < ESI->NumberOfEvents; i++ ) {
        a = ESI->sw_stop[i];
        b = values[i];
        c = a + b;
        values[i] = c;
    }
 
    papi_return( PAPI_reset( EventSet ) );
}
 
int
PAPI_write( int EventSet, long long *values )
{
    APIDBG("Entry: EventSet: %d, values: %p\n", EventSet, values);
 
    int cidx, retval = PAPI_OK;
    EventSetInfo_t *ESI;
    hwd_context_t *context;
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
    cidx = valid_ESI_component( ESI );
    if ( cidx < 0 )
        papi_return( cidx );
 
    if ( values == NULL )
        papi_return( PAPI_EINVAL );
 
    if ( ESI->state & PAPI_RUNNING ) {
        /* get the context we should use for this event set */
        context = _papi_hwi_get_context( ESI, NULL );
        retval = _papi_hwd[cidx]->write( context, ESI->ctl_state, values );
        if ( retval != PAPI_OK )
            return ( retval );
    }
 
    memcpy( ESI->hw_start, values,
            ( size_t ) _papi_hwd[cidx]->cmp_info.num_cntrs *
            sizeof ( long long ) );
 
    return ( retval );
}
 
int
PAPI_cleanup_eventset( int EventSet )
{
    APIDBG("Entry: EventSet: %d\n",EventSet);
 
    EventSetInfo_t *ESI;
    int i, cidx, total, retval;
 
    /* Is the EventSet already in existence? */
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
    /* if the eventset has no index and no events, return OK
       otherwise return NOCMP */
    cidx = valid_ESI_component( ESI );
    if ( cidx < 0 ) {
        if ( ESI->NumberOfEvents )
            papi_return( cidx );
        papi_return( PAPI_OK );
    }
 
    /* Of course, it must be stopped in order to modify it. */
 
    if ( ESI->state & PAPI_RUNNING )
        papi_return( PAPI_EISRUN );
 
    /* clear overflow flag and turn off hardware overflow handler */
    if ( ESI->state & PAPI_OVERFLOWING ) {
        total = ESI->overflow.event_counter;
        for ( i = 0; i < total; i++ ) {
            retval = PAPI_overflow( EventSet,
                                    ESI->overflow.EventCode[0], 0, 0, NULL );
            if ( retval != PAPI_OK )
                papi_return( retval );
        }
    }
 
    /* clear profile flag and turn off hardware profile handler */
    if ( ( ESI->state & PAPI_PROFILING ) &&
         _papi_hwd[cidx]->cmp_info.hardware_intr &&
         !( ESI->profile.flags & PAPI_PROFIL_FORCE_SW ) ) {
        total = ESI->profile.event_counter;
        for ( i = 0; i < total; i++ ) {
            retval =
                PAPI_sprofil( NULL, 0, EventSet, ESI->profile.EventCode[0], 0,
                              PAPI_PROFIL_POSIX );
            if ( retval != PAPI_OK )
                papi_return( retval );
        }
    }
 
    if ( _papi_hwi_is_sw_multiplex( ESI ) ) {
        retval = MPX_cleanup( &ESI->multiplex.mpx_evset );
        if ( retval != PAPI_OK )
            papi_return( retval );
    }
 
    retval = _papi_hwd[cidx]->cleanup_eventset( ESI->ctl_state );
    if ( retval != PAPI_OK ) 
        papi_return( retval );
 
    /* Now do the magic */
    papi_return( _papi_hwi_cleanup_eventset( ESI ) );
}
 
int
PAPI_multiplex_init( void )
{
    APIDBG("Entry:\n");
 
    int retval;
 
    retval = mpx_init( _papi_os_info.itimer_ns );
    papi_return( retval );
}
 
int
PAPI_state( int EventSet, int *status )
{
    APIDBG("Entry: EventSet: %d, status: %p\n", EventSet, status);
 
    EventSetInfo_t *ESI;
 
    if ( status == NULL )
        papi_return( PAPI_EINVAL );
 
    /* check for good EventSetIndex value */
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
    /*read status FROM ESI->state */
 
    *status = ESI->state;
 
    return ( PAPI_OK );
}
 
int
PAPI_set_debug( int level )
{
    APIDBG("Entry: level: %d\n", level);
    PAPI_option_t option;
 
    memset( &option, 0x0, sizeof ( option ) );
    option.debug.level = level;
    option.debug.handler = _papi_hwi_debug_handler;
    return ( PAPI_set_opt( PAPI_DEBUG, &option ) );
}
 
/* Attaches to or detaches from the specified thread id */
inline_static int
_papi_set_attach( int option, int EventSet, unsigned long tid )
{
    APIDBG("Entry: option: %d, EventSet: %d, tid: %lu\n", option, EventSet, tid);
    PAPI_option_t attach;
 
    memset( &attach, 0x0, sizeof ( attach ) );
    attach.attach.eventset = EventSet;
    attach.attach.tid = tid;
    return ( PAPI_set_opt( option, &attach ) );
}
 
int
PAPI_attach( int EventSet, unsigned long tid )
{
    APIDBG( "Entry: EventSet: %d, tid: %lu\n", EventSet, tid);
    return ( _papi_set_attach( PAPI_ATTACH, EventSet, tid ) );
}
 
int
PAPI_detach( int EventSet )
{
    APIDBG( "Entry: EventSet: %d\n", EventSet);
    return ( _papi_set_attach( PAPI_DETACH, EventSet, 0 ) );
}
 
int
PAPI_set_multiplex( int EventSet )
{
    APIDBG( "Entry: EventSet: %d\n", EventSet);
 
    PAPI_option_t mpx;
    EventSetInfo_t *ESI;
    int cidx;
    int ret;
 
    /* Is the EventSet already in existence? */
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
 
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
    /* if the eventset has no index return NOCMP */
    cidx = valid_ESI_component( ESI );
    if ( cidx < 0 )
        papi_return( cidx );
 
    if ( ( ret = mpx_check( EventSet ) ) != PAPI_OK )
        papi_return( ret );
 
    memset( &mpx, 0x0, sizeof ( mpx ) );
    mpx.multiplex.eventset = EventSet;
    mpx.multiplex.flags = PAPI_MULTIPLEX_DEFAULT;
    mpx.multiplex.ns = _papi_os_info.itimer_ns;
    return ( PAPI_set_opt( PAPI_MULTIPLEX, &mpx ) );
}
 
int
PAPI_set_opt( int option, PAPI_option_t * ptr )
{
    APIDBG("Entry:  option: %d, ptr: %p\n", option, ptr);
 
    _papi_int_option_t internal;
    int retval = PAPI_OK;
    hwd_context_t *context;
    int cidx;
 
    if ( ( option != PAPI_DEBUG ) && ( init_level == PAPI_NOT_INITED ) )
        papi_return( PAPI_ENOINIT );
    if ( ptr == NULL )
        papi_return( PAPI_EINVAL );
 
    memset( &internal, 0x0, sizeof ( _papi_int_option_t ) );
 
    switch ( option ) {
    case PAPI_DETACH:
    {
        internal.attach.ESI = _papi_hwi_lookup_EventSet( ptr->attach.eventset );
        if ( internal.attach.ESI == NULL )
            papi_return( PAPI_ENOEVST );
 
        cidx = valid_ESI_component( internal.attach.ESI );
        if ( cidx < 0 )
            papi_return( cidx );
 
        if ( _papi_hwd[cidx]->cmp_info.attach == 0 )
            papi_return( PAPI_ECMP );
 
        /* if attached to a cpu, return an error */
        if (internal.attach.ESI->state & PAPI_CPU_ATTACHED)
            papi_return( PAPI_ECMP );
 
        if ( ( internal.attach.ESI->state & PAPI_STOPPED ) == 0 )
            papi_return( PAPI_EISRUN );
 
        if ( ( internal.attach.ESI->state & PAPI_ATTACHED ) == 0 )
            papi_return( PAPI_EINVAL );
 
        internal.attach.tid = internal.attach.ESI->attach.tid;
        /* get the context we should use for this event set */
        context = _papi_hwi_get_context( internal.attach.ESI, NULL );
        retval = _papi_hwd[cidx]->ctl( context, PAPI_DETACH, &internal );
        if ( retval != PAPI_OK )
            papi_return( retval );
 
        internal.attach.ESI->state ^= PAPI_ATTACHED;
        internal.attach.ESI->attach.tid = 0;
        return ( PAPI_OK );
    }
    case PAPI_ATTACH:
    {
        internal.attach.ESI = _papi_hwi_lookup_EventSet( ptr->attach.eventset );
        if ( internal.attach.ESI == NULL )
            papi_return( PAPI_ENOEVST );
 
        cidx = valid_ESI_component( internal.attach.ESI );
        if ( cidx < 0 )
            papi_return( cidx );
 
        if ( _papi_hwd[cidx]->cmp_info.attach == 0 )
            papi_return( PAPI_ECMP );
 
        if ( ( internal.attach.ESI->state & PAPI_STOPPED ) == 0 )
            papi_return( PAPI_EISRUN );
 
        if ( internal.attach.ESI->state & PAPI_ATTACHED )
            papi_return( PAPI_EINVAL );
 
        /* if attached to a cpu, return an error */
        if (internal.attach.ESI->state & PAPI_CPU_ATTACHED)
            papi_return( PAPI_ECMP );
 
        internal.attach.tid = ptr->attach.tid;
        /* get the context we should use for this event set */
        context = _papi_hwi_get_context( internal.attach.ESI, NULL );
        retval = _papi_hwd[cidx]->ctl( context, PAPI_ATTACH, &internal );
        if ( retval != PAPI_OK )
            papi_return( retval );
 
        internal.attach.ESI->state |= PAPI_ATTACHED;
        internal.attach.ESI->attach.tid = ptr->attach.tid;
 
        papi_return (_papi_hwi_lookup_or_create_thread( 
                      &(internal.attach.ESI->master), ptr->attach.tid ));
    }
    case PAPI_CPU_ATTACH:
    {
        APIDBG("eventset: %d, cpu_num: %d\n", ptr->cpu.eventset, ptr->cpu.cpu_num);
        internal.cpu.ESI = _papi_hwi_lookup_EventSet( ptr->cpu.eventset );
        if ( internal.cpu.ESI == NULL )
            papi_return( PAPI_ENOEVST );
 
        internal.cpu.cpu_num = ptr->cpu.cpu_num;
        APIDBG("internal: %p, ESI: %p, cpu_num: %d\n", &internal, internal.cpu.ESI, internal.cpu.cpu_num);
 
        cidx = valid_ESI_component( internal.cpu.ESI );
        if ( cidx < 0 )
            papi_return( cidx );
 
        if ( _papi_hwd[cidx]->cmp_info.cpu == 0 )
            papi_return( PAPI_ECMP );
 
        // can not attach to a cpu if already attached to a process or 
        // counters set to be inherited by child processes
        if ( internal.cpu.ESI->state & (PAPI_ATTACHED | PAPI_INHERIT) )
            papi_return( PAPI_EINVAL );
 
        if ( ( internal.cpu.ESI->state & PAPI_STOPPED ) == 0 )
            papi_return( PAPI_EISRUN );
 
        retval = _papi_hwi_lookup_or_create_cpu(&internal.cpu.ESI->CpuInfo, internal.cpu.cpu_num);
        if( retval != PAPI_OK) {
            papi_return( retval );
        }
 
        /* get the context we should use for this event set */
        context = _papi_hwi_get_context( internal.cpu.ESI, NULL );
        retval = _papi_hwd[cidx]->ctl( context, PAPI_CPU_ATTACH, &internal );
        if ( retval != PAPI_OK )
            papi_return( retval );
 
        /* set to show this event set is attached to a cpu not a thread */
        internal.cpu.ESI->state |= PAPI_CPU_ATTACHED;
        return ( PAPI_OK );
    }
    case PAPI_DEF_MPX_NS:
    {
        cidx = 0;            /* xxxx for now, assume we only check against cpu component */
        if ( ptr->multiplex.ns < 0 )
            papi_return( PAPI_EINVAL );
        /* We should check the resolution here with the system, either
           component if kernel multiplexing or PAPI if SW multiplexing. */
        internal.multiplex.ns = ( unsigned long ) ptr->multiplex.ns;
        /* get the context we should use for this event set */
        context = _papi_hwi_get_context( internal.cpu.ESI, NULL );
        /* Low level just checks/adjusts the args for this component */
        retval = _papi_hwd[cidx]->ctl( context, PAPI_DEF_MPX_NS, &internal );
        if ( retval == PAPI_OK ) {
            _papi_os_info.itimer_ns = ( int ) internal.multiplex.ns;
            ptr->multiplex.ns = ( int ) internal.multiplex.ns;
        }
        papi_return( retval );
    }
    case PAPI_DEF_ITIMER_NS:
    {
        cidx = 0;            /* xxxx for now, assume we only check against cpu component */
        if ( ptr->itimer.ns < 0 )
            papi_return( PAPI_EINVAL );
        internal.itimer.ns = ptr->itimer.ns;
        /* Low level just checks/adjusts the args for this component */
        retval = _papi_hwd[cidx]->ctl( NULL, PAPI_DEF_ITIMER_NS, &internal );
        if ( retval == PAPI_OK ) {
            _papi_os_info.itimer_ns = internal.itimer.ns;
            ptr->itimer.ns = internal.itimer.ns;
        }
        papi_return( retval );
    }
    case PAPI_DEF_ITIMER:
    {
        cidx = 0;            /* xxxx for now, assume we only check against cpu component */
        if ( ptr->itimer.ns < 0 )
            papi_return( PAPI_EINVAL );
        memcpy( &internal.itimer, &ptr->itimer,
                sizeof ( PAPI_itimer_option_t ) );
        /* Low level just checks/adjusts the args for this component */
        retval = _papi_hwd[cidx]->ctl( NULL, PAPI_DEF_ITIMER, &internal );
        if ( retval == PAPI_OK ) {
            _papi_os_info.itimer_num = ptr->itimer.itimer_num;
            _papi_os_info.itimer_sig = ptr->itimer.itimer_sig;
            if ( ptr->itimer.ns > 0 )
                _papi_os_info.itimer_ns = ptr->itimer.ns;
            /* flags are currently ignored, eventually the flags will be able
               to specify whether or not we use POSIX itimers (clock_gettimer) */
        }
        papi_return( retval );
    }
    case PAPI_MULTIPLEX:
    {
        EventSetInfo_t *ESI;
        ESI = _papi_hwi_lookup_EventSet( ptr->multiplex.eventset );
       
        if ( ESI == NULL )
            papi_return( PAPI_ENOEVST );
 
        cidx = valid_ESI_component( ESI );
        if ( cidx < 0 )
            papi_return( cidx );
       
        if ( !( ESI->state & PAPI_STOPPED ) )
            papi_return( PAPI_EISRUN );
        if ( ESI->state & PAPI_MULTIPLEXING )
            papi_return( PAPI_EINVAL );
 
        if ( ptr->multiplex.ns < 0 )
            papi_return( PAPI_EINVAL );
        internal.multiplex.ESI = ESI;
        internal.multiplex.ns = ( unsigned long ) ptr->multiplex.ns;
        internal.multiplex.flags = ptr->multiplex.flags;
        if ( ( _papi_hwd[cidx]->cmp_info.kernel_multiplex ) &&
             ( ( ptr->multiplex.flags & PAPI_MULTIPLEX_FORCE_SW ) == 0 ) ) {
            /* get the context we should use for this event set */
            context = _papi_hwi_get_context( ESI, NULL );
            retval = _papi_hwd[cidx]->ctl( context, PAPI_MULTIPLEX, &internal );
        }
        /* Kernel or PAPI may have changed this value so send it back out to the user */
        ptr->multiplex.ns = ( int ) internal.multiplex.ns;
        if ( retval == PAPI_OK )
            papi_return( _papi_hwi_convert_eventset_to_multiplex
                         ( &internal.multiplex ) );
        return ( retval );
    }
    case PAPI_DEBUG:
    {
        int level = ptr->debug.level;
        switch ( level ) {
        case PAPI_QUIET:
        case PAPI_VERB_ESTOP:
        case PAPI_VERB_ECONT:
            _papi_hwi_error_level = level;
            break;
        default:
            papi_return( PAPI_EINVAL );
        }
        _papi_hwi_debug_handler = ptr->debug.handler;
        return ( PAPI_OK );
    }
    case PAPI_DEFDOM:
    {
        int dom = ptr->defdomain.domain;
        if ( ( dom < PAPI_DOM_MIN ) || ( dom > PAPI_DOM_MAX ) )
            papi_return( PAPI_EINVAL );
 
        /* Change the global structure. The _papi_hwd_init_control_state function 
           in the components gets information from the global structure instead of
           per-thread information. */
        cidx = valid_component( ptr->defdomain.def_cidx );
        if ( cidx < 0 )
            papi_return( cidx );
 
        /* Check what the component supports */
 
        if ( dom == PAPI_DOM_ALL )
            dom = _papi_hwd[cidx]->cmp_info.available_domains;
 
        if ( dom & ~_papi_hwd[cidx]->cmp_info.available_domains )
            papi_return( PAPI_ENOSUPP );
 
        _papi_hwd[cidx]->cmp_info.default_domain = dom;
 
        return ( PAPI_OK );
    }
    case PAPI_DOMAIN:
    {
        int dom = ptr->domain.domain;
        if ( ( dom < PAPI_DOM_MIN ) || ( dom > PAPI_DOM_MAX ) )
            papi_return( PAPI_EINVAL_DOM );
 
        internal.domain.ESI = _papi_hwi_lookup_EventSet( ptr->domain.eventset );
        if ( internal.domain.ESI == NULL )
            papi_return( PAPI_ENOEVST );
 
        cidx = valid_ESI_component( internal.domain.ESI );
        if ( cidx < 0 )
            papi_return( cidx );
 
        /* Check what the component supports */
 
        if ( dom == PAPI_DOM_ALL )
            dom = _papi_hwd[cidx]->cmp_info.available_domains;
 
        if ( dom & ~_papi_hwd[cidx]->cmp_info.available_domains )
            papi_return( PAPI_EINVAL_DOM );
 
        if ( !( internal.domain.ESI->state & PAPI_STOPPED ) )
            papi_return( PAPI_EISRUN );
 
        /* Try to change the domain of the eventset in the hardware */
        internal.domain.domain = dom;
        internal.domain.eventset = ptr->domain.eventset;
        /* get the context we should use for this event set */
        context = _papi_hwi_get_context( internal.domain.ESI, NULL );
        retval = _papi_hwd[cidx]->ctl( context, PAPI_DOMAIN, &internal );
        if ( retval < PAPI_OK )
            papi_return( retval );
 
        /* Change the domain of the eventset in the library */
 
        internal.domain.ESI->domain.domain = dom;
 
        return ( retval );
    }
    case PAPI_DEFGRN:
    {
        int grn = ptr->defgranularity.granularity;
        if ( ( grn < PAPI_GRN_MIN ) || ( grn > PAPI_GRN_MAX ) )
            papi_return( PAPI_EINVAL );
 
        cidx = valid_component( ptr->defgranularity.def_cidx );
        if ( cidx < 0 )
            papi_return( cidx );
 
        /* Change the component structure. The _papi_hwd_init_control_state function 
           in the components gets information from the global structure instead of
           per-thread information. */
 
        /* Check what the component supports */
 
        if ( grn & ~_papi_hwd[cidx]->cmp_info.available_granularities )
            papi_return( PAPI_EINVAL );
 
        /* Make sure there is only 1 set. */
        if ( grn ^ ( 1 << ( ffs( grn ) - 1 ) ) )
            papi_return( PAPI_EINVAL );
 
        _papi_hwd[cidx]->cmp_info.default_granularity = grn;
 
        return ( PAPI_OK );
    }
    case PAPI_GRANUL:
    {
        int grn = ptr->granularity.granularity;
 
        if ( ( grn < PAPI_GRN_MIN ) || ( grn > PAPI_GRN_MAX ) )
            papi_return( PAPI_EINVAL );
 
        internal.granularity.ESI =
            _papi_hwi_lookup_EventSet( ptr->granularity.eventset );
        if ( internal.granularity.ESI == NULL )
            papi_return( PAPI_ENOEVST );
 
        cidx = valid_ESI_component( internal.granularity.ESI );
        if ( cidx < 0 )
            papi_return( cidx );
 
        /* Check what the component supports */
 
        if ( grn & ~_papi_hwd[cidx]->cmp_info.available_granularities )
            papi_return( PAPI_EINVAL );
 
        /* Make sure there is only 1 set. */
        if ( grn ^ ( 1 << ( ffs( grn ) - 1 ) ) )
            papi_return( PAPI_EINVAL );
 
        internal.granularity.granularity = grn;
        internal.granularity.eventset = ptr->granularity.eventset;
        retval = _papi_hwd[cidx]->ctl( NULL, PAPI_GRANUL, &internal );
        if ( retval < PAPI_OK )
            return ( retval );
 
        internal.granularity.ESI->granularity.granularity = grn;
        return ( retval );
    }
    case PAPI_INHERIT:
    {
        EventSetInfo_t *ESI;
        ESI = _papi_hwi_lookup_EventSet( ptr->inherit.eventset );
        if ( ESI == NULL )
            papi_return( PAPI_ENOEVST );
 
        cidx = valid_ESI_component( ESI );
        if ( cidx < 0 )
            papi_return( cidx );
 
        if ( _papi_hwd[cidx]->cmp_info.inherit == 0 )
            papi_return( PAPI_ECMP );
 
        if ( ( ESI->state & PAPI_STOPPED ) == 0 )
            papi_return( PAPI_EISRUN );
 
        /* if attached to a cpu, return an error */
        if (ESI->state & PAPI_CPU_ATTACHED)
            papi_return( PAPI_ECMP );
 
        internal.inherit.ESI = ESI;
        internal.inherit.inherit = ptr->inherit.inherit;
 
        /* get the context we should use for this event set */
        context = _papi_hwi_get_context( internal.inherit.ESI, NULL );
        retval = _papi_hwd[cidx]->ctl( context, PAPI_INHERIT, &internal );
        if ( retval < PAPI_OK )
            return ( retval );
 
        ESI->inherit.inherit = ptr->inherit.inherit;
        return ( retval );
    }
    case PAPI_DATA_ADDRESS:
    case PAPI_INSTR_ADDRESS:
    {
 
        EventSetInfo_t *ESI;
 
        ESI = _papi_hwi_lookup_EventSet( ptr->addr.eventset );
        if ( ESI == NULL )
            papi_return( PAPI_ENOEVST );
 
        cidx = valid_ESI_component( ESI );
        if ( cidx < 0 )
            papi_return( cidx );
 
        internal.address_range.ESI = ESI;
 
        if ( !( internal.address_range.ESI->state & PAPI_STOPPED ) )
            papi_return( PAPI_EISRUN );
 
        /*set domain to be PAPI_DOM_USER */
        internal.address_range.domain = PAPI_DOM_USER;
 
        internal.address_range.start = ptr->addr.start;
        internal.address_range.end = ptr->addr.end;
        /* get the context we should use for this event set */
        context = _papi_hwi_get_context( internal.address_range.ESI, NULL );
        retval = _papi_hwd[cidx]->ctl( context, option, &internal );
        ptr->addr.start_off = internal.address_range.start_off;
        ptr->addr.end_off = internal.address_range.end_off;
        papi_return( retval );
    }
    case PAPI_USER_EVENTS_FILE:
    {
        APIDBG("User Events Filename is -%s-\n", ptr->events_file);
 
        // go load the user defined event definitions from the applications event definition file
        // do not know how to find a pmu name and type for this operation yet
//      retval = papi_load_derived_events(pmu_str, pmu_type, cidx, 0);
 
//      _papi_user_defined_events_setup(ptr->events_file);
        return( PAPI_OK );
    }
    default:
        papi_return( PAPI_EINVAL );
    }
}
 
int
PAPI_num_hwctrs( void )
{
    APIDBG( "Entry:\n");
    return ( PAPI_num_cmp_hwctrs( 0 ) );
}
 
int
PAPI_num_cmp_hwctrs( int cidx )
{
    APIDBG( "Entry: cidx: %d\n", cidx);
    return ( PAPI_get_cmp_opt( PAPI_MAX_HWCTRS, NULL, cidx ) );
}
 
int
PAPI_get_multiplex( int EventSet )
{
    APIDBG( "Entry: EventSet: %d\n", EventSet);
    PAPI_option_t popt;
    int retval;
 
    popt.multiplex.eventset = EventSet;
    retval = PAPI_get_opt( PAPI_MULTIPLEX, &popt );
    if ( retval < 0 )
        retval = 0;
    return retval;
}
 
int
PAPI_get_opt( int option, PAPI_option_t * ptr )
{
    APIDBG( "Entry: option: %d, ptr: %p\n", option, ptr);
    EventSetInfo_t *ESI;
 
    if ( ( option != PAPI_DEBUG ) && ( init_level == PAPI_NOT_INITED ) &&
         ( option != PAPI_LIB_VERSION ) )
        papi_return( PAPI_ENOINIT );
 
    switch ( option ) {
    case PAPI_DETACH:
    {
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        ESI = _papi_hwi_lookup_EventSet( ptr->attach.eventset );
        if ( ESI == NULL )
            papi_return( PAPI_ENOEVST );
        ptr->attach.tid = ESI->attach.tid;
        return ( ( ESI->state & PAPI_ATTACHED ) == 0 );
    }
    case PAPI_ATTACH:
    {
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        ESI = _papi_hwi_lookup_EventSet( ptr->attach.eventset );
        if ( ESI == NULL )
            papi_return( PAPI_ENOEVST );
        ptr->attach.tid = ESI->attach.tid;
        return ( ( ESI->state & PAPI_ATTACHED ) != 0 );
    }
    case PAPI_CPU_ATTACH:
    {
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        ESI = _papi_hwi_lookup_EventSet( ptr->attach.eventset );
        if ( ESI == NULL )
            papi_return( PAPI_ENOEVST );
        ptr->cpu.cpu_num = ESI->CpuInfo->cpu_num;
        return ( ( ESI->state & PAPI_CPU_ATTACHED ) != 0 );
    }
    case PAPI_DEF_MPX_NS:
    {
        /* xxxx for now, assume we only check against cpu component */
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        ptr->multiplex.ns = _papi_os_info.itimer_ns;
        return ( PAPI_OK );
    }
    case PAPI_DEF_ITIMER_NS:
    {
        /* xxxx for now, assume we only check against cpu component */
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        ptr->itimer.ns = _papi_os_info.itimer_ns;
        return ( PAPI_OK );
    }
    case PAPI_DEF_ITIMER:
    {
        /* xxxx for now, assume we only check against cpu component */
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        ptr->itimer.itimer_num = _papi_os_info.itimer_num;
        ptr->itimer.itimer_sig = _papi_os_info.itimer_sig;
        ptr->itimer.ns = _papi_os_info.itimer_ns;
        ptr->itimer.flags = 0;
        return ( PAPI_OK );
    }
    case PAPI_MULTIPLEX:
    {
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        ESI = _papi_hwi_lookup_EventSet( ptr->multiplex.eventset );
        if ( ESI == NULL )
            papi_return( PAPI_ENOEVST );
        ptr->multiplex.ns = ESI->multiplex.ns;
        ptr->multiplex.flags = ESI->multiplex.flags;
        return ( ESI->state & PAPI_MULTIPLEXING ) != 0;
    }
    case PAPI_PRELOAD:
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        memcpy( &ptr->preload, &_papi_hwi_system_info.preload_info,
                sizeof ( PAPI_preload_info_t ) );
        break;
    case PAPI_DEBUG:
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        ptr->debug.level = _papi_hwi_error_level;
        ptr->debug.handler = _papi_hwi_debug_handler;
        break;
    case PAPI_CLOCKRATE:
        return ( ( int ) _papi_hwi_system_info.hw_info.cpu_max_mhz );
    case PAPI_MAX_CPUS:
        return ( _papi_hwi_system_info.hw_info.ncpu );
        /* For now, MAX_HWCTRS and MAX CTRS are identical.
           At some future point, they may map onto different values.
         */
    case PAPI_INHERIT:
    {
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        ESI = _papi_hwi_lookup_EventSet( ptr->inherit.eventset );
        if ( ESI == NULL )
            papi_return( PAPI_ENOEVST );
        ptr->inherit.inherit = ESI->inherit.inherit;
        return ( PAPI_OK );
    }
    case PAPI_GRANUL:
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        ESI = _papi_hwi_lookup_EventSet( ptr->granularity.eventset );
        if ( ESI == NULL )
            papi_return( PAPI_ENOEVST );
        ptr->granularity.granularity = ESI->granularity.granularity;
        break;
    case PAPI_EXEINFO:
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        ptr->exe_info = &_papi_hwi_system_info.exe_info;
        break;
    case PAPI_HWINFO:
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        ptr->hw_info = &_papi_hwi_system_info.hw_info;
        break;
 
    case PAPI_DOMAIN:
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        ESI = _papi_hwi_lookup_EventSet( ptr->domain.eventset );
        if ( ESI == NULL )
            papi_return( PAPI_ENOEVST );
        ptr->domain.domain = ESI->domain.domain;
        return ( PAPI_OK );
    case PAPI_LIB_VERSION:
        return ( PAPI_VERSION );
/* The following cases all require a component index 
    and are handled by PAPI_get_cmp_opt() with cidx == 0*/
    case PAPI_MAX_HWCTRS:
    case PAPI_MAX_MPX_CTRS:
    case PAPI_DEFDOM:
    case PAPI_DEFGRN:
    case PAPI_SHLIBINFO:
    case PAPI_COMPONENTINFO:
        return ( PAPI_get_cmp_opt( option, ptr, 0 ) );
    default:
        papi_return( PAPI_EINVAL );
    }
    return ( PAPI_OK );
}
 
int
PAPI_get_cmp_opt( int option, PAPI_option_t * ptr, int cidx )
{
    APIDBG( "Entry: option: %d, ptr: %p, cidx: %d\n", option, ptr, cidx);
 
  if (_papi_hwi_invalid_cmp(cidx)) {
     return PAPI_ECMP;
  }
 
    switch ( option ) {
        /* For now, MAX_HWCTRS and MAX CTRS are identical.
           At some future point, they may map onto different values.
         */
    case PAPI_MAX_HWCTRS:
        return ( _papi_hwd[cidx]->cmp_info.num_cntrs );
    case PAPI_MAX_MPX_CTRS:
        return ( _papi_hwd[cidx]->cmp_info.num_mpx_cntrs );
    case PAPI_DEFDOM:
        return ( _papi_hwd[cidx]->cmp_info.default_domain );
    case PAPI_DEFGRN:
        return ( _papi_hwd[cidx]->cmp_info.default_granularity );
    case PAPI_SHLIBINFO:
    {
        int retval;
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        retval = _papi_os_vector.update_shlib_info( &_papi_hwi_system_info );
        ptr->shlib_info = &_papi_hwi_system_info.shlib_info;
        papi_return( retval );
    }
    case PAPI_COMPONENTINFO:
        if ( ptr == NULL )
            papi_return( PAPI_EINVAL );
        ptr->cmp_info = &( _papi_hwd[cidx]->cmp_info );
        return PAPI_OK;
    default:
      papi_return( PAPI_EINVAL );
    }
    return PAPI_OK;
}
 
int
PAPI_num_components( void )
{
    APIDBG( "Entry:\n");
    return ( papi_num_components );
}
 
int
PAPI_num_events( int EventSet )
{
    APIDBG( "Entry: EventSet: %d\n", EventSet);
    EventSetInfo_t *ESI;
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( !ESI )
        papi_return( PAPI_ENOEVST );
 
#ifdef DEBUG
    /* Not necessary */
    if ( ESI->NumberOfEvents == 0 )
        papi_return( PAPI_EINVAL );
#endif
 
    return ( ESI->NumberOfEvents );
}
 
 
void
PAPI_shutdown( void )
{
    APIDBG( "Entry:\n");
 
        EventSetInfo_t *ESI;
        ThreadInfo_t *master;
        DynamicArray_t *map = &_papi_hwi_system_info.global_eventset_map;
        int i, j = 0, k, retval;
 
 
    if ( init_retval == DEADBEEF ) {
        PAPIERROR( PAPI_SHUTDOWN_str );
        return;
    }
 
    MPX_shutdown(  );
 
    /* Free all EventSets for this thread */
 
   master = _papi_hwi_lookup_thread( 0 );
 
      /* Count number of running EventSets AND */
      /* Stop any running EventSets in this thread */
 
#ifdef DEBUG
again:
#endif
   for( i = 0; i < map->totalSlots; i++ ) {
      ESI = map->dataSlotArray[i];
      if ( ESI ) {
     if ( ESI->master == master ) {
        if ( ESI->state & PAPI_RUNNING ) {
           if((retval = PAPI_stop( i, NULL )) != PAPI_OK) {
               APIDBG("Call to PAPI_stop failed: %d\n", retval);
           }
        }
        retval=PAPI_cleanup_eventset( i );
        if (retval!=PAPI_OK) PAPIERROR("Error during cleanup.");
        _papi_hwi_free_EventSet( ESI );
     } 
         else {
            if ( ESI->state & PAPI_RUNNING ) {
           j++;
        }
     }
      }
   }
 
    /* No locking required, we're just waiting for the others
       to call shutdown or stop their eventsets. */
 
#ifdef DEBUG
    if ( j != 0 ) {
        PAPIERROR( PAPI_SHUTDOWN_SYNC_str );
        sleep( 1 );
        j = 0;
        goto again;
    }
#endif
 
    // if we have some user events defined, release the space they allocated
    // give back the strings which were allocated when each event was created
    for ( i=0 ; i<user_defined_events_count ; i++) {
        papi_free (user_defined_events[i].symbol);
        papi_free (user_defined_events[i].postfix);
        papi_free (user_defined_events[i].long_descr);
        papi_free (user_defined_events[i].short_descr);
        papi_free (user_defined_events[i].note);
        for ( k=0 ; k<(int)(user_defined_events[i].count) ; k++) {
            papi_free (user_defined_events[i].name[k]);
        }
    }
    // make sure the user events list is empty
    memset (user_defined_events, '\0' , sizeof(user_defined_events));
    user_defined_events_count = 0;
 
    /* Shutdown the entire component */
    //_papi_hwi_shutdown_highlevel(  );
    _papi_hwi_shutdown_global_internal(  );
    _papi_hwi_shutdown_global_threads(  );
    for( i = 0; i < papi_num_components; i++ ) {
       if (!_papi_hwd[i]->cmp_info.disabled) {
              _papi_hwd[i]->shutdown_component(  );
       }
    }
 
    /* Now it is safe to call re-init */
 
    init_retval = DEADBEEF;
    init_level = PAPI_NOT_INITED;
    _papi_mem_cleanup_all(  );
}
 
char *
PAPI_strerror( int errorCode )
{
    if ( ( errorCode > 0 ) || ( -errorCode > _papi_hwi_num_errors ) )
        return ( NULL );
 
    return ( _papi_errlist[-errorCode] );
}
 
void
PAPI_perror( const char *msg )
{
    char *foo;
 
    foo = PAPI_strerror( _papi_hwi_errno );
    if ( foo == NULL )
        return;
 
    if ( msg )
        if ( *msg )
            fprintf( stderr, "%s: ", msg );
 
    fprintf( stderr, "%s\n", foo );
}
 
int
PAPI_overflow( int EventSet, int EventCode, int threshold, int flags,
           PAPI_overflow_handler_t handler )
{
    APIDBG( "Entry: EventSet: %d, EventCode: %#x, threshold: %d, flags: %#x, handler: %p\n", EventSet, EventCode, threshold, flags, handler);
    int retval, cidx, index, i;
    EventSetInfo_t *ESI;
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL ) {
        OVFDBG("No EventSet\n");
        papi_return( PAPI_ENOEVST );
        }
 
    cidx = valid_ESI_component( ESI );
    if ( cidx < 0 ) {
        OVFDBG("Component Error\n");
        papi_return( cidx );
    }
 
    if ( ( ESI->state & PAPI_STOPPED ) != PAPI_STOPPED ) {
        OVFDBG("Already running\n");
        papi_return( PAPI_EISRUN );
    }
 
    if ( ESI->state & PAPI_ATTACHED ) {
        OVFDBG("Attached\n");
        papi_return( PAPI_EINVAL );
    }
    
    if ( ESI->state & PAPI_CPU_ATTACHED ) {
        OVFDBG("CPU attached\n");
        papi_return( PAPI_EINVAL );
    }
    
    if ( ( index = _papi_hwi_lookup_EventCodeIndex( ESI,
                        ( unsigned int ) EventCode ) ) < 0 ) {
        papi_return( PAPI_ENOEVNT );
    }
 
    if ( threshold < 0 ) {
        OVFDBG("Threshold below zero\n");
        papi_return( PAPI_EINVAL );
    }
 
    /* We do not support derived events in overflow */
    /* Unless it's DERIVED_CMPD in which no calculations are done */
 
    if ( !( flags & PAPI_OVERFLOW_FORCE_SW ) && threshold != 0 &&
         ( ESI->EventInfoArray[index].derived ) &&
         ( ESI->EventInfoArray[index].derived != DERIVED_CMPD ) ) {
        OVFDBG("Derived event in overflow\n");
        papi_return( PAPI_EINVAL );
    }
 
    /* the first time to call PAPI_overflow function */
 
    if ( !( ESI->state & PAPI_OVERFLOWING ) ) {
        if ( handler == NULL ) {
            OVFDBG("NULL handler\n");
            papi_return( PAPI_EINVAL );
        }
        if ( threshold == 0 ) {
            OVFDBG("Zero threshold\n");
            papi_return( PAPI_EINVAL );
        }
    }
    if ( threshold > 0 &&
         ESI->overflow.event_counter >= _papi_hwd[cidx]->cmp_info.num_cntrs )
        papi_return( PAPI_ECNFLCT );
 
    if ( threshold == 0 ) {
        for ( i = 0; i < ESI->overflow.event_counter; i++ ) {
            if ( ESI->overflow.EventCode[i] == EventCode )
                break;
        }
        /* EventCode not found */
        if ( i == ESI->overflow.event_counter )
            papi_return( PAPI_EINVAL );
        /* compact these arrays */
        while ( i < ESI->overflow.event_counter - 1 ) {
            ESI->overflow.deadline[i] = ESI->overflow.deadline[i + 1];
            ESI->overflow.threshold[i] = ESI->overflow.threshold[i + 1];
            ESI->overflow.EventIndex[i] = ESI->overflow.EventIndex[i + 1];
            ESI->overflow.EventCode[i] = ESI->overflow.EventCode[i + 1];
            i++;
        }
        ESI->overflow.deadline[i] = 0;
        ESI->overflow.threshold[i] = 0;
        ESI->overflow.EventIndex[i] = 0;
        ESI->overflow.EventCode[i] = 0;
        ESI->overflow.event_counter--;
    } else {
        if ( ESI->overflow.event_counter > 0 ) {
            if ( ( flags & PAPI_OVERFLOW_FORCE_SW ) &&
                 ( ESI->overflow.flags & PAPI_OVERFLOW_HARDWARE ) )
                papi_return( PAPI_ECNFLCT );
            if ( !( flags & PAPI_OVERFLOW_FORCE_SW ) &&
                 ( ESI->overflow.flags & PAPI_OVERFLOW_FORCE_SW ) )
                papi_return( PAPI_ECNFLCT );
        }
        for ( i = 0; i < ESI->overflow.event_counter; i++ ) {
            if ( ESI->overflow.EventCode[i] == EventCode )
                break;
        }
        /* A new entry */
        if ( i == ESI->overflow.event_counter ) {
            ESI->overflow.EventCode[i] = EventCode;
            ESI->overflow.event_counter++;
        }
        /* New or existing entry */
        ESI->overflow.deadline[i] = threshold;
        ESI->overflow.threshold[i] = threshold;
        ESI->overflow.EventIndex[i] = index;
        ESI->overflow.flags = flags;
 
    }
 
    /* If overflowing is already active, we should check to
       make sure that we don't specify a different handler
       or different flags here. You can't mix them. */
 
    ESI->overflow.handler = handler;
 
    /* Set up the option structure for the low level.
       If we have hardware interrupts and we are not using
       forced software emulated interrupts */
 
    if ( _papi_hwd[cidx]->cmp_info.hardware_intr &&
         !( ESI->overflow.flags & PAPI_OVERFLOW_FORCE_SW ) ) {
        retval = _papi_hwd[cidx]->set_overflow( ESI, index, threshold );
        if ( retval == PAPI_OK )
            ESI->overflow.flags |= PAPI_OVERFLOW_HARDWARE;
        else {
            papi_return( retval );  /* We should undo stuff here */
        }
    } else {
        /* Make sure hardware overflow is not set */
        ESI->overflow.flags &= ~( PAPI_OVERFLOW_HARDWARE );
    }
 
    APIDBG( "Overflow using: %s\n",
            ( ESI->overflow.
              flags & PAPI_OVERFLOW_HARDWARE ? "[Hardware]" : ESI->overflow.
              flags & PAPI_OVERFLOW_FORCE_SW ? "[Forced Software]" :
              "[Software]" ) );
 
    /* Toggle the overflow flags and ESI state */
 
    if ( ESI->overflow.event_counter >= 1 )
        ESI->state |= PAPI_OVERFLOWING;
    else {
        ESI->state ^= PAPI_OVERFLOWING;
        ESI->overflow.flags = 0;
        ESI->overflow.handler = NULL;
    }
 
    return PAPI_OK;
}
 
int
PAPI_sprofil( PAPI_sprofil_t *prof, int profcnt, int EventSet,
              int EventCode, int threshold, int flags )
{
    APIDBG( "Entry: prof: %p, profcnt: %d, EventSet: %d, EventCode: %#x, threshold: %d, flags: %#x\n", prof, profcnt, EventSet, EventCode, threshold, flags);
   EventSetInfo_t *ESI;
   int retval, index, i, buckets;
   int forceSW = 0;
   int cidx;
 
   /* Check to make sure EventSet exists */
   ESI = _papi_hwi_lookup_EventSet( EventSet );
   if ( ESI == NULL ) {
      papi_return( PAPI_ENOEVST );
   }
 
   /* Check to make sure EventSet is stopped */
   if ( ( ESI->state & PAPI_STOPPED ) != PAPI_STOPPED ) {
      papi_return( PAPI_EISRUN );
   }
 
   /* We cannot profile if attached */
   if ( ESI->state & PAPI_ATTACHED ) {
      papi_return( PAPI_EINVAL );
   }
 
   /* We cannot profile if cpu attached */
   if ( ESI->state & PAPI_CPU_ATTACHED ) {
      papi_return( PAPI_EINVAL );
   }
 
   /* Get component for EventSet */
   cidx = valid_ESI_component( ESI );
   if ( cidx < 0 ) {
      papi_return( cidx );
   }
 
   /* Get index of the Event we want to profile */
   if ( ( index = _papi_hwi_lookup_EventCodeIndex( ESI,
                      (unsigned int) EventCode ) ) < 0 ) {
      papi_return( PAPI_ENOEVNT );
   }
 
   /* We do not support derived events in overflow */
   /* Unless it's DERIVED_CMPD in which no calculations are done */
   if ( ( ESI->EventInfoArray[index].derived ) &&
    ( ESI->EventInfoArray[index].derived != DERIVED_CMPD ) &&
    !( flags & PAPI_PROFIL_FORCE_SW ) ) {
      papi_return( PAPI_EINVAL );
   }
 
   /* If no prof structures, then make sure count is 0 */
   if ( prof == NULL ) {
      profcnt = 0;
   }
 
   /* check all profile regions for valid scale factors of:
      2 (131072/65536),
      1 (65536/65536),
      or < 1 (65535 -> 2) as defined in unix profil()
      2/65536 is reserved for single bucket profiling
      {0,1}/65536 are traditionally used to terminate profiling
      but are unused here since PAPI uses threshold instead
    */
   for( i = 0; i < profcnt; i++ ) {
      if ( !( ( prof[i].pr_scale == 131072 ) ||
       ( ( prof[i].pr_scale <= 65536 && prof[i].pr_scale > 1 ) ) ) ) {
     APIDBG( "Improper scale factor: %d\n", prof[i].pr_scale );
     papi_return( PAPI_EINVAL );
      }
   }
 
   /* Make sure threshold is valid */
   if ( threshold < 0 ) {
      papi_return( PAPI_EINVAL );
   }
 
   /* the first time to call PAPI_sprofil */
   if ( !( ESI->state & PAPI_PROFILING ) ) {
      if ( threshold == 0 ) {
     papi_return( PAPI_EINVAL );
      }
   }
 
   /* ??? */
   if ( (threshold > 0) &&
    (ESI->profile.event_counter >= _papi_hwd[cidx]->cmp_info.num_cntrs) ) {
      papi_return( PAPI_ECNFLCT );
   }
 
   if ( threshold == 0 ) {
      for( i = 0; i < ESI->profile.event_counter; i++ ) {
     if ( ESI->profile.EventCode[i] == EventCode ) {
        break;
     }
      }
        
      /* EventCode not found */
      if ( i == ESI->profile.event_counter ) {
     papi_return( PAPI_EINVAL );
      }
 
      /* compact these arrays */
      while ( i < ESI->profile.event_counter - 1 ) {
         ESI->profile.prof[i] = ESI->profile.prof[i + 1];
     ESI->profile.count[i] = ESI->profile.count[i + 1];
     ESI->profile.threshold[i] = ESI->profile.threshold[i + 1];
     ESI->profile.EventIndex[i] = ESI->profile.EventIndex[i + 1];
     ESI->profile.EventCode[i] = ESI->profile.EventCode[i + 1];
     i++;
      }
      ESI->profile.prof[i] = NULL;
      ESI->profile.count[i] = 0;
      ESI->profile.threshold[i] = 0;
      ESI->profile.EventIndex[i] = 0;
      ESI->profile.EventCode[i] = 0;
      ESI->profile.event_counter--;
   } else {
      if ( ESI->profile.event_counter > 0 ) {
     if ( ( flags & PAPI_PROFIL_FORCE_SW ) &&
          !( ESI->profile.flags & PAPI_PROFIL_FORCE_SW ) ) {
        papi_return( PAPI_ECNFLCT );
     }
     if ( !( flags & PAPI_PROFIL_FORCE_SW ) &&
          ( ESI->profile.flags & PAPI_PROFIL_FORCE_SW ) ) {
        papi_return( PAPI_ECNFLCT );
     }
      }
 
      for( i = 0; i < ESI->profile.event_counter; i++ ) {
     if ( ESI->profile.EventCode[i] == EventCode ) {
        break;
     }
      }
 
      if ( i == ESI->profile.event_counter ) {
     i = ESI->profile.event_counter;
     ESI->profile.event_counter++;
     ESI->profile.EventCode[i] = EventCode;
      }
      ESI->profile.prof[i] = prof;
      ESI->profile.count[i] = profcnt;
      ESI->profile.threshold[i] = threshold;
      ESI->profile.EventIndex[i] = index;
   }
 
   APIDBG( "Profile event counter is %d\n", ESI->profile.event_counter );
 
   /* Clear out old flags */
   if ( threshold == 0 ) {
      flags |= ESI->profile.flags;
   }
 
   /* make sure no invalid flags are set */
   if ( flags &
    ~( PAPI_PROFIL_POSIX | PAPI_PROFIL_RANDOM | PAPI_PROFIL_WEIGHTED |
       PAPI_PROFIL_COMPRESS | PAPI_PROFIL_BUCKETS | PAPI_PROFIL_FORCE_SW |
       PAPI_PROFIL_INST_EAR | PAPI_PROFIL_DATA_EAR ) ) {
      papi_return( PAPI_EINVAL );
   }
 
   /* if we have kernel-based profiling, then we're just asking for 
      signals on interrupt. */
   /* if we don't have kernel-based profiling, then we're asking for 
      emulated PMU interrupt */
   if ( ( flags & PAPI_PROFIL_FORCE_SW ) &&
    ( _papi_hwd[cidx]->cmp_info.kernel_profile == 0 ) ) {
      forceSW = PAPI_OVERFLOW_FORCE_SW;
   }
 
   /* make sure one and only one bucket size is set */
   buckets = flags & PAPI_PROFIL_BUCKETS;
   if ( !buckets ) {
      flags |= PAPI_PROFIL_BUCKET_16;   /* default to 16 bit if nothing set */
   }
   else {
      /* return error if more than one set */
      if ( !( ( buckets == PAPI_PROFIL_BUCKET_16 ) ||
          ( buckets == PAPI_PROFIL_BUCKET_32 ) ||
          ( buckets == PAPI_PROFIL_BUCKET_64 ) ) ) {
     papi_return( PAPI_EINVAL );
      }
   }
 
   /* Set up the option structure for the low level */
   ESI->profile.flags = flags;
 
   if ( _papi_hwd[cidx]->cmp_info.kernel_profile &&
    !( ESI->profile.flags & PAPI_PROFIL_FORCE_SW ) ) {
      retval = _papi_hwd[cidx]->set_profile( ESI, index, threshold );
      if ( ( retval == PAPI_OK ) && ( threshold > 0 ) ) {
     /* We need overflowing because we use the overflow dispatch handler */
     ESI->state |= PAPI_OVERFLOWING;
     ESI->overflow.flags |= PAPI_OVERFLOW_HARDWARE;
      }
   } else {
      retval = PAPI_overflow( EventSet, EventCode, threshold, forceSW,
                  _papi_hwi_dummy_handler );
   }
    
   if ( retval < PAPI_OK ) {
      papi_return( retval );    /* We should undo stuff here */
   }
 
   /* Toggle the profiling flags and ESI state */
 
   if ( ESI->profile.event_counter >= 1 ) {
      ESI->state |= PAPI_PROFILING;
   }
   else {
      ESI->state ^= PAPI_PROFILING;
      ESI->profile.flags = 0;
   }
 
   return PAPI_OK;
}
 
int
PAPI_profil( void *buf, unsigned bufsiz, vptr_t offset,
             unsigned scale, int EventSet, int EventCode, int threshold,
             int flags )
{
    APIDBG( "Entry: buf: %p, bufsiz: %d, offset: %p, scale: %u, EventSet: %d, EventCode: %#x, threshold: %d, flags: %#x\n", buf, bufsiz, offset, scale, EventSet, EventCode, threshold, flags);
    EventSetInfo_t *ESI;
    int i;
    int retval;
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
    /* scale factors are checked for validity in PAPI_sprofil */
 
    if ( threshold > 0 ) {
        PAPI_sprofil_t *prof;
 
        for ( i = 0; i < ESI->profile.event_counter; i++ ) {
            if ( ESI->profile.EventCode[i] == EventCode )
                break;
        }
 
        if ( i == ESI->profile.event_counter ) {
            prof =
                ( PAPI_sprofil_t * ) papi_malloc( sizeof ( PAPI_sprofil_t ) );
            memset( prof, 0x0, sizeof ( PAPI_sprofil_t ) );
            prof->pr_base = buf;
            prof->pr_size = bufsiz;
            prof->pr_off = offset;
            prof->pr_scale = scale;
 
            retval =
                PAPI_sprofil( prof, 1, EventSet, EventCode, threshold, flags );
 
            if ( retval != PAPI_OK )
                papi_free( prof );
        } else {
            prof = ESI->profile.prof[i];
            prof->pr_base = buf;
            prof->pr_size = bufsiz;
            prof->pr_off = offset;
            prof->pr_scale = scale;
            retval =
                PAPI_sprofil( prof, 1, EventSet, EventCode, threshold, flags );
        }
        papi_return( retval );
    }
 
    for ( i = 0; i < ESI->profile.event_counter; i++ ) {
        if ( ESI->profile.EventCode[i] == EventCode )
            break;
    }
    /* EventCode not found */
    if ( i == ESI->profile.event_counter )
        papi_return( PAPI_EINVAL );
 
    papi_free( ESI->profile.prof[i] );
    ESI->profile.prof[i] = NULL;
 
    papi_return( PAPI_sprofil( NULL, 0, EventSet, EventCode, 0, flags ) );
}
 
/* This function sets the low level default granularity
   for all newly manufactured eventsets. The first function
   preserves API compatibility and assumes component 0;
   The second function takes a component argument. */
 
int
PAPI_set_granularity( int granularity )
{
    return ( PAPI_set_cmp_granularity( granularity, 0 ) );
}
 
int
PAPI_set_cmp_granularity( int granularity, int cidx )
{
    PAPI_option_t ptr;
 
    memset( &ptr, 0, sizeof ( ptr ) );
    ptr.defgranularity.def_cidx = cidx;
    ptr.defgranularity.granularity = granularity;
    papi_return( PAPI_set_opt( PAPI_DEFGRN, &ptr ) );
}
 
/* This function sets the low level default counting domain
   for all newly manufactured eventsets. The first function
   preserves API compatibility and assumes component 0;
   The second function takes a component argument. */
 
int
PAPI_set_domain( int domain )
{
    return ( PAPI_set_cmp_domain( domain, 0 ) );
}
 
int
PAPI_set_cmp_domain( int domain, int cidx )
{
    PAPI_option_t ptr;
 
    memset( &ptr, 0, sizeof ( ptr ) );
    ptr.defdomain.def_cidx = cidx;
    ptr.defdomain.domain = domain;
    papi_return( PAPI_set_opt( PAPI_DEFDOM, &ptr ) );
}
 
int
PAPI_add_events( int EventSet, int *Events, int number )
{
    APIDBG( "Entry: EventSet: %d, Events: %p, number: %d\n", EventSet, Events, number);
    int i, retval;
 
    if ( ( Events == NULL ) || ( number <= 0 ) )
        papi_return( PAPI_EINVAL );
 
    for ( i = 0; i < number; i++ ) {
        retval = PAPI_add_event( EventSet, Events[i] );
        if ( retval != PAPI_OK ) {
            if ( i == 0 )
                papi_return( retval );
            else
                return ( i );
        }
    }
    return ( PAPI_OK );
}
 
int
PAPI_remove_events( int EventSet, int *Events, int number )
{
    APIDBG( "Entry: EventSet: %d, Events: %p, number: %d\n", EventSet, Events, number);
    int i, retval;
 
    if ( ( Events == NULL ) || ( number <= 0 ) )
        papi_return( PAPI_EINVAL );
 
    for ( i = 0; i < number; i++ ) {
        retval = PAPI_remove_event( EventSet, Events[i] );
        if ( retval != PAPI_OK ) {
            if ( i == 0 )
                papi_return( retval );
            else
                return ( i );
        }
    }
    return ( PAPI_OK );
}
 
int
PAPI_list_events( int EventSet, int *Events, int *number )
{
    APIDBG( "Entry: EventSet: %d, Events: %p, number: %p\n", EventSet, Events, number);
    EventSetInfo_t *ESI;
    int i, j;
 
    if ( *number < 0 )
        papi_return( PAPI_EINVAL );
 
    if ( ( Events == NULL ) && ( *number > 0 ) )
        papi_return( PAPI_EINVAL );
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( !ESI )
        papi_return( PAPI_ENOEVST );
 
    if ( ( Events == NULL ) || ( *number == 0 ) ) {
        *number = ESI->NumberOfEvents;
        papi_return( PAPI_OK );
    }
 
    for ( i = 0, j = 0; j < ESI->NumberOfEvents; i++ ) {
        if ( ( int ) ESI->EventInfoArray[i].event_code != PAPI_NULL ) {
            Events[j] = ( int ) ESI->EventInfoArray[i].event_code;
            j++;
            if ( j == *number )
                break;
        }
    }
 
    *number = j;
 
    return ( PAPI_OK );
}
 
/* xxx This is OS dependent, not component dependent, right? */
int
PAPI_get_dmem_info( PAPI_dmem_info_t * dest )
{
    if ( dest == NULL )
        return PAPI_EINVAL;
 
    memset( ( void * ) dest, 0x0, sizeof ( PAPI_dmem_info_t ) );
    return ( _papi_os_vector.get_dmem_info( dest ) );
}
 
 
const PAPI_exe_info_t *
PAPI_get_executable_info( void )
{
    PAPI_option_t ptr;
    int retval;
 
    memset( &ptr, 0, sizeof ( ptr ) );
    retval = PAPI_get_opt( PAPI_EXEINFO, &ptr );
    if ( retval == PAPI_OK )
        return ( ptr.exe_info );
    else
        return ( NULL );
}
 
const PAPI_shlib_info_t *
PAPI_get_shared_lib_info( void )
{
    PAPI_option_t ptr;
    int retval;
 
    memset( &ptr, 0, sizeof ( ptr ) );
    retval = PAPI_get_opt( PAPI_SHLIBINFO, &ptr );
    if ( retval == PAPI_OK )
        return ( ptr.shlib_info );
    else
        return ( NULL );
}
const PAPI_hw_info_t *
PAPI_get_hardware_info( void )
{
    PAPI_option_t ptr;
    int retval;
 
    memset( &ptr, 0, sizeof ( ptr ) );
    retval = PAPI_get_opt( PAPI_HWINFO, &ptr );
    if ( retval == PAPI_OK )
        return ( ptr.hw_info );
    else
        return ( NULL );
}
 
 
/* The next 4 timing functions always use component 0 */
 
long long
PAPI_get_real_cyc( void )
{
    return ( _papi_os_vector.get_real_cycles(  ) );
}
 
/* FIXME */
long long
PAPI_get_real_nsec( void )
{
  return ( ( _papi_os_vector.get_real_nsec(  )));
 
}
 
long long
PAPI_get_real_usec( void )
{
    return ( _papi_os_vector.get_real_usec(  ) );
}
 
long long
PAPI_get_virt_cyc( void )
{
 
    return ( ( long long ) _papi_os_vector.get_virt_cycles( ) );
}
 
long long
PAPI_get_virt_nsec( void )
{
 
  return ( ( _papi_os_vector.get_virt_nsec()));
 
}
 
long long
PAPI_get_virt_usec( void )
{
 
    return ( ( long long ) _papi_os_vector.get_virt_usec() );
}
 
int
PAPI_lock( int lck )
{
    if ( ( lck < 0 ) || ( lck >= PAPI_MAX_LOCK ) )
        papi_return( PAPI_EINVAL );
 
    papi_return( _papi_hwi_lock( lck ) );
}
 
int
PAPI_unlock( int lck )
{
    if ( ( lck < 0 ) || ( lck >= PAPI_MAX_LOCK ) )
        papi_return( PAPI_EINVAL );
 
    papi_return( _papi_hwi_unlock( lck ) );
}
 
int
PAPI_is_initialized( void )
{
    return ( init_level );
}
 
/* This function maps the overflow_vector to event indexes in the event
   set, so that user can know which PAPI event overflowed.
   int *array---- an array of event indexes in eventset; the first index
                  maps to the highest set bit in overflow_vector
   int *number--- this is an input/output parameter, user should put the
                  size of the array into this parameter, after the function
                  is executed, the number of indexes in *array is written
                  to this parameter
*/
 
int
PAPI_get_overflow_event_index( int EventSet, long long overflow_vector,
                               int *array, int *number )
{
    APIDBG( "Entry: EventSet: %d, overflow_vector: %lld, array: %p, number: %p\n", EventSet, overflow_vector, array, number);
    EventSetInfo_t *ESI;
    int set_bit, j, pos;
    int count = 0, k;
 
    if ( overflow_vector == ( long long ) 0 )
        papi_return( PAPI_EINVAL );
 
    if ( ( array == NULL ) || ( number == NULL ) )
        papi_return( PAPI_EINVAL );
 
    if ( *number < 1 )
        papi_return( PAPI_EINVAL );
 
    ESI = _papi_hwi_lookup_EventSet( EventSet );
    if ( ESI == NULL )
        papi_return( PAPI_ENOEVST );
 
    /* in case the eventset is empty */
    if ( ESI->NumberOfEvents == 0 )
        papi_return( PAPI_EINVAL );
 
    while ( ( set_bit = ffsll( overflow_vector ) ) ) {
        set_bit -= 1;
        overflow_vector ^= ( long long ) 1 << set_bit;
        for ( j = 0; j < ESI->NumberOfEvents; j++ ) {
            for ( k = 0, pos = 0; k < PAPI_EVENTS_IN_DERIVED_EVENT && pos >= 0; k++ ) {
                pos = ESI->EventInfoArray[j].pos[k];
                if ( ( set_bit == pos ) &&
                     ( ( ESI->EventInfoArray[j].derived == NOT_DERIVED ) ||
                       ( ESI->EventInfoArray[j].derived == DERIVED_CMPD ) ) ) {
                    array[count++] = j;
                    if ( count == *number )
                        return PAPI_OK;
 
                    break;
                }
            }
        }
    }
    *number = count;
    return PAPI_OK;
}
 
 
int
PAPI_get_event_component( int EventCode)
{
    APIDBG( "Entry: EventCode: %#x\n", EventCode);
    return _papi_hwi_component_index( EventCode);
}
 
int  PAPI_get_component_index(const char *name)
{
    APIDBG( "Entry: name: %s\n", name);
  int cidx;
 
  const PAPI_component_info_t *cinfo;
 
  for(cidx=0;cidx<papi_num_components;cidx++) {
 
     cinfo=PAPI_get_component_info(cidx); 
     if (cinfo==NULL) return PAPI_ENOCMP;
 
     if (!strcmp(name,cinfo->name)) {
        return cidx;
     }
  }
 
  return PAPI_ENOCMP;
}
 
 
int
PAPI_disable_component( int cidx )
{
    APIDBG( "Entry: cidx: %d\n", cidx);
 
   const PAPI_component_info_t *cinfo;
 
   /* Can only run before PAPI_library_init() is called */
   if (init_level != PAPI_NOT_INITED) {
      return PAPI_ENOINIT;
   }
     
   cinfo=PAPI_get_component_info(cidx); 
   if (cinfo==NULL) return PAPI_ENOCMP;
 
   ((PAPI_component_info_t *)cinfo)->disabled=1;
   strcpy(((PAPI_component_info_t *)cinfo)->disabled_reason,
           "Disabled by PAPI_disable_component()");
 
   return PAPI_OK;
 
}
 
int
PAPI_disable_component_by_name(const char *name )
{
    APIDBG( "Entry: name: %s\n", name);
    int cidx;
 
    /* I can only be called before init time */
    if (init_level!=PAPI_NOT_INITED) {
        return PAPI_ENOINIT;
    }
 
    cidx = PAPI_get_component_index(name);
    if (cidx>=0) {
        return PAPI_disable_component(cidx);
    } 
 
    return PAPI_ENOCMP;
}
 
int
PAPI_enum_dev_type(int enum_modifier, void **handle)
{
    return _papi_hwi_enum_dev_type(enum_modifier, handle);
}
 
int
PAPI_get_dev_type_attr(void *handle, PAPI_dev_type_attr_e attr, void *val)
{
    return _papi_hwi_get_dev_type_attr(handle, attr, val);
}
 
int
PAPI_get_dev_attr(void *handle, int id, PAPI_dev_attr_e attr, void *val)
{
    return _papi_hwi_get_dev_attr(handle, id, attr, val);
}