papi_internal.h

Go to the documentation of this file.

/****************************/
/* THIS IS OPEN SOURCE CODE */
/****************************/
#ifndef _PAPI_INTERNAL_H
#define _PAPI_INTERNAL_H
 
/* AIX's C compiler does not recognize the inline keyword */
#ifdef _AIX
#define inline
#endif
 
#include "papi_debug.h"
 
#define DEADBEEF 0xdedbeef
extern int papi_num_components;
extern int _papi_num_compiled_components;
extern int init_level;
extern int _papi_hwi_errno;
extern int _papi_hwi_num_errors;
extern char **_papi_errlist;
 
/********************************************************/
/* This block provides general strings used in PAPI     */
/* If a new string is needed for PAPI prompts           */
/* it should be placed in this file and referenced by   */
/* label.                                               */
/********************************************************/
#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"
 
 
/* some members of structs and/or function parameters may or may not be
   necessary, but at this point, we have included anything that might
   possibly be useful later, and will remove them as we progress */
 
/* Signal used for overflow delivery */
 
#define PAPI_INT_MPX_SIGNAL SIGPROF
#define PAPI_INT_SIGNAL SIGPROF
#define PAPI_INT_ITIMER ITIMER_PROF
 
#define PAPI_INT_ITIMER_MS 1
#if defined(linux)
#define PAPI_NSIG _NSIG
#else
#define PAPI_NSIG 128
#endif
 
/* Multiplex definitions */
 
#define PAPI_INT_MPX_DEF_US 10000   /*Default resolution in us. of mpx handler */
 
/* Commands used to compute derived events */
 
#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   
/* Thread related: thread local storage */
 
#define LOWLEVEL_TLS        PAPI_NUM_TLS+0
#define NUM_INNER_TLS       1
#define PAPI_MAX_TLS        (NUM_INNER_TLS+PAPI_NUM_TLS)
 
/* Thread related: locks */
 
#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 */
 
/* extras related */
 
#define NEED_CONTEXT        1
#define DONT_NEED_CONTEXT   0
 
#define PAPI_EVENTS_IN_DERIVED_EVENT    8
 
 
/* these vestigial pointers are to structures defined in the components
    they are opaque to the framework and defined as void at this level
    they are remapped to real data in the component routines that use them */
#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
 
/* DEFINES END HERE */
 
#ifndef NO_CONFI
#include "config.h"
#endif
 
#include OSCONTEXT
#include "papi_preset.h"
 
#ifndef inline_static
#define inline_static inline static
#endif
 
typedef struct _EventSetDomainInfo {
   int domain;
} EventSetDomainInfo_t;
 
typedef struct _EventSetGranularityInfo {
   int granularity;
} EventSetGranularityInfo_t;
 
typedef struct _EventSetOverflowInfo {
   int flags;
   int event_counter;
   PAPI_overflow_handler_t handler;
   long long *deadline;
   int *threshold;
   int *EventIndex;
   int *EventCode;
} EventSetOverflowInfo_t;
 
typedef struct _EventSetAttachInfo {
  unsigned long tid;
} EventSetAttachInfo_t;
 
typedef struct _EventSetCpuInfo {
  unsigned int cpu_num;
} EventSetCpuInfo_t;
 
typedef struct _EventSetInheritInfo
{
    int inherit;
} EventSetInheritInfo_t;
 
typedef struct _EventSetProfileInfo {
   PAPI_sprofil_t **prof;
   int *count;     
   int *threshold;
   int *EventIndex;
   int *EventCode;
   int flags;
   int event_counter;
} EventSetProfileInfo_t;
 
typedef struct _EventInfo {
   unsigned int event_code;     
   int pos[PAPI_EVENTS_IN_DERIVED_EVENT];   
   char *ops;                   
   int derived;                 
} EventInfo_t;
 
typedef struct _NativeInfo {
   int ni_event;                
   int ni_papi_code;            
   int ni_position;             
   int ni_owners;               
   hwd_register_t *ni_bits;     
} NativeInfo_t;
 
 
/* Multiplex definitions */
 
typedef struct _papi_info {
   long long event_type;
   int domain;
   int granularity;
} PapiInfo;
 
typedef struct _masterevent {
   int uses;
   int active;
   int is_a_rate;
   int papi_event;
   PapiInfo pi;
   long long count;
   long long cycles;
   long long handler_count;
   long long prev_total_c;
   long long count_estimate;
   double rate_estimate;
   struct _threadlist *mythr;
   struct _masterevent *next;
} MasterEvent;
 
typedef struct _threadlist {
#ifdef PTHREADS
    pthread_t thr;
#else
    unsigned long int tid;
#endif
   long long total_c;
   MasterEvent *cur_event;
   MasterEvent *head;
   struct _threadlist *next;
} Threadlist;
 
/* Ugh, should move this out and into all callers of papi_internal.h */
#include "sw_multiplex.h"
 
struct _ThreadInfo;
struct _CpuInfo;
 
typedef struct _EventSetInfo {
  struct _ThreadInfo *master;  
  struct _CpuInfo    *CpuInfo; 
  int state;                   
  EventInfo_t *EventInfoArray; 
  hwd_control_state_t *ctl_state; 
  unsigned long int tid;       
  int EventSetIndex;           
  int CmpIdx;              
  int NumberOfEvents;          
  long long *hw_start;         
  long long *sw_stop;          
  int NativeCount;             
  NativeInfo_t *NativeInfoArray;  
  hwd_register_t *NativeBits;     
  EventSetDomainInfo_t domain;
  EventSetGranularityInfo_t granularity;
  EventSetOverflowInfo_t overflow;
  EventSetMultiplexInfo_t multiplex;
  EventSetAttachInfo_t attach;
  EventSetCpuInfo_t cpu;
  EventSetProfileInfo_t profile;
  EventSetInheritInfo_t inherit;
} EventSetInfo_t;
 
