papi_internal.h File Reference

Include dependency graph for papi_internal.h:

Go to the source code of this file.

Data Structures
struct	EventSetDomainInfo_t
struct	EventSetGranularityInfo_t
struct	EventSetOverflowInfo_t
struct	EventSetAttachInfo_t
struct	EventSetCpuInfo_t
struct	EventSetInheritInfo_t
struct	EventSetProfileInfo_t
struct	EventInfo_t
struct	NativeInfo_t
struct	PapiInfo
struct	MasterEvent
struct	Threadlist
struct	EventSetInfo_t
struct	DynamicArray_t
struct	_papi_int_attach_t
struct	_papi_int_cpu_t
struct	_papi_int_multiplex_t
struct	_papi_int_defdomain_t
struct	_papi_int_domain_t
struct	_papi_int_granularity_t
struct	_papi_int_overflow_t
struct	_papi_int_profile_t
struct	_papi_int_inherit_t
struct	_papi_int_addr_range_t
union	_papi_int_option_t
struct	_papi_hwi_context_t
struct	papi_mdi_t
struct	PAPI_os_info_t

Macros
#define	DEADBEEF   0xdedbeef
#define	PAPI_ERROR_CODE_str   "Error Code"
#define	PAPI_SHUTDOWN_str   "PAPI_shutdown: PAPI is not initialized"
#define	PAPI_SHUTDOWN_SYNC_str   "PAPI_shutdown: other threads still have running EventSets"
#define	PAPI_INT_MPX_SIGNAL   SIGPROF
#define	PAPI_INT_SIGNAL   SIGPROF
#define	PAPI_INT_ITIMER   ITIMER_PROF
#define	PAPI_INT_ITIMER_MS   1
#define	PAPI_NSIG   128
#define	PAPI_INT_MPX_DEF_US   10000 /*Default resolution in us. of mpx handler */
#define	NOT_DERIVED   0x0
#define	DERIVED_ADD   0x1
#define	DERIVED_PS   0x2
#define	DERIVED_ADD_PS   0x4
#define	DERIVED_CMPD   0x8
#define	DERIVED_SUB   0x10
#define	DERIVED_POSTFIX   0x20
#define	DERIVED_INFIX   0x40
#define	LOWLEVEL_TLS   PAPI_NUM_TLS+0
#define	NUM_INNER_TLS   1
#define	PAPI_MAX_TLS   (NUM_INNER_TLS+PAPI_NUM_TLS)
#define	INTERNAL_LOCK   PAPI_NUM_LOCK+0 /* papi_internal.c */
#define	MULTIPLEX_LOCK   PAPI_NUM_LOCK+1 /* multiplex.c */
#define	THREADS_LOCK   PAPI_NUM_LOCK+2 /* threads.c */
#define	HIGHLEVEL_LOCK   PAPI_NUM_LOCK+3 /* papi_hl.c */
#define	MEMORY_LOCK   PAPI_NUM_LOCK+4 /* papi_memory.c */
#define	COMPONENT_LOCK   PAPI_NUM_LOCK+5 /* per-component */
#define	GLOBAL_LOCK   PAPI_NUM_LOCK+6 /* papi.c for global variable (static and non) initialization/shutdown */
#define	CPUS_LOCK   PAPI_NUM_LOCK+7 /* cpus.c */
#define	NAMELIB_LOCK   PAPI_NUM_LOCK+8 /* papi_pfm4_events.c */
#define	NEED_CONTEXT   1
#define	DONT_NEED_CONTEXT   0
#define	PAPI_EVENTS_IN_DERIVED_EVENT   8
#define	hwd_context_t   void
#define	hwd_control_state_t   void
#define	hwd_reg_alloc_t   void
#define	hwd_register_t   void
#define	hwd_siginfo_t   void
#define	hwd_ucontext_t   void
#define	inline_static   inline static

Typedefs
typedef PAPI_itimer_option_t	_papi_int_itimer_t

Functions
EventSetInfo_t *	_papi_hwi_lookup_EventSet (int eventset)
void	_papi_hwi_set_papi_event_string (const char *event_string)
char *	_papi_hwi_get_papi_event_string (void)
void	_papi_hwi_free_papi_event_string ()
void	_papi_hwi_set_papi_event_code (unsigned int event_code, int update_flag)
unsigned int	_papi_hwi_get_papi_event_code (void)
int	_papi_hwi_get_ntv_idx (unsigned int papi_evt_code)
int	_papi_hwi_is_sw_multiplex (EventSetInfo_t *ESI)
hwd_context_t *	_papi_hwi_get_context (EventSetInfo_t *ESI, int *is_dirty)
void	PAPIERROR (char *format,...)
void	PAPIWARN (char *format,...)
int	_papi_hwi_assign_eventset (EventSetInfo_t *ESI, int cidx)
void	_papi_hwi_free_EventSet (EventSetInfo_t *ESI)
int	_papi_hwi_create_eventset (int *EventSet, ThreadInfo_t *handle)
int	_papi_hwi_lookup_EventCodeIndex (const EventSetInfo_t *ESI, unsigned int EventCode)
int	_papi_hwi_remove_EventSet (EventSetInfo_t *ESI)
void	_papi_hwi_map_events_to_native (EventSetInfo_t *ESI)
int	_papi_hwi_add_event (EventSetInfo_t *ESI, int EventCode)
int	_papi_hwi_remove_event (EventSetInfo_t *ESI, int EventCode)
int	_papi_hwi_read (hwd_context_t *context, EventSetInfo_t *ESI, long long *values)
int	_papi_hwi_cleanup_eventset (EventSetInfo_t *ESI)
int	_papi_hwi_convert_eventset_to_multiplex (_papi_int_multiplex_t *mpx)
int	_papi_hwi_init_global (void)
int	_papi_hwi_init_global_internal (void)
int	_papi_hwi_init_os (void)
void	_papi_hwi_init_errors (void)
PAPI_os_info_t *	_papi_hwi_get_os_info (void)
void	_papi_hwi_shutdown_global_internal (void)
void	_papi_hwi_dummy_handler (int EventSet, void *address, long long overflow_vector, void *context)
int	_papi_hwi_get_preset_event_info (int EventCode, PAPI_event_info_t *info)
int	_papi_hwi_get_user_event_info (int EventCode, PAPI_event_info_t *info)
int	_papi_hwi_derived_type (char *tmp, int *code)
int	_papi_hwi_query_native_event (unsigned int EventCode)
int	_papi_hwi_get_native_event_info (unsigned int EventCode, PAPI_event_info_t *info)
int	_papi_hwi_native_name_to_code (const char *in, int *out)
int	_papi_hwi_native_code_to_name (unsigned int EventCode, char *hwi_name, int len)
int	_papi_hwi_invalid_cmp (int cidx)
int	_papi_hwi_component_index (int event_code)
int	_papi_hwi_native_to_eventcode (int cidx, int event_code, int ntv_idx, const char *event_name)
int	_papi_hwi_eventcode_to_native (int event_code)

Variables
int	papi_num_components
int	_papi_num_compiled_components
int	init_level
int	_papi_hwi_errno
int	_papi_hwi_num_errors
char **	_papi_errlist
papi_mdi_t	_papi_hwi_system_info
int	_papi_hwi_error_level
int	_papi_hwi_using_signal [PAPI_NSIG]
PAPI_os_info_t	_papi_os_info
PAPI_debug_handler_t	_papi_hwi_debug_handler

Detailed Description

Author

Philip Mucci mucci.nosp@m.@cs..nosp@m.utk.e.nosp@m.du

Dan Terpstra terpstra.utk.edu

Kevin London londo.nosp@m.n@cs.nosp@m..utk..nosp@m.edu

Haihang You you@c.nosp@m.s.ut.nosp@m.k.edu

Definition in file papi_internal.h.

Macro Definition Documentation

COMPONENT_LOCK

#define COMPONENT_LOCK   PAPI_NUM_LOCK+5 /* per-component */

Definition at line 91 of file papi_internal.h.

CPUS_LOCK

#define CPUS_LOCK   PAPI_NUM_LOCK+7 /* cpus.c */

Definition at line 93 of file papi_internal.h.

DEADBEEF

#define DEADBEEF   0xdedbeef

Definition at line 26 of file papi_internal.h.

DERIVED_ADD

#define DERIVED_ADD   0x1

Add counters

Definition at line 70 of file papi_internal.h.

DERIVED_ADD_PS

#define DERIVED_ADD_PS   0x4

Add 2 counters then divide by the cycle counter and xl8 to secs.

Definition at line 72 of file papi_internal.h.

DERIVED_CMPD

#define DERIVED_CMPD   0x8

Event lives in operand index but takes 2 or more codes

Definition at line 73 of file papi_internal.h.

DERIVED_INFIX

#define DERIVED_INFIX   0x40

Process counters based on specified infix string

Definition at line 76 of file papi_internal.h.

DERIVED_POSTFIX

#define DERIVED_POSTFIX   0x20

Process counters based on specified postfix string

Definition at line 75 of file papi_internal.h.

DERIVED_PS

#define DERIVED_PS   0x2

Divide by the cycle counter and convert to seconds

Definition at line 71 of file papi_internal.h.

DERIVED_SUB

#define DERIVED_SUB   0x10

Sub all counters from counter with operand_index

Definition at line 74 of file papi_internal.h.

DONT_NEED_CONTEXT

#define DONT_NEED_CONTEXT   0

Definition at line 99 of file papi_internal.h.

GLOBAL_LOCK

#define GLOBAL_LOCK   PAPI_NUM_LOCK+6 /* papi.c for global variable (static and non) initialization/shutdown */

Definition at line 92 of file papi_internal.h.

HIGHLEVEL_LOCK

#define HIGHLEVEL_LOCK   PAPI_NUM_LOCK+3 /* papi_hl.c */

Definition at line 89 of file papi_internal.h.

hwd_context_t

#define hwd_context_t   void

Definition at line 107 of file papi_internal.h.

hwd_control_state_t

#define hwd_control_state_t   void

Definition at line 108 of file papi_internal.h.

hwd_reg_alloc_t

#define hwd_reg_alloc_t   void

Definition at line 109 of file papi_internal.h.

hwd_register_t

#define hwd_register_t   void

Definition at line 110 of file papi_internal.h.

hwd_siginfo_t

#define hwd_siginfo_t   void

Definition at line 111 of file papi_internal.h.

hwd_ucontext_t

typedef struct sigcontext hwd_ucontext_t   void

Definition at line 112 of file papi_internal.h.

inline_static

#define inline_static   inline static

Definition at line 124 of file papi_internal.h.

INTERNAL_LOCK

#define INTERNAL_LOCK   PAPI_NUM_LOCK+0 /* papi_internal.c */

Definition at line 86 of file papi_internal.h.

LOWLEVEL_TLS

#define LOWLEVEL_TLS   PAPI_NUM_TLS+0

Definition at line 80 of file papi_internal.h.

MEMORY_LOCK

#define MEMORY_LOCK   PAPI_NUM_LOCK+4 /* papi_memory.c */

Definition at line 90 of file papi_internal.h.

MULTIPLEX_LOCK

#define MULTIPLEX_LOCK   PAPI_NUM_LOCK+1 /* multiplex.c */

Definition at line 87 of file papi_internal.h.

NAMELIB_LOCK

#define NAMELIB_LOCK   PAPI_NUM_LOCK+8 /* papi_pfm4_events.c */

Definition at line 94 of file papi_internal.h.

NEED_CONTEXT

#define NEED_CONTEXT   1

Definition at line 98 of file papi_internal.h.

NOT_DERIVED

#define NOT_DERIVED   0x0

Do nothing

Definition at line 69 of file papi_internal.h.

NUM_INNER_TLS

#define NUM_INNER_TLS   1

Definition at line 81 of file papi_internal.h.

PAPI_ERROR_CODE_str

#define PAPI_ERROR_CODE_str   "Error Code"

Definition at line 41 of file papi_internal.h.

PAPI_EVENTS_IN_DERIVED_EVENT

#define PAPI_EVENTS_IN_DERIVED_EVENT   8

Definition at line 101 of file papi_internal.h.

PAPI_INT_ITIMER

#define PAPI_INT_ITIMER   ITIMER_PROF

Definition at line 54 of file papi_internal.h.

PAPI_INT_ITIMER_MS

#define PAPI_INT_ITIMER_MS   1

Definition at line 56 of file papi_internal.h.

PAPI_INT_MPX_DEF_US

#define PAPI_INT_MPX_DEF_US   10000 /*Default resolution in us. of mpx handler */

Definition at line 65 of file papi_internal.h.

PAPI_INT_MPX_SIGNAL

#define PAPI_INT_MPX_SIGNAL   SIGPROF

Definition at line 52 of file papi_internal.h.

PAPI_INT_SIGNAL

#define PAPI_INT_SIGNAL   SIGPROF

Definition at line 53 of file papi_internal.h.

PAPI_MAX_TLS

#define PAPI_MAX_TLS   (NUM_INNER_TLS+PAPI_NUM_TLS)

Definition at line 82 of file papi_internal.h.

PAPI_NSIG

#define PAPI_NSIG   128

Definition at line 60 of file papi_internal.h.

PAPI_SHUTDOWN_str

#define PAPI_SHUTDOWN_str   "PAPI_shutdown: PAPI is not initialized"

Definition at line 42 of file papi_internal.h.

PAPI_SHUTDOWN_SYNC_str

#define PAPI_SHUTDOWN_SYNC_str   "PAPI_shutdown: other threads still have running EventSets"

Definition at line 43 of file papi_internal.h.

THREADS_LOCK

#define THREADS_LOCK   PAPI_NUM_LOCK+2 /* threads.c */

Definition at line 88 of file papi_internal.h.

Typedef Documentation

_papi_int_itimer_t

typedef PAPI_itimer_option_t _papi_int_itimer_t

Definition at line 364 of file papi_internal.h.

Function Documentation

_papi_hwi_add_event()

int _papi_hwi_add_event	(	EventSetInfo_t *	ESI,
		int	EventCode
	)

Definition at line 1335 of file papi_internal.c.

{
    INTDBG("ENTER: ESI: %p (%d), EventCode: %#x\n", ESI, ESI->EventSetIndex, EventCode);

    int i, j, thisindex, remap, retval = PAPI_OK;
    int cidx;

    /* Sanity check the component */
    cidx=_papi_hwi_component_index( EventCode );
    if (cidx<0) {
        return PAPI_ENOCMP;
    }
    if (_papi_hwd[cidx]->cmp_info.disabled) {
        return PAPI_ECMP_DISABLED;
    }

    /* Sanity check that the new EventCode is from the same component */
    /* as previous events.                                            */

    if ( ESI->CmpIdx < 0 ) {
       if ( ( retval = _papi_hwi_assign_eventset( ESI, cidx)) != PAPI_OK ) {
          INTDBG("EXIT: Error assigning eventset to component index %d\n", cidx);
          return retval;
       }
    } else {
       if ( ESI->CmpIdx != cidx ) {
            INTDBG("EXIT: Event is not valid for component index %d\n", cidx);
            return PAPI_EINVAL;
       }
    }

    /* Make sure the event is not present and get the next free slot. */
    thisindex = get_free_EventCodeIndex( ESI, ( unsigned int ) EventCode );
    if ( thisindex < PAPI_OK ) {
       return thisindex;
    }

    INTDBG("Adding event to slot %d of EventSet %d\n",thisindex,ESI->EventSetIndex);

    /* If it is a software MPX EventSet, add it to the multiplex data structure */
    /* and this thread's multiplex list                                         */

    if ( !_papi_hwi_is_sw_multiplex( ESI ) ) {

       /* Handle preset case */
       if ( IS_PRESET(EventCode) ) {
      int count;
      int preset_index = EventCode & ( int ) PAPI_PRESET_AND_MASK;

      /* Check if it's within the valid range */
      if ( ( preset_index < 0 ) || ( preset_index >= PAPI_MAX_PRESET_EVENTS ) ) {
         return PAPI_EINVAL;
      }

      /* count the number of native events in this preset */
      count = ( int ) _papi_hwi_presets[preset_index].count;

      /* Check if event exists */
      if ( !count ) {
         return PAPI_ENOEVNT;
      }

      /* check if the native events have been used as overflow events */
      /* this is not allowed                                          */
      if ( ESI->state & PAPI_OVERFLOWING ) {
         for( i = 0; i < count; i++ ) {
        for( j = 0; j < ESI->overflow.event_counter; j++ ) {
          if ( ESI->overflow.EventCode[j] ==(int)
            ( _papi_hwi_presets[preset_index].code[i] ) ) {
              return PAPI_ECNFLCT;
           }
        }
         }
      }

      /* Try to add the preset. */

      remap = add_native_events( ESI,
                     _papi_hwi_presets[preset_index].code,
                     count, &ESI->EventInfoArray[thisindex] );
      if ( remap < 0 ) {
         return remap;
      }
          else {
         /* Fill in the EventCode (machine independent) information */
         ESI->EventInfoArray[thisindex].event_code =
                                  ( unsigned int ) EventCode;
         ESI->EventInfoArray[thisindex].derived =
                  _papi_hwi_presets[preset_index].derived_int;
         ESI->EventInfoArray[thisindex].ops =
                  _papi_hwi_presets[preset_index].postfix;
             ESI->NumberOfEvents++;
         _papi_hwi_map_events_to_native( ESI );

      }
       }
       /* Handle adding Native events */
       else if ( IS_NATIVE(EventCode) ) {

      /* Check if native event exists */
      if ( _papi_hwi_query_native_event( ( unsigned int ) EventCode ) != PAPI_OK ) {
         return PAPI_ENOEVNT;
      }

      /* check if the native events have been used as overflow events */
      /* This is not allowed                                          */
      if ( ESI->state & PAPI_OVERFLOWING ) {
         for( j = 0; j < ESI->overflow.event_counter; j++ ) {
            if ( EventCode == ESI->overflow.EventCode[j] ) {
           return PAPI_ECNFLCT;
        }
         }
      }

      /* Try to add the native event. */

      remap = add_native_events( ESI, (unsigned int *)&EventCode, 1,
                     &ESI->EventInfoArray[thisindex] );

      if ( remap < 0 ) {
         return remap;
      } else {

         /* Fill in the EventCode (machine independent) information */
         ESI->EventInfoArray[thisindex].event_code = 
                                       ( unsigned int ) EventCode;
             ESI->NumberOfEvents++;
         _papi_hwi_map_events_to_native( ESI );

      }
       } else if ( IS_USER_DEFINED( EventCode ) ) {
         int count;
         int index = EventCode & PAPI_UE_AND_MASK;

         if ( index < 0 || index >= user_defined_events_count )
           return ( PAPI_EINVAL );

         count = ( int ) user_defined_events[index].count;

         for ( i = 0; i < count; i++ ) {
           for ( j = 0; j < ESI->overflow.event_counter; j++ ) {
             if ( ESI->overflow.EventCode[j] ==
                 (int)(user_defined_events[index].code[i]) ) {
               return ( PAPI_EBUG );
             }
           }
         }

         remap = add_native_events( ESI,
             user_defined_events[index].code,
             count, &ESI->EventInfoArray[thisindex] );

         if ( remap < 0 ) {
           return remap;
         } else {
           ESI->EventInfoArray[thisindex].event_code = (unsigned int) EventCode;
           ESI->EventInfoArray[thisindex].derived = user_defined_events[index].derived_int;
           ESI->EventInfoArray[thisindex].ops = user_defined_events[index].postfix;
           ESI->NumberOfEvents++;
           _papi_hwi_map_events_to_native( ESI );
         }
       } else {

      /* not Native, Preset, or User events */

      return PAPI_EBUG;
       }
    }
    else {

       /* Multiplexing is special. See multiplex.c */

       retval = mpx_add_event( &ESI->multiplex.mpx_evset, EventCode,
                   ESI->domain.domain,
                   ESI->granularity.granularity );


       if ( retval < PAPI_OK ) {
      return retval;
       }

       /* Relevant (???) */
       ESI->EventInfoArray[thisindex].event_code = ( unsigned int ) EventCode;
       ESI->EventInfoArray[thisindex].derived = NOT_DERIVED;

       ESI->NumberOfEvents++;

       /* event is in the EventInfoArray but not mapped to the NativeEvents */
       /* this causes issues if you try to set overflow on the event.       */
       /* in theory this wouldn't matter anyway.                            */
    }

    /* reinstate the overflows if any */
    retval=update_overflow( ESI );

    return retval;
}