typedef struct _dynamic_array {
   EventSetInfo_t **dataSlotArray;      
   int totalSlots;              
   int availSlots;              
   int fullSlots;               
   int lowestEmptySlot;         
} DynamicArray_t;
 
/* Component option types for _papi_hwd_ctl. */
 
typedef struct _papi_int_attach {
   unsigned long tid;
   EventSetInfo_t *ESI;
} _papi_int_attach_t;
 
typedef struct _papi_int_cpu {
   unsigned int cpu_num;
   EventSetInfo_t *ESI;
} _papi_int_cpu_t;
 
typedef struct _papi_int_multiplex {
   int flags;
   unsigned long ns;
   EventSetInfo_t *ESI;
} _papi_int_multiplex_t;
 
typedef struct _papi_int_defdomain {
   int defdomain;
} _papi_int_defdomain_t;
 
typedef struct _papi_int_domain {
   int domain;
   int eventset;
   EventSetInfo_t *ESI;
} _papi_int_domain_t;
 
typedef struct _papi_int_granularity {
   int granularity;
   int eventset;
   EventSetInfo_t *ESI;
} _papi_int_granularity_t;
 
typedef struct _papi_int_overflow {
   EventSetInfo_t *ESI;
   EventSetOverflowInfo_t overflow;
} _papi_int_overflow_t;
 
typedef struct _papi_int_profile {
   EventSetInfo_t *ESI;
   EventSetProfileInfo_t profile;
} _papi_int_profile_t;
 
typedef PAPI_itimer_option_t _papi_int_itimer_t;
/* These shortcuts are only for use code */
#undef multiplex_itimer_sig
#undef multiplex_itimer_num
#undef multiplex_itimer_us
 
typedef struct _papi_int_inherit
{
    EventSetInfo_t *ESI;
    int inherit;
} _papi_int_inherit_t;
 
typedef struct _papi_int_addr_range { /* if both are zero, range is disabled */
   EventSetInfo_t *ESI;
   int domain;
   vptr_t start;                
   vptr_t end;                  
   int start_off;                
   int end_off;                  
} _papi_int_addr_range_t;
 
typedef union _papi_int_option_t {
   _papi_int_overflow_t overflow;
   _papi_int_profile_t profile;
   _papi_int_domain_t domain;
   _papi_int_attach_t attach;
   _papi_int_cpu_t cpu;
   _papi_int_multiplex_t multiplex;
   _papi_int_itimer_t itimer;
    _papi_int_inherit_t inherit;
    _papi_int_granularity_t granularity;
    _papi_int_addr_range_t address_range;
} _papi_int_option_t;
 
typedef struct {
   hwd_siginfo_t *si;
   hwd_ucontext_t *ucontext;
} _papi_hwi_context_t;
 
typedef struct _papi_mdi {
   DynamicArray_t global_eventset_map;  
   pid_t pid;                   
   PAPI_hw_info_t hw_info;      
   PAPI_exe_info_t exe_info;    
   PAPI_shlib_info_t shlib_info;    
   PAPI_preload_info_t preload_info; 
} papi_mdi_t;
 
extern papi_mdi_t _papi_hwi_system_info;
extern int _papi_hwi_error_level;
/* extern const hwi_describe_t _papi_hwi_err[PAPI_NUM_ERRORS]; */
/*extern volatile int _papi_hwi_using_signal;*/
extern int _papi_hwi_using_signal[PAPI_NSIG];
 
typedef struct _papi_os_option {
   char name[PAPI_MAX_STR_LEN];     
   char version[PAPI_MAX_STR_LEN];  
   int os_version;                  
   int itimer_sig;                  
   int itimer_num;                  
   int itimer_ns;                   
   int itimer_res_ns;               
   int clock_ticks;                 
   unsigned long reserved[8];       /* For future expansion */
} PAPI_os_info_t;
 
extern PAPI_os_info_t _papi_os_info; /* For internal PAPI use only */
 
#include "papi_lock.h"
#include "threads.h"
 
extern THREAD_LOCAL_STORAGE_KEYWORD int _papi_rate_events_running;
extern THREAD_LOCAL_STORAGE_KEYWORD int _papi_hl_events_running;
 
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 );
 
extern int _papi_hwi_error_level;
extern PAPI_debug_handler_t _papi_hwi_debug_handler;
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( int PE_OR_PEU );
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);
 
enum {
    PAPI_SYSDETECT_QUERY__DEV_TYPE_ENUM,
    PAPI_SYSDETECT_QUERY__DEV_TYPE_ATTR,
    PAPI_SYSDETECT_QUERY__DEV_ATTR,
};
 
typedef struct {
    int query_type;
    union {
        struct {
            int modifier;
        } enumerate;
 
        struct {
            void *handle;
            PAPI_dev_type_attr_e attr;
        } dev_type;
 
        struct {
            void *handle;
            int id;
            PAPI_dev_attr_e attr;
        } dev;
    } query;
} _papi_hwi_sysdetect_t;
 
int _papi_hwi_enum_dev_type(int enum_modifier, void **handle);
int _papi_hwi_get_dev_type_attr(void *handle, PAPI_dev_type_attr_e attr, void *val);
int _papi_hwi_get_dev_attr(void *handle, int id, PAPI_dev_attr_e attr, void *val);
 
#endif /* PAPI_INTERNAL_H */