Here is the call graph for this function:

_papi_hwi_assign_eventset()

int _papi_hwi_assign_eventset	(	EventSetInfo_t *	ESI,
		int	cidx
	)

Definition at line 760 of file papi_internal.c.

{
   INTDBG("ENTER: ESI: %p (%d), cidx: %d\n", ESI, ESI->EventSetIndex, cidx);
   int retval;
   size_t max_counters;
   char *ptr;
   unsigned int i, j;

   /* If component doesn't exist... */
   if (_papi_hwi_invalid_cmp(cidx)) return PAPI_ECMP;

   /* Assigned at create time */
   ESI->domain.domain = _papi_hwd[cidx]->cmp_info.default_domain;
   ESI->granularity.granularity =
                             _papi_hwd[cidx]->cmp_info.default_granularity;
   ESI->CmpIdx = cidx;

   /* ??? */
   max_counters = ( size_t ) _papi_hwd[cidx]->cmp_info.num_mpx_cntrs;

   ESI->ctl_state = (hwd_control_state_t *) papi_calloc( 1, (size_t)
                   _papi_hwd[cidx]->size.control_state );
   ESI->sw_stop = (long long *) papi_calloc( ( size_t ) max_counters,
                              sizeof ( long long ) );
   ESI->hw_start = ( long long * ) papi_calloc( ( size_t ) max_counters,
                                                      sizeof ( long long ) );
   ESI->EventInfoArray = ( EventInfo_t * ) papi_calloc( (size_t) max_counters,
                                                      sizeof ( EventInfo_t ) );

   /* allocate room for the native events and for the component-private */
   /* register structures */
   /* ugh is there a cleaner way to allocate this?  vmw */
   ESI->NativeInfoArray = ( NativeInfo_t * )
     papi_calloc( ( size_t ) max_counters, sizeof ( NativeInfo_t ));

   ESI->NativeBits = papi_calloc(( size_t ) max_counters,
                                 ( size_t ) _papi_hwd[cidx]->size.reg_value );

   /* NOTE: the next two malloc allocate blocks of memory that are later */
   /* parcelled into overflow and profile arrays                         */
   ESI->overflow.deadline = ( long long * )
        papi_malloc( ( sizeof ( long long ) +
                       sizeof ( int ) * 3 ) * ( size_t ) max_counters );

   ESI->profile.prof = ( PAPI_sprofil_t ** )
        papi_malloc( ( sizeof ( PAPI_sprofil_t * ) * ( size_t ) max_counters +
                       ( size_t ) max_counters * sizeof ( int ) * 4 ) );

   /* If any of these allocations failed, free things up and fail */

   if ( ( ESI->ctl_state == NULL ) ||
    ( ESI->sw_stop == NULL )   ||
        ( ESI->hw_start == NULL )  ||
    ( ESI->NativeInfoArray == NULL ) ||
    ( ESI->NativeBits == NULL ) ||
        ( ESI->EventInfoArray == NULL )  ||
    ( ESI->profile.prof == NULL ) ||
        ( ESI->overflow.deadline == NULL ) ) {

      if ( ESI->sw_stop ) papi_free( ESI->sw_stop );
      if ( ESI->hw_start ) papi_free( ESI->hw_start );
      if ( ESI->EventInfoArray ) papi_free( ESI->EventInfoArray );
      if ( ESI->NativeInfoArray ) papi_free( ESI->NativeInfoArray );
      if ( ESI->NativeBits ) papi_free( ESI->NativeBits );
      if ( ESI->ctl_state ) papi_free( ESI->ctl_state );
      if ( ESI->overflow.deadline ) papi_free( ESI->overflow.deadline );
      if ( ESI->profile.prof ) papi_free( ESI->profile.prof );
      papi_free( ESI );
      return PAPI_ENOMEM;
   }


   /* Carve up the overflow block into separate arrays */
   ptr = ( char * ) ESI->overflow.deadline;
   ptr += sizeof ( long long ) * max_counters;
   ESI->overflow.threshold = ( int * ) ptr;
   ptr += sizeof ( int ) * max_counters;
   ESI->overflow.EventIndex = ( int * ) ptr;
   ptr += sizeof ( int ) * max_counters;
   ESI->overflow.EventCode = ( int * ) ptr;

   /* Carve up the profile block into separate arrays */
   ptr = ( char * ) ESI->profile.prof +
        ( sizeof ( PAPI_sprofil_t * ) * max_counters );
   ESI->profile.count = ( int * ) ptr;
   ptr += sizeof ( int ) * max_counters;
   ESI->profile.threshold = ( int * ) ptr;
   ptr += sizeof ( int ) * max_counters;
   ESI->profile.EventIndex = ( int * ) ptr;
   ptr += sizeof ( int ) * max_counters;
   ESI->profile.EventCode = ( int * ) ptr;

   /* initialize_EventInfoArray */

   for ( i = 0; i < max_counters; i++ ) {
       ESI->EventInfoArray[i].event_code=( unsigned int ) PAPI_NULL;
       ESI->EventInfoArray[i].ops = NULL;
       ESI->EventInfoArray[i].derived=NOT_DERIVED;
       for ( j = 0; j < PAPI_EVENTS_IN_DERIVED_EVENT; j++ ) {
       ESI->EventInfoArray[i].pos[j] = PAPI_NULL;
       }
   }

   /* initialize_NativeInfoArray */
   for( i = 0; i < max_counters; i++ ) {
      ESI->NativeInfoArray[i].ni_event = -1;
      ESI->NativeInfoArray[i].ni_position = -1;
      ESI->NativeInfoArray[i].ni_papi_code = -1;
      ESI->NativeInfoArray[i].ni_owners = 0;
      ESI->NativeInfoArray[i].ni_bits = ((unsigned char*)ESI->NativeBits) +
                                          (i*_papi_hwd[cidx]->size.reg_value);
   }

   ESI->NativeCount = 0;

   ESI->state = PAPI_STOPPED;

   /* these used to be init_config */
   retval = _papi_hwd[cidx]->init_control_state( ESI->ctl_state );
   retval |= _papi_hwd[cidx]->set_domain( ESI->ctl_state, ESI->domain.domain);

   return retval;
}

Here is the call graph for this function:

_papi_hwi_cleanup_eventset()

int _papi_hwi_cleanup_eventset

(

EventSetInfo_t *

ESI

)

Definition at line 1755 of file papi_internal.c.

{
   int i, j, num_cntrs, retval;
   hwd_context_t *context;
   int EventCode;
   NativeInfo_t *native;
   if ( !_papi_hwi_invalid_cmp( ESI->CmpIdx ) ) {
   num_cntrs = _papi_hwd[ESI->CmpIdx]->cmp_info.num_mpx_cntrs;

   for(i=0;i<num_cntrs;i++) {

      EventCode=ESI->EventInfoArray[i].event_code;

      /* skip if event not there */
      if ( EventCode == PAPI_NULL ) continue;

      /* If it is a MPX EventSet, remove it from the multiplex */
      /* data structure and this thread's multiplex list */

      if ( _papi_hwi_is_sw_multiplex( ESI ) ) {
     retval = mpx_remove_event( &ESI->multiplex.mpx_evset, EventCode );
     if ( retval < PAPI_OK )
        return retval;
      } else {

      native = ESI->NativeInfoArray;

      /* clear out ESI->NativeInfoArray */
      /* do we really need to do this, seeing as we free() it later? */

      for( j = 0; j < ESI->NativeCount; j++ ) {
         native[j].ni_event = -1;
         native[j].ni_position = -1;
         native[j].ni_owners = 0;
         /* native[j].ni_bits?? */
      }
      }

      /* do we really need to do this, seeing as we free() it later? */
      ESI->EventInfoArray[i].event_code= ( unsigned int ) PAPI_NULL;
      for( j = 0; j < PAPI_EVENTS_IN_DERIVED_EVENT; j++ ) {
      ESI->EventInfoArray[i].pos[j] = PAPI_NULL;
      }
      ESI->EventInfoArray[i].ops = NULL;
      ESI->EventInfoArray[i].derived = NOT_DERIVED;
   }

   context = _papi_hwi_get_context( ESI, NULL );
   /* calling with count of 0 equals a close? */
   retval = _papi_hwd[ESI->CmpIdx]->update_control_state( ESI->ctl_state,
                   NULL, 0, context);
   if (retval!=PAPI_OK) {
     return retval;
   }
   }

   ESI->CmpIdx = -1;
   ESI->NumberOfEvents = 0;
   ESI->NativeCount = 0;

   if ( ( ESI->state & PAPI_MULTIPLEXING ) && ESI->multiplex.mpx_evset )
           papi_free( ESI->multiplex.mpx_evset );

   if ( ( ESI->state & PAPI_CPU_ATTACH ) && ESI->CpuInfo )
           _papi_hwi_shutdown_cpu( ESI->CpuInfo );

   if ( ESI->ctl_state )
      papi_free( ESI->ctl_state );

   if ( ESI->sw_stop )
      papi_free( ESI->sw_stop );

   if ( ESI->hw_start )
      papi_free( ESI->hw_start );

   if ( ESI->EventInfoArray )
      papi_free( ESI->EventInfoArray );

   if ( ESI->NativeInfoArray )
      papi_free( ESI->NativeInfoArray );

   if ( ESI->NativeBits )
      papi_free( ESI->NativeBits );

   if ( ESI->overflow.deadline )
      papi_free( ESI->overflow.deadline );

   if ( ESI->profile.prof )
      papi_free( ESI->profile.prof );

   ESI->ctl_state = NULL;
   ESI->sw_stop = NULL;
   ESI->hw_start = NULL;
   ESI->EventInfoArray = NULL;
   ESI->NativeInfoArray = NULL;
   ESI->NativeBits = NULL;

   memset( &ESI->domain, 0x0, sizeof(EventSetDomainInfo_t) );
   memset( &ESI->granularity, 0x0, sizeof(EventSetGranularityInfo_t) );
   memset( &ESI->overflow, 0x0, sizeof(EventSetOverflowInfo_t) );
   memset( &ESI->multiplex, 0x0, sizeof(EventSetMultiplexInfo_t) );
   memset( &ESI->attach, 0x0, sizeof(EventSetAttachInfo_t) );
   memset( &ESI->cpu, 0x0, sizeof(EventSetCpuInfo_t) );
   memset( &ESI->profile, 0x0, sizeof(EventSetProfileInfo_t) );
   memset( &ESI->inherit, 0x0, sizeof(EventSetInheritInfo_t) );

   ESI->CpuInfo = NULL;

   return PAPI_OK;
}

Here is the call graph for this function:

_papi_hwi_component_index()

int _papi_hwi_component_index

(

int

event_code

)

Definition at line 520 of file papi_internal.c.

                                            {
    INTDBG("ENTER: event_code: %#x\n", event_code);

  int cidx;
  int event_index;

  /* currently assume presets are for component 0 only */
  if (IS_PRESET(event_code)) {
     INTDBG("EXIT: Event %#x is a PRESET, assigning component %d\n", event_code,0);
     return 0;
  }

  /* user defined events are treated like preset events (component 0 only) */
  if (IS_USER_DEFINED(event_code)) {
     INTDBG("EXIT: Event %#x is USER DEFINED, assigning component %d\n", event_code,0);
     return 0;
  }

  event_index=event_code&PAPI_NATIVE_AND_MASK;

  if ( (event_index < 0) || (event_index>=num_native_events)) {
     INTDBG("EXIT: Event index %#x is out of range, num_native_events: %d\n", event_index, num_native_events);
     return PAPI_ENOEVNT;
  }

  cidx=_papi_native_events[event_index].cidx;

  if ((cidx<0) || (cidx >= papi_num_components)) {
      INTDBG("EXIT: Component index %#x is out of range, papi_num_components: %d\n", cidx, papi_num_components);
      return PAPI_ENOCMP;
  }

  INTDBG("EXIT: Found cidx: %d event_index: %d, event_code: %#x\n", cidx, event_index, event_code);
  return cidx;
}

_papi_hwi_convert_eventset_to_multiplex()

int _papi_hwi_convert_eventset_to_multiplex

(

_papi_int_multiplex_t *

mpx

)

Definition at line 1867 of file papi_internal.c.

{
    int retval, i, j = 0, *mpxlist = NULL;
    EventSetInfo_t *ESI = mpx->ESI;
    int flags = mpx->flags;

    /* If there are any events in the EventSet,
       convert them to multiplex events */

    if ( ESI->NumberOfEvents ) {

        mpxlist =
            ( int * ) papi_malloc( sizeof ( int ) *
                                   ( size_t ) ESI->NumberOfEvents );
        if ( mpxlist == NULL )
            return ( PAPI_ENOMEM );

        /* Build the args to MPX_add_events(). */

        /* Remember the EventInfoArray can be sparse
           and the data can be non-contiguous */

        for ( i = 0; i < EventInfoArrayLength( ESI ); i++ )
            if ( ESI->EventInfoArray[i].event_code !=
                 ( unsigned int ) PAPI_NULL )
                mpxlist[j++] = ( int ) ESI->EventInfoArray[i].event_code;

        /* Resize the EventInfo_t array */

        if ( ( _papi_hwd[ESI->CmpIdx]->cmp_info.kernel_multiplex == 0 ) ||
             ( ( _papi_hwd[ESI->CmpIdx]->cmp_info.kernel_multiplex ) &&
               ( flags & PAPI_MULTIPLEX_FORCE_SW ) ) ) {
            retval =
                MPX_add_events( &ESI->multiplex.mpx_evset, mpxlist, j,
                                ESI->domain.domain,
                                ESI->granularity.granularity );
            if ( retval != PAPI_OK ) {
                papi_free( mpxlist );
                return ( retval );
            }
        }

        papi_free( mpxlist );
    }

    /* Update the state before initialization! */

    ESI->state |= PAPI_MULTIPLEXING;
    if ( _papi_hwd[ESI->CmpIdx]->cmp_info.kernel_multiplex &&
         ( flags & PAPI_MULTIPLEX_FORCE_SW ) )
        ESI->multiplex.flags = PAPI_MULTIPLEX_FORCE_SW;
    ESI->multiplex.ns = ( int ) mpx->ns;

    return ( PAPI_OK );
}

Here is the call graph for this function:

_papi_hwi_create_eventset()

int _papi_hwi_create_eventset	(	int *	EventSet,
		ThreadInfo_t *	handle
	)

Definition at line 937 of file papi_internal.c.

{
    EventSetInfo_t *ESI;
    int retval;

    /* Is the EventSet already in existence? */

    if ( ( EventSet == NULL ) || ( handle == NULL ) )
        return PAPI_EINVAL;

    if ( *EventSet != PAPI_NULL )
        return PAPI_EINVAL;

    /* Well, then allocate a new one. Use n to keep track of a NEW EventSet */

    retval = create_EventSet( &ESI );
    if ( retval != PAPI_OK )
        return retval;

    ESI->CmpIdx = -1;        /* when eventset is created, it is not decided yet which component it belongs to, until first event is added */
    ESI->state = PAPI_STOPPED;

    /* Add it to the global table */

    retval = add_EventSet( ESI, handle );
    if ( retval < PAPI_OK ) {
        _papi_hwi_free_EventSet( ESI );
        return retval ;
    }

    *EventSet = ESI->EventSetIndex;

    INTDBG( "(%p,%p): new EventSet in slot %d\n",
            ( void * ) EventSet, handle, *EventSet );

    return retval;
}

Here is the call graph for this function:

_papi_hwi_derived_type()

int _papi_hwi_derived_type	(	char *	tmp,
		int *	code
	)

Definition at line 2242 of file papi_internal.c.

{
  int i = 0;
  while ( _papi_hwi_derived[i].name != NULL ) {
    if ( strcasecmp( tmp, _papi_hwi_derived[i].name ) == 0 ) {
      *code = _papi_hwi_derived[i].value;
      return PAPI_OK;
    }
    i++;
  }
  INTDBG( "Invalid derived string %s\n", tmp );
  return PAPI_EINVAL;
}

_papi_hwi_dummy_handler()

void _papi_hwi_dummy_handler	(	int	EventSet,
		void *	address,
		long long	overflow_vector,
		void *	context
	)

Definition at line 2036 of file papi_internal.c.

{
    /* This function is not used and shouldn't be called. */
    ( void ) EventSet;       /*unused */
    ( void ) address;        /*unused */
    ( void ) overflow_vector;   /*unused */
    ( void ) context;        /*unused */
    return;
}

_papi_hwi_eventcode_to_native()

int _papi_hwi_eventcode_to_native

(

int

event_code

)

Definition at line 581 of file papi_internal.c.

                                              {
    INTDBG("ENTER: event_code: %#x\n", event_code);

  int result;
  int event_index;

  event_index=event_code&PAPI_NATIVE_AND_MASK;
 if ((event_index < 0)  ||  (event_index>=num_native_events)) {
    INTDBG("EXIT: PAPI_ENOEVNT\n");
    return PAPI_ENOEVNT;
  }

  result=_papi_native_events[event_index].component_event;

  INTDBG("EXIT: result: %#x\n", result);
  return result;

}

_papi_hwi_free_EventSet()

void _papi_hwi_free_EventSet

(

EventSetInfo_t *

ESI

)

Definition at line 892 of file papi_internal.c.

{
    _papi_hwi_cleanup_eventset( ESI );

#ifdef DEBUG
    memset( ESI, 0x00, sizeof ( EventSetInfo_t ) );
#endif
    papi_free( ESI );

}

Here is the call graph for this function:

_papi_hwi_free_papi_event_string()

void _papi_hwi_free_papi_event_string

(

)

Definition at line 107 of file papi_internal.c.

                                   {
    if (papi_event_string != NULL) {
        free(papi_event_string);
        papi_event_string = NULL;
    }
    return;
}

_papi_hwi_get_context()

hwd_context_t* _papi_hwi_get_context	(	EventSetInfo_t *	ESI,
		int *	is_dirty
	)

Definition at line 2693 of file papi_internal.c.

{
    INTDBG("Entry: ESI: %p, is_dirty: %p\n", ESI, is_dirty);
    int dirty_ctx;
    hwd_context_t *ctx=NULL;

    /* assume for now the control state is clean (last updated by this ESI) */
    dirty_ctx = 0;

    /* get a context pointer based on if we are counting for a thread or for a cpu */
    if (ESI->state & PAPI_CPU_ATTACHED) {
        /* use cpu context */
        ctx = ESI->CpuInfo->context[ESI->CmpIdx];

        /* if the user wants to know if the control state was last set by the same event set, tell him */
        if (is_dirty != NULL) {
            if (ESI->CpuInfo->from_esi != ESI) {
                dirty_ctx = 1;
            }
            *is_dirty = dirty_ctx;
        }
        ESI->CpuInfo->from_esi = ESI;

    } else {

        /* use thread context */
        ctx = ESI->master->context[ESI->CmpIdx];

        /* if the user wants to know if the control state was last set by the same event set, tell him */
        if (is_dirty != NULL) {
            if (ESI->master->from_esi != ESI) {
                dirty_ctx = 1;
            }
            *is_dirty = dirty_ctx;
        }
        ESI->master->from_esi = ESI;

    }
    return( ctx );
}

_papi_hwi_get_native_event_info()

int _papi_hwi_get_native_event_info	(	unsigned int	EventCode,
		PAPI_event_info_t *	info
	)

Definition at line 2576 of file papi_internal.c.

{
      INTDBG("ENTER: EventCode: %#x, info: %p\n", EventCode, info);
    int retval;
    int cidx;
    int nevt_code;

    cidx = _papi_hwi_component_index( EventCode );
    if (cidx<0) return PAPI_ENOCMP;

    if (_papi_hwd[cidx]->cmp_info.disabled) return PAPI_ENOCMP;

    if ( EventCode & PAPI_NATIVE_MASK ) {
        // 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);

       /* clear the event info */
       memset( info, 0, sizeof ( PAPI_event_info_t ) );
       info->event_code = ( unsigned int ) EventCode;
       info->component_index = (unsigned int) cidx;
       retval = _papi_hwd[cidx]->ntv_code_to_info(
                  _papi_hwi_eventcode_to_native(EventCode), info);

       /* If component error, it's missing the ntv_code_to_info vector */
       /* so we'll have to fake it.                                    */
       if ( retval == PAPI_ECMP ) {


      INTDBG("missing NTV_CODE_TO_INFO, faking\n");
      /* Fill in the info structure */

        if ((nevt_code = _papi_hwi_eventcode_to_native(EventCode)) < 0) {
            INTDBG("EXIT: nevt_code: %d\n", nevt_code);
            return nevt_code;
        }
      if ( (retval = _papi_hwd[cidx]->ntv_code_to_name(
                    (unsigned int)nevt_code,
                    info->symbol,
                    sizeof(info->symbol)) ) == PAPI_OK ) {

      } else {
         INTDBG("EXIT: retval: %d\n", retval);
         return retval;
      }

        if ((nevt_code = _papi_hwi_eventcode_to_native(EventCode)) <0) {
            INTDBG("EXIT: nevt_code: %d\n", nevt_code);
            return nevt_code;
        }
      retval = _papi_hwd[cidx]->ntv_code_to_descr(
                     (unsigned int)nevt_code,
                     info->long_descr,
                     sizeof ( info->long_descr));
      if (retval!=PAPI_OK) {
         INTDBG("Failed ntv_code_to_descr()\n");
      }

       }
       retval = _papi_hwi_prefix_component_name(
                        _papi_hwd[cidx]->cmp_info.short_name, 
                        info->symbol,
                        info->symbol,
                        sizeof(info->symbol) );

       INTDBG("EXIT: retval: %d\n", retval);
       return retval;
    }

    INTDBG("EXIT: PAPI_ENOEVNT\n");
    return PAPI_ENOEVNT;
}

Here is the call graph for this function:

_papi_hwi_get_ntv_idx()

int _papi_hwi_get_ntv_idx

(

unsigned int

papi_evt_code

)

Definition at line 142 of file papi_internal.c.

                                                   {
    INTDBG("ENTER: papi_evt_code: %#x\n", papi_evt_code);

    int result;
    int event_index;

    if (papi_evt_code == 0) {
        INTDBG("EXIT: PAPI_ENOEVNT, invalid papi event code\n");
        return PAPI_ENOEVNT;
    }

    event_index=papi_evt_code&PAPI_NATIVE_AND_MASK;
    if ((event_index<0) || (event_index>=num_native_events)) {
        INTDBG("EXIT: PAPI_ENOEVNT, invalid index into native event array\n");
        return PAPI_ENOEVNT;
    }

    result=_papi_native_events[event_index].ntv_idx;

    INTDBG("EXIT: result: %d\n", result);
    return result;
}

_papi_hwi_get_os_info()

PAPI_os_info_t* _papi_hwi_get_os_info

(

void

)

_papi_hwi_get_papi_event_code()

unsigned int _papi_hwi_get_papi_event_code

(

void

)

Definition at line 136 of file papi_internal.c.

                                 {
    INTDBG("papi_event_code: %#x\n", papi_event_code);
    return papi_event_code;
}

_papi_hwi_get_papi_event_string()

char* _papi_hwi_get_papi_event_string

(

void

)

Definition at line 102 of file papi_internal.c.

                                   {
    INTDBG("papi_event_string: %s\n", papi_event_string);
    return papi_event_string;
}

_papi_hwi_get_preset_event_info()

int _papi_hwi_get_preset_event_info	(	int	EventCode,
		PAPI_event_info_t *	info
	)

Definition at line 2286 of file papi_internal.c.

{
    INTDBG("ENTER: EventCode: %#x, info: %p\n", EventCode, info);

    int i = EventCode & PAPI_PRESET_AND_MASK;
    unsigned int j;

    if ( _papi_hwi_presets[i].symbol ) {    /* if the event is in the preset table */
      // since we are setting the whole structure to zero the strncpy calls below will 
      // be leaving NULL terminates strings as long as they copy 1 less byte than the 
      // buffer size of the field.
       memset( info, 0, sizeof ( PAPI_event_info_t ) );

       info->event_code = ( unsigned int ) EventCode;
       strncpy( info->symbol, _papi_hwi_presets[i].symbol,
        sizeof(info->symbol)-1);

       if ( _papi_hwi_presets[i].short_descr != NULL )
          strncpy( info->short_descr, _papi_hwi_presets[i].short_descr,
                  sizeof ( info->short_descr )-1 );

       if ( _papi_hwi_presets[i].long_descr != NULL )
          strncpy( info->long_descr,  _papi_hwi_presets[i].long_descr,
                  sizeof ( info->long_descr )-1 );

       info->event_type = _papi_hwi_presets[i].event_type;
       info->count = _papi_hwi_presets[i].count;

       _papi_hwi_derived_string( _papi_hwi_presets[i].derived_int,
                     info->derived,  sizeof ( info->derived ) );

       if ( _papi_hwi_presets[i].postfix != NULL )
          strncpy( info->postfix, _papi_hwi_presets[i].postfix,
                  sizeof ( info->postfix )-1 );

       for(j=0;j < info->count; j++) {
          info->code[j]=_papi_hwi_presets[i].code[j];
          strncpy(info->name[j], _papi_hwi_presets[i].name[j],
          sizeof(info->name[j])-1);
       }

       if ( _papi_hwi_presets[i].note != NULL ) {
          strncpy( info->note, _papi_hwi_presets[i].note,
                  sizeof ( info->note )-1 );
       }

       return PAPI_OK;
    } else {
       return PAPI_ENOEVNT;
    }
}

Here is the call graph for this function:

_papi_hwi_get_user_event_info()

int _papi_hwi_get_user_event_info	(	int	EventCode,
		PAPI_event_info_t *	info
	)

Definition at line 2346 of file papi_internal.c.

{
    INTDBG("ENTER: EventCode: %#x, info: %p\n", EventCode, info);

    unsigned int i = EventCode & PAPI_UE_AND_MASK;
    unsigned int j;

    // if event code not in valid range, return error
    if (i >= PAPI_MAX_USER_EVENTS) {
        INTDBG("EXIT: Invalid event index: %d, max value is: %d\n", i, PAPI_MAX_USER_EVENTS - 1);
        return( PAPI_ENOEVNT );
    }

    if ( user_defined_events[i].symbol == NULL) {   /* if the event is in the preset table */
        INTDBG("EXIT: Event symbol for this event is NULL\n");
        return PAPI_ENOEVNT;
    }

    /* set whole structure to 0 */
    memset( info, 0, sizeof ( PAPI_event_info_t ) );

    info->event_code = ( unsigned int ) EventCode;
    strncpy( info->symbol, user_defined_events[i].symbol,
        sizeof(info->symbol)-1);

    if ( user_defined_events[i].short_descr != NULL )
        strncpy( info->short_descr, user_defined_events[i].short_descr,
            sizeof(info->short_descr)-1);

    if ( user_defined_events[i].long_descr != NULL )
        strncpy( info->long_descr,  user_defined_events[i].long_descr,
            sizeof(info->long_descr)-1);

//  info->event_type = user_defined_events[i].event_type;
    info->count = user_defined_events[i].count;

    _papi_hwi_derived_string( user_defined_events[i].derived_int,
            info->derived,  sizeof(info->derived)-1);

    if ( user_defined_events[i].postfix != NULL )
        strncpy( info->postfix, user_defined_events[i].postfix,
            sizeof(info->postfix)-1);

    for(j=0;j < info->count; j++) {
        info->code[j]=user_defined_events[i].code[j];
        INTDBG("info->code[%d]: %#x\n", j, info->code[j]);
        strncpy(info->name[j], user_defined_events[i].name[j], sizeof(info->name[j])-1);
    }

    if ( user_defined_events[i].note != NULL ) {
        strncpy( info->note, user_defined_events[i].note, sizeof(info->note)-1);
    }

    INTDBG("EXIT: PAPI_OK: event_code: %#x, symbol: %s, short_desc: %s, long_desc: %s\n", info->event_code, info->symbol, info->short_descr, info->long_descr);
    return PAPI_OK;
}

Here is the call graph for this function:

_papi_hwi_init_errors()

void _papi_hwi_init_errors

(

void

)

Definition at line 482 of file papi_internal.c.

                            {
/* we use add error to avoid the cost of lookups, we know the errors are not there yet */
    /*  0 PAPI_OK */    _papi_hwi_add_error("No error");
    /*  1 PAPI_EINVAL */    _papi_hwi_add_error("Invalid argument");
    /*  2 PAPI_ENOMEM */    _papi_hwi_add_error("Insufficient memory");
    /*  3 PAPI_ESYS */  _papi_hwi_add_error("A System/C library call failed");
    /*  4 PAPI_ECMP */  _papi_hwi_add_error("Not supported by component");
    /*  5 PAPI_ECLOST */    _papi_hwi_add_error("Access to the counters was lost or interrupted");
    /*  6 PAPI_EBUG */  _papi_hwi_add_error("Internal error, please send mail to the developers");
    /*  7 PAPI_ENOEVNT */   _papi_hwi_add_error("Event does not exist");
    /*  8 PAPI_ECNFLCT */   _papi_hwi_add_error("Event exists, but cannot be counted due to hardware resource limits");
    /*  9 PAPI_ENOTRUN */   _papi_hwi_add_error("EventSet is currently not running");
    /* 10 PAPI_EISRUN */    _papi_hwi_add_error("EventSet is currently counting");
    /* 11 PAPI_ENOEVST */   _papi_hwi_add_error("No such EventSet available");
    /* 12 PAPI_ENOTPRESET */_papi_hwi_add_error("Event in argument is not a valid preset");
    /* 13 PAPI_ENOCNTR */   _papi_hwi_add_error("Hardware does not support performance counters");
    /* 14 PAPI_EMISC */ _papi_hwi_add_error("Unknown error code");
    /* 15 PAPI_EPERM */ _papi_hwi_add_error("Permission level does not permit operation");
    /* 16 PAPI_ENOINIT */   _papi_hwi_add_error("PAPI hasn't been initialized yet");
    /* 17 PAPI_ENOCMP */    _papi_hwi_add_error("Component Index isn't set");
    /* 18 PAPI_ENOSUPP */   _papi_hwi_add_error("Not supported");
    /* 19 PAPI_ENOIMPL */   _papi_hwi_add_error("Not implemented");
    /* 20 PAPI_EBUF */  _papi_hwi_add_error("Buffer size exceeded");
    /* 21 PAPI_EINVAL_DOM */_papi_hwi_add_error("EventSet domain is not supported for the operation");
    /* 22 PAPI_EATTR */ _papi_hwi_add_error("Invalid or missing event attributes");
    /* 23 PAPI_ECOUNT */    _papi_hwi_add_error("Too many events or attributes");
    /* 24 PAPI_ECOMBO */    _papi_hwi_add_error("Bad combination of features");
    /* 25 PAPI_ECMP_DISABLED */_papi_hwi_add_error("Component containing event is disabled");
}

Here is the call graph for this function:

_papi_hwi_init_global()

int _papi_hwi_init_global

(

void

)

Definition at line 1933 of file papi_internal.c.

{
        int retval, i = 0;

    retval = _papi_hwi_innoculate_os_vector( &_papi_os_vector );
    if ( retval != PAPI_OK ) {
       return retval;
    }

    while ( _papi_hwd[i] ) {

       retval = _papi_hwi_innoculate_vector( _papi_hwd[i] );
       if ( retval != PAPI_OK ) {
          return retval;
       }

       /* We can be disabled by user before init */
       if (!_papi_hwd[i]->cmp_info.disabled) {
          retval = _papi_hwd[i]->init_component( i );
          _papi_hwd[i]->cmp_info.disabled=retval;

          /* Do some sanity checking */
          if (retval==PAPI_OK) {
        if (_papi_hwd[i]->cmp_info.num_cntrs >
            _papi_hwd[i]->cmp_info.num_mpx_cntrs) {
          fprintf(stderr,"Warning!  num_cntrs %d is more than num_mpx_cntrs %d for component %s\n",
                        _papi_hwd[i]->cmp_info.num_cntrs,
                        _papi_hwd[i]->cmp_info.num_mpx_cntrs,
                        _papi_hwd[i]->cmp_info.name);
        }

          }
       }

       i++;
    }
    return PAPI_OK;
}

Here is the call graph for this function:

_papi_hwi_init_global_internal()

int _papi_hwi_init_global_internal

(

void

)

Definition at line 1976 of file papi_internal.c.

{

    int retval;

    memset(&_papi_hwi_system_info,0x0,sizeof( _papi_hwi_system_info ));

    memset( _papi_hwi_using_signal,0x0,sizeof( _papi_hwi_using_signal ));

    /* Global struct to maintain EventSet mapping */
    retval = allocate_eventset_map( &_papi_hwi_system_info.global_eventset_map );
    if ( retval != PAPI_OK ) {
        return retval;
    }

    _papi_hwi_system_info.pid = 0;  /* Process identifier */

    /* PAPI_hw_info_t struct */
    memset(&(_papi_hwi_system_info.hw_info),0x0,sizeof(PAPI_hw_info_t));

    return PAPI_OK;
}

Here is the call graph for this function:

_papi_hwi_init_os()

int _papi_hwi_init_os

(

void

)

Definition at line 1213 of file aix.c.

                        {
  
   struct utsname uname_buffer;

   uname(&uname_buffer);

   strncpy(_papi_os_info.name,uname_buffer.sysname,PAPI_MAX_STR_LEN);

   strncpy(_papi_os_info.version,uname_buffer.release,PAPI_MAX_STR_LEN);
   
   _papi_os_info.itimer_sig = PAPI_INT_MPX_SIGNAL;
   _papi_os_info.itimer_num = PAPI_INT_ITIMER;
   _papi_os_info.itimer_res_ns = 1;
   _papi_os_info.itimer_ns = 1000 * PAPI_INT_MPX_DEF_US;

   return PAPI_OK;

}

Here is the call graph for this function:

_papi_hwi_invalid_cmp()

int _papi_hwi_invalid_cmp

(

int

cidx

)

Definition at line 513 of file papi_internal.c.

{
  return ( cidx < 0 || cidx >= papi_num_components );
}

_papi_hwi_is_sw_multiplex()

int _papi_hwi_is_sw_multiplex

(

EventSetInfo_t *

ESI

)

Definition at line 2669 of file papi_internal.c.

{
   /* Are we multiplexing at all */
   if ( ( ESI->state & PAPI_MULTIPLEXING ) == 0 ) {
      return 0;
   }

   /* Does the component support kernel multiplexing */
   if ( _papi_hwd[ESI->CmpIdx]->cmp_info.kernel_multiplex ) {
      /* Have we forced software multiplexing */
      if ( ESI->multiplex.flags == PAPI_MULTIPLEX_FORCE_SW ) {
     return 1;
      }
      /* Nope, using hardware multiplexing */
      return 0;
   }

   /* We are multiplexing but the component does not support hardware */

   return 1;

}

_papi_hwi_lookup_EventCodeIndex()

int _papi_hwi_lookup_EventCodeIndex	(	const EventSetInfo_t *	ESI,
		unsigned int	EventCode
	)

Definition at line 1005 of file papi_internal.c.

{
    int i;
    int limit = EventInfoArrayLength( ESI );

    for ( i = 0; i < limit; i++ ) {
       if ( ESI->EventInfoArray[i].event_code == EventCode ) {
          return i;
       }
    }

    return PAPI_EINVAL;
}

Here is the call graph for this function:

_papi_hwi_lookup_EventSet()

EventSetInfo_t* _papi_hwi_lookup_EventSet

(

int

eventset

)

Definition at line 2650 of file papi_internal.c.

{
    const DynamicArray_t *map = &_papi_hwi_system_info.global_eventset_map;
    EventSetInfo_t *set;

    if ( ( eventset < 0 ) || ( eventset > map->totalSlots ) )
        return ( NULL );

    set = map->dataSlotArray[eventset];
#ifdef DEBUG
    if ( ( ISLEVEL( DEBUG_THREADS ) ) && ( _papi_hwi_thread_id_fn ) &&
         ( set->master->tid != _papi_hwi_thread_id_fn(  ) ) )
        return ( NULL );
#endif

    return ( set );
}

_papi_hwi_map_events_to_native()

void _papi_hwi_map_events_to_native

(

EventSetInfo_t *

ESI

)

Definition at line 1085 of file papi_internal.c.

{
    INTDBG("ENTER: ESI: %p, ESI->EventInfoArray: %p, ESI->NativeInfoArray: %p, ESI->NumberOfEvents: %d, ESI->NativeCount: %d\n", ESI, ESI->EventInfoArray, ESI->NativeInfoArray, ESI->NumberOfEvents, ESI->NativeCount);

    int i, event, k, n, preset_index = 0, nevt;
    int total_events = ESI->NumberOfEvents;

    event = 0;
    for( i = 0; i < total_events; i++ ) {

        /* find the first event that isn't PAPI_NULL */
        /* Is this really necessary? --vmw           */
        while ( ESI->EventInfoArray[event].event_code == ( unsigned int ) PAPI_NULL ) {
            event++;
        }

        /* If it's a preset */
        if ( IS_PRESET(ESI->EventInfoArray[event].event_code) ) {
            preset_index = ( int ) ESI->EventInfoArray[event].event_code & PAPI_PRESET_AND_MASK;

            /* walk all sub-events in the preset */
            for( k = 0; k < PAPI_EVENTS_IN_DERIVED_EVENT; k++ ) {
                nevt = _papi_hwi_presets[preset_index].code[k];
                if ( nevt == PAPI_NULL ) {
                    break;
                }

                INTDBG("Looking for subevent %#x\n",nevt);

                /* Match each sub-event to something in the Native List */
                for( n = 0; n < ESI->NativeCount; n++ ) {
                    if ( nevt == ESI->NativeInfoArray[n].ni_papi_code ) {
                        INTDBG("Found papi event: %#x, &ESI->NativeInfoArray[%d]: %p, ni_event: %#x, ni_position %d\n",
                                nevt, n, &(ESI->NativeInfoArray[n]), ESI->NativeInfoArray[n].ni_event, ESI->NativeInfoArray[n].ni_position);
                        ESI->EventInfoArray[event].pos[k] = ESI->NativeInfoArray[n].ni_position;
                        break;
                    }
                }
            }
        }
        /* If it's a native event */
        else if( IS_NATIVE(ESI->EventInfoArray[event].event_code) ) {
            nevt = ( int ) ESI->EventInfoArray[event].event_code;

            // get index into native info array for this event
            int nidx = event_already_in_eventset( ESI, nevt );
            // if not found, then we need to return an error
            if (nidx == PAPI_ENOEVNT) {
                INTDBG("EXIT: needed event not found\n");
                return;
            }
            ESI->EventInfoArray[event].pos[0] = ESI->NativeInfoArray[nidx].ni_position;
            INTDBG("nidx: %d, ni_position: %d\n", nidx, ESI->NativeInfoArray[nidx].ni_position);

        }
        /* If it's a user-defined event */
        else if ( IS_USER_DEFINED(ESI->EventInfoArray[event].event_code) ) {
            preset_index = ( int ) ESI->EventInfoArray[event].event_code & PAPI_UE_AND_MASK;
            for ( k = 0; k < PAPI_EVENTS_IN_DERIVED_EVENT; k++ ) {
                nevt = user_defined_events[preset_index].code[k];
                INTDBG("nevt: %#x, user_defined_events[%d].code[%d]: %#x, code[%d]: %#x\n",
                        nevt, preset_index, k, user_defined_events[preset_index].code[k], k+1, user_defined_events[preset_index].code[k+1]);

                if ( nevt == PAPI_NULL ) break;

                /* Match each sub-event to something in the Native List */
                for ( n = 0; n < ESI->NativeCount; n++ ) {
                    // if this is the event we are looking for, set its position and exit inner loop to look for next sub-event
                    if ( _papi_hwi_eventcode_to_native(nevt) == ESI->NativeInfoArray[n].ni_event ) {
                        ESI->EventInfoArray[event].pos[k] = ESI->NativeInfoArray[n].ni_position;
                        break;
                    }
                }
            }
        }
        event++;
    }
    INTDBG("EXIT: \n");
    return;
}

Here is the call graph for this function:

_papi_hwi_native_code_to_name()

int _papi_hwi_native_code_to_name	(	unsigned int	EventCode,
		char *	hwi_name,
		int	len
	)

Definition at line 2538 of file papi_internal.c.

{
    INTDBG("ENTER: EventCode: %#x, hwi_name: %p, len: %d\n", EventCode, hwi_name, len);
  int cidx;
  int retval;
  int nevt_code;

  cidx = _papi_hwi_component_index( EventCode );
  if (cidx<0) return PAPI_ENOEVNT;

  if ( EventCode & PAPI_NATIVE_MASK ) {
      // 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);

    if ((nevt_code = _papi_hwi_eventcode_to_native(EventCode)) < 0) {
        INTDBG("EXIT: nevt_code: %d\n", nevt_code);
        return nevt_code;
    }
    if ( (retval = _papi_hwd[cidx]->ntv_code_to_name(
                        (unsigned int)nevt_code,
                        hwi_name, len) ) == PAPI_OK ) {
            retval = _papi_hwi_prefix_component_name( _papi_hwd[cidx]->cmp_info.short_name, 
                                             hwi_name, hwi_name, len);
            INTDBG("EXIT: retval: %d\n", retval);
            return retval;
    }
    INTDBG("EXIT: retval: %d\n", retval);
    return (retval);
  }
  INTDBG("EXIT: PAPI_ENOEVNT\n");
  return PAPI_ENOEVNT;
}

Here is the call graph for this function:

_papi_hwi_native_name_to_code()

int _papi_hwi_native_name_to_code	(	const char *	in,
		int *	out
	)

Definition at line 2438 of file papi_internal.c.

{
    INTDBG("ENTER: in: %s, out: %p\n", in, out);

    int retval = PAPI_ENOEVNT;
    char name[PAPI_HUGE_STR_LEN];   /* make sure it's big enough */

    unsigned int i;
    int cidx;
    char *full_event_name;

    if (in == NULL) {
        INTDBG("EXIT: PAPI_EINVAL\n");
        return PAPI_EINVAL;
    }

    full_event_name = strdup(in);

    in = _papi_hwi_strip_component_prefix(in);

    // look in each component
    for(cidx=0; cidx < papi_num_components; cidx++) {

        if (_papi_hwd[cidx]->cmp_info.disabled) continue;

        // if this component does not support the pmu
        // which defines this event, no need to call it
        if (is_supported_by_component(cidx, full_event_name) == 0) {
            continue;
        }

        INTDBG("cidx: %d, name: %s, event: %s\n",
            cidx, _papi_hwd[cidx]->cmp_info.name, in);

        // show that we do not have an event code yet
        // (the component may create one and update this info)
        // this also clears any values left over from a previous call
        _papi_hwi_set_papi_event_code(-1, -1);


        // if component has a ntv_name_to_code function, use it to get event code
        if (_papi_hwd[cidx]->ntv_name_to_code != NULL) {
            // try and get this events event code
            retval = _papi_hwd[cidx]->ntv_name_to_code( in, ( unsigned * ) out );
            if (retval==PAPI_OK) {
                *out = _papi_hwi_native_to_eventcode(cidx, *out, -1, in);
                free (full_event_name);
                INTDBG("EXIT: PAPI_OK  event: %s code: %#x\n", in, *out);
                return PAPI_OK;
            }
        } else {
            // force the code through the work around
            retval = PAPI_ECMP;
        }

        /* If not implemented, work around */
        if ( retval==PAPI_ECMP) {
            i = 0;
            retval = _papi_hwd[cidx]->ntv_enum_events( &i, PAPI_ENUM_FIRST );
            if (retval != PAPI_OK) {
                free (full_event_name);
                INTDBG("EXIT: retval: %d\n", retval);
                return retval;
            }

//          _papi_hwi_lock( INTERNAL_LOCK );

            do {
                // save event code so components can get it with call to: _papi_hwi_get_papi_event_code()
                _papi_hwi_set_papi_event_code(i, 0);
                retval = _papi_hwd[cidx]->ntv_code_to_name(i, name, sizeof(name));
                /* printf("%#x\nname =|%s|\ninput=|%s|\n", i, name, in); */
                if ( retval == PAPI_OK && in != NULL) {
                    if ( strcasecmp( name, in ) == 0 ) {
                        *out = _papi_hwi_native_to_eventcode(cidx, i, -1, name);
                        free (full_event_name);
                        INTDBG("EXIT: PAPI_OK, event: %s, code: %#x\n", in, *out);
                        return PAPI_OK;
                    }
                    retval = PAPI_ENOEVNT;
                } else {
                    *out = 0;
                    retval = PAPI_ENOEVNT;
                    break;
                }
            } while ( ( _papi_hwd[cidx]->ntv_enum_events( &i, PAPI_ENUM_EVENTS ) == PAPI_OK ) );

//          _papi_hwi_unlock( INTERNAL_LOCK );
        }
    }

    free (full_event_name);
    INTDBG("EXIT: retval: %d\n", retval);

    return retval;
}

Here is the call graph for this function:

_papi_hwi_native_to_eventcode()

int _papi_hwi_native_to_eventcode	(	int	cidx,
		int	event_code,
		int	ntv_idx,
		const char *	event_name
	)

Definition at line 558 of file papi_internal.c.

                                                                                             {
  INTDBG("Entry: cidx: %d, event: %#x, ntv_idx: %d, event_name: %s\n", cidx, event_code, ntv_idx, event_name);

  int result;

  if (papi_event_code_changed > 0) {
      result = _papi_hwi_get_papi_event_code();
      INTDBG("EXIT: papi_event_code: %#x set by the component\n", result);
      return result;
  }

  result=_papi_hwi_find_native_event(cidx, event_code, event_name);
  if (result==PAPI_ENOEVNT) {
     // Need to create one
     result=_papi_hwi_add_native_event(cidx, event_code, ntv_idx, event_name);
  }

  INTDBG("EXIT: result: %#x\n", result);
  return result;
}

Here is the call graph for this function:

_papi_hwi_query_native_event()

int _papi_hwi_query_native_event

(

unsigned int

EventCode

)

Definition at line 2407 of file papi_internal.c.

{
    INTDBG("ENTER: EventCode: %#x\n", EventCode);
   char name[PAPI_HUGE_STR_LEN];      /* probably overkill, */
                                      /* but should always be big enough */
   int cidx;
   int nevt_code;

   cidx = _papi_hwi_component_index( EventCode );
   if (cidx<0) {
       INTDBG("EXIT: PAPI_ENOCMP\n");
       return PAPI_ENOCMP;
   }

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

    if ((nevt_code = _papi_hwi_eventcode_to_native(EventCode)) < 0) {
        INTDBG("EXIT: nevt_code: %d\n", nevt_code);
        return nevt_code;
    }
   int ret = _papi_hwd[cidx]->ntv_code_to_name( (unsigned int)nevt_code, name, sizeof(name));

   INTDBG("EXIT: ret: %d\n", ret);
   return (ret);
}

Here is the call graph for this function:

_papi_hwi_read()

int _papi_hwi_read	(	hwd_context_t *	context,
		EventSetInfo_t *	ESI,
		long long *	values
	)

Definition at line 1702 of file papi_internal.c.

{
    INTDBG("ENTER: context: %p, ESI: %p, values: %p\n", context, ESI, values);
    int retval;
    long long *dp = NULL;
    int i, index;

    retval = _papi_hwd[ESI->CmpIdx]->read( context, ESI->ctl_state,
                           &dp, ESI->state );
    if ( retval != PAPI_OK ) {
        INTDBG("EXIT: retval: %d\n", retval);
       return retval;
    }

    /* This routine distributes hardware counters to software counters in the
       order that they were added. Note that the higher level
       EventInfoArray[i] entries may not be contiguous because the user
       has the right to remove an event.
       But if we do compaction after remove event, this function can be
       changed.
     */

    for ( i = 0; i != ESI->NumberOfEvents; i++ ) {

        index = ESI->EventInfoArray[i].pos[0];

        if ( index == -1 )
            continue;

        INTDBG( "ESI->EventInfoArray: %p, pos[%d]: %d, dp[%d]: %lld, derived[%d]: %#x\n", ESI->EventInfoArray, i, index, index, dp[index], i, ESI->EventInfoArray[i].derived );

        /* If this is not a derived event */

        if ( ESI->EventInfoArray[i].derived == NOT_DERIVED ) {
            values[i] = dp[index];
            INTDBG( "value: %#llx\n", values[i] );
        } else {             /* If this is a derived event */
            values[i] = handle_derived( &ESI->EventInfoArray[i], dp );
#ifdef DEBUG
            if ( values[i] < ( long long ) 0 ) {
                INTDBG( "Derived Event is negative!!: %lld\n", values[i] );
            }
            INTDBG( "derived value: %#llx \n", values[i] );
#endif
        }
    }

    INTDBG("EXIT: PAPI_OK\n");
    return PAPI_OK;
}

Here is the call graph for this function:

_papi_hwi_remove_event()

int _papi_hwi_remove_event	(	EventSetInfo_t *	ESI,
		int	EventCode
	)

Definition at line 1619 of file papi_internal.c.

{
    int j = 0, retval, thisindex;
    EventInfo_t *array;

    thisindex =
        _papi_hwi_lookup_EventCodeIndex( ESI, ( unsigned int ) EventCode );
    if ( thisindex < PAPI_OK )
        return ( thisindex );

    /* If it is a MPX EventSet, remove it from the multiplex data structure and
       this threads multiplex list */

    if ( _papi_hwi_is_sw_multiplex( ESI ) ) {
        retval = mpx_remove_event( &ESI->multiplex.mpx_evset, EventCode );
        if ( retval < PAPI_OK )
            return ( retval );
    } else
        /* Remove the events hardware dependent stuff from the EventSet */
    {
        if ( IS_PRESET(EventCode) ) {
            int preset_index = EventCode & PAPI_PRESET_AND_MASK;

            /* Check if it's within the valid range */
            if ( ( preset_index < 0 ) ||
                 ( preset_index >= PAPI_MAX_PRESET_EVENTS ) )
                return PAPI_EINVAL;

            /* Check if event exists */
            if ( !_papi_hwi_presets[preset_index].count )
                return PAPI_ENOEVNT;

            /* Remove the preset event. */
            for ( j = 0; _papi_hwi_presets[preset_index].code[j] != (unsigned int)PAPI_NULL;
                  j++ );
            retval = remove_native_events( ESI, ( int * )_papi_hwi_presets[preset_index].code, j );
            if ( retval != PAPI_OK )
                return ( retval );
        } else if ( IS_NATIVE(EventCode) ) {
            /* Check if native event exists */
            if ( _papi_hwi_query_native_event( ( unsigned int ) EventCode ) !=
                 PAPI_OK )
                return PAPI_ENOEVNT;

            /* Remove the native event. */
            retval = remove_native_events( ESI, &EventCode, 1 );
            if ( retval != PAPI_OK )
                return ( retval );
        } else if ( IS_USER_DEFINED( EventCode ) ) {
          int index = EventCode & PAPI_UE_AND_MASK;

          if ( (index < 0) || (index >= user_defined_events_count) )
            return ( PAPI_EINVAL );

          for( j = 0; j < PAPI_EVENTS_IN_DERIVED_EVENT &&
              user_defined_events[index].code[j] != 0; j++ ) {
            retval = remove_native_events( ESI, ( int * )user_defined_events[index].code, j);

            if ( retval != PAPI_OK )
              return ( retval );
          }
        } else
            return ( PAPI_ENOEVNT );
    }
    array = ESI->EventInfoArray;

    /* Compact the Event Info Array list if it's not the last event */
    /* clear the newly empty slot in the array */
    for ( ; thisindex < ESI->NumberOfEvents - 1; thisindex++ )
        array[thisindex] = array[thisindex + 1];


    array[thisindex].event_code = ( unsigned int ) PAPI_NULL;
    for ( j = 0; j < PAPI_EVENTS_IN_DERIVED_EVENT; j++ )
        array[thisindex].pos[j] = PAPI_NULL;
    array[thisindex].ops = NULL;
    array[thisindex].derived = NOT_DERIVED;
    ESI->NumberOfEvents--;

    return ( PAPI_OK );
}

Here is the call graph for this function:

_papi_hwi_remove_EventSet()

int _papi_hwi_remove_EventSet

(

EventSetInfo_t *

ESI

)

Definition at line 1023 of file papi_internal.c.

{
    DynamicArray_t *map = &_papi_hwi_system_info.global_eventset_map;
    int i;

    i = ESI->EventSetIndex;

    _papi_hwi_lock( INTERNAL_LOCK );

    _papi_hwi_free_EventSet( ESI );

    /* do bookkeeping for PAPI_EVENTSET_MAP */

    map->dataSlotArray[i] = NULL;
    map->availSlots++;
    map->fullSlots--;

    _papi_hwi_unlock( INTERNAL_LOCK );

    return PAPI_OK;
}

Here is the call graph for this function:

_papi_hwi_set_papi_event_code()

void _papi_hwi_set_papi_event_code	(	unsigned int	event_code,
		int	update_flag
	)

Definition at line 119 of file papi_internal.c.

                                                                         {
    INTDBG("new event_code: %#x, update_flag: %d, previous event_code: %#x\n", event_code, update_flag, papi_event_code);

    // if call is just to reset and start over, set both flags to show nothing saved yet
    if (update_flag < 0) {
        papi_event_code_changed = -1;
        papi_event_code = -1;
        return;
    }

    // if 0, it is being set prior to calling a component, if >0 it is being changed by the component
    papi_event_code_changed = update_flag;
    // save the event code passed in
    papi_event_code = event_code;
    return;
}

_papi_hwi_set_papi_event_string()

void _papi_hwi_set_papi_event_string

(

const char *

event_string

)

Definition at line 90 of file papi_internal.c.

                                                           {
    INTDBG("event_string: %s\n", event_string);
    if (papi_event_string != NULL) {
        free (papi_event_string);
        papi_event_string = NULL;
    }
    if (event_string != NULL) {
        papi_event_string = strdup(event_string);
    }
    return;
}

_papi_hwi_shutdown_global_internal()

void _papi_hwi_shutdown_global_internal

(

void

)

Definition at line 2000 of file papi_internal.c.

{
    int i = 0;
    _papi_hwi_cleanup_all_presets(  );

    _papi_hwi_cleanup_errors( );

    _papi_hwi_lock( INTERNAL_LOCK );

    for( i = 0; i < num_native_events; i++){
        free(_papi_native_events[i].evt_name);
    }

    free(_papi_native_events);
    _papi_native_events = NULL;        // In case a new library init is done.
    num_native_events=0;               // .. 
    num_native_chunks=0;               // .. 

    _papi_hwi_free_papi_event_string();

    papi_free(  _papi_hwi_system_info.global_eventset_map.dataSlotArray );
    memset(  &_papi_hwi_system_info.global_eventset_map,
         0x00, sizeof ( DynamicArray_t ) );

    _papi_hwi_unlock( INTERNAL_LOCK );

    if ( _papi_hwi_system_info.shlib_info.map ) {
        papi_free( _papi_hwi_system_info.shlib_info.map );
    }
    memset( &_papi_hwi_system_info, 0x0, sizeof ( _papi_hwi_system_info ) );

}

Here is the call graph for this function:

PAPIERROR()

void PAPIERROR	(	char *	format,
			...
	)

Definition at line 606 of file papi_internal.c.

{
    va_list args;
    if ( ( _papi_hwi_error_level != PAPI_QUIET ) ||
         ( getenv( "PAPI_VERBOSE" ) ) ) {
        va_start( args, format );
        fprintf( stderr, "PAPI Error: " );
        vfprintf( stderr, format, args );
        fprintf( stderr, "\n" );
        va_end( args );
    }
}

Here is the call graph for this function:

PAPIWARN()

void PAPIWARN	(	char *	format,
			...
	)

Definition at line 620 of file papi_internal.c.

{
    va_list args;
    if ( ( _papi_hwi_error_level != PAPI_QUIET ) ||
         ( getenv( "PAPI_VERBOSE" ) ) ) {
        va_start( args, format );
        fprintf( stderr, "PAPI Warning: " );
        vfprintf( stderr, format, args );
        fprintf( stderr, "\n" );
        va_end( args );
    }
}

Here is the call graph for this function:

Variable Documentation

_papi_errlist

char** _papi_errlist

Definition at line 81 of file papi_internal.c.

_papi_hwi_debug_handler

PAPI_debug_handler_t _papi_hwi_debug_handler

Definition at line 55 of file papi_internal.c.

_papi_hwi_errno

int _papi_hwi_errno

Definition at line 57 of file papi_internal.c.

_papi_hwi_error_level

int _papi_hwi_error_level

Definition at line 451 of file papi_internal.h.

_papi_hwi_num_errors

int _papi_hwi_num_errors

Definition at line 58 of file papi_internal.c.

_papi_hwi_system_info

papi_mdi_t _papi_hwi_system_info

Definition at line 56 of file papi_internal.c.

_papi_hwi_using_signal

int _papi_hwi_using_signal[PAPI_NSIG]

Definition at line 365 of file extras.c.

_papi_num_compiled_components

int _papi_num_compiled_components

_papi_os_info

PAPI_os_info_t _papi_os_info

Definition at line 1210 of file aix.c.

init_level

int init_level

Definition at line 53 of file papi_internal.c.

papi_num_components

int papi_num_components

Definition at line 1925 of file papi_internal.c.