papi.h

Go to the documentation of this file.

/****************************/
/* THIS IS OPEN SOURCE CODE */
/****************************/
 
#ifndef _PAPI
#define _PAPI
 
#pragma GCC visibility push(default)
 
/* Definition of PAPI_VERSION format.  Note that each of the four 
 * components _must_ be less than 256.  Also, the PAPI_VER_CURRENT
 * masks out the revision and increment.  Any revision change is supposed 
 * to be binary compatible between the user application code and the 
 * run-time library. Any modification that breaks this compatibility 
 * _should_ modify the minor version number as to force user applications 
 * to re-compile.
 */
#define PAPI_VERSION_NUMBER(maj,min,rev,inc) (((maj)<<24) | ((min)<<16) | ((rev)<<8) | (inc))
#define PAPI_VERSION_MAJOR(x)       (((x)>>24)    & 0xff)
#define PAPI_VERSION_MINOR(x)       (((x)>>16)    & 0xff)
#define PAPI_VERSION_REVISION(x)    (((x)>>8)     & 0xff)
#define PAPI_VERSION_INCREMENT(x)((x)          & 0xff)
 
/* This is the official PAPI version */
/* The final digit represents the patch count */
#define PAPI_VERSION            PAPI_VERSION_NUMBER(7,1,0,0)
#define PAPI_VER_CURRENT        (PAPI_VERSION & 0xffff0000)
 
  /* Tests for checking event code type */
#define IS_NATIVE( EventCode ) ( ( EventCode & PAPI_NATIVE_MASK ) && !(EventCode & PAPI_PRESET_MASK) )
#define IS_PRESET( EventCode ) ( ( EventCode & PAPI_PRESET_MASK ) && !(EventCode & PAPI_NATIVE_MASK) )
#define IS_USER_DEFINED( EventCode ) ( ( EventCode & PAPI_PRESET_MASK ) && (EventCode & PAPI_NATIVE_MASK) )
 
#ifdef __cplusplus
extern "C"
{
#endif
 
/* Include files */
 
#include <sys/types.h>
#include <limits.h>
#include "papiStdEventDefs.h"
 
#define PAPI_OK          0     
#define PAPI_EINVAL     -1     
#define PAPI_ENOMEM     -2     
#define PAPI_ESYS       -3     
#define PAPI_ECMP       -4     
#define PAPI_ESBSTR     -4     
#define PAPI_ECLOST     -5     
#define PAPI_EBUG       -6     
#define PAPI_ENOEVNT    -7     
#define PAPI_ECNFLCT    -8     
#define PAPI_ENOTRUN    -9     
#define PAPI_EISRUN     -10    
#define PAPI_ENOEVST    -11    
#define PAPI_ENOTPRESET -12    
#define PAPI_ENOCNTR    -13    
#define PAPI_EMISC      -14    
#define PAPI_EPERM      -15    
#define PAPI_ENOINIT    -16    
#define PAPI_ENOCMP     -17    
#define PAPI_ENOSUPP    -18    
#define PAPI_ENOIMPL    -19    
#define PAPI_EBUF       -20    
#define PAPI_EINVAL_DOM -21    
#define PAPI_EATTR      -22    
#define PAPI_ECOUNT     -23    
#define PAPI_ECOMBO     -24    
#define PAPI_ECMP_DISABLED  -25    
#define PAPI_EDELAY_INIT -26   
#define PAPI_EMULPASS   -27    
#define PAPI_NUM_ERRORS  28    
#define PAPI_NOT_INITED     0
#define PAPI_LOW_LEVEL_INITED   1       /* Low level has called library init */
#define PAPI_HIGH_LEVEL_INITED  2       /* High level has called library init */
#define PAPI_THREAD_LEVEL_INITED 4      /* Threads have been inited */
 
#define PAPI_NULL       -1      
#define PAPI_DOM_USER    0x1    
#define PAPI_DOM_MIN     PAPI_DOM_USER
#define PAPI_DOM_KERNEL  0x2    
#define PAPI_DOM_OTHER   0x4    
#define PAPI_DOM_SUPERVISOR 0x8 
#define PAPI_DOM_ALL     (PAPI_DOM_USER|PAPI_DOM_KERNEL|PAPI_DOM_OTHER|PAPI_DOM_SUPERVISOR) 
/* #define PAPI_DOM_DEFAULT PAPI_DOM_USER NOW DEFINED BY COMPONENT */
#define PAPI_DOM_MAX     PAPI_DOM_ALL
#define PAPI_DOM_HWSPEC  0x80000000     
#define PAPI_USR1_TLS       0x0
#define PAPI_USR2_TLS       0x1
#define PAPI_TLS_HIGH_LEVEL    0x2
#define PAPI_NUM_TLS        0x3
#define PAPI_TLS_USR1       PAPI_USR1_TLS
#define PAPI_TLS_USR2       PAPI_USR2_TLS
#define PAPI_TLS_NUM        PAPI_NUM_TLS
#define PAPI_TLS_ALL_THREADS    0x10
#define PAPI_USR1_LOCK              0x0    
#define PAPI_USR2_LOCK              0x1    
#define PAPI_NUM_LOCK               0x2    
#define PAPI_LOCK_USR1              PAPI_USR1_LOCK
#define PAPI_LOCK_USR2              PAPI_USR2_LOCK
#define PAPI_LOCK_NUM           PAPI_NUM_LOCK
/* Remove this!  If it breaks userspace we might have to add it back :( */
/* #define PAPI_MPX_DEF_DEG 32                                  */
 
#define PAPI_VENDOR_UNKNOWN 0
#define PAPI_VENDOR_INTEL   1
#define PAPI_VENDOR_AMD     2
#define PAPI_VENDOR_IBM     3
#define PAPI_VENDOR_CRAY    4
#define PAPI_VENDOR_SUN     5
#define PAPI_VENDOR_FREESCALE 6
#define PAPI_VENDOR_ARM     7
#define PAPI_VENDOR_MIPS    8
#define PAPI_VENDOR_ARM_ARM       0x41
#define PAPI_VENDOR_ARM_BROADCOM  0x42
#define PAPI_VENDOR_ARM_CAVIUM    0x43
#define PAPI_VENDOR_ARM_FUJITSU   0x46
#define PAPI_VENDOR_ARM_HISILICON 0x48
#define PAPI_VENDOR_ARM_APM       0x50
#define PAPI_VENDOR_ARM_QUALCOMM  0x51
#define PAPI_GRN_THR     0x1    
#define PAPI_GRN_MIN     PAPI_GRN_THR
#define PAPI_GRN_PROC    0x2    
#define PAPI_GRN_PROCG   0x4    
#define PAPI_GRN_SYS     0x8    
#define PAPI_GRN_SYS_CPU 0x10   
#define PAPI_GRN_MAX     PAPI_GRN_SYS_CPU
#define PAPI_STOPPED      0x01  
#define PAPI_RUNNING      0x02  
#define PAPI_PAUSED       0x04  
#define PAPI_NOT_INIT     0x08  
#define PAPI_OVERFLOWING  0x10  
#define PAPI_PROFILING    0x20  
#define PAPI_MULTIPLEXING 0x40  
#define PAPI_ATTACHED     0x80  
#define PAPI_CPU_ATTACHED 0x100 
#define PAPI_QUIET       0      
#define PAPI_VERB_ECONT  1      
#define PAPI_VERB_ESTOP  2      
#define PAPI_PROFIL_POSIX     0x0        
#define PAPI_PROFIL_RANDOM    0x1        
#define PAPI_PROFIL_WEIGHTED  0x2        
#define PAPI_PROFIL_COMPRESS  0x4        
#define PAPI_PROFIL_BUCKET_16 0x8        
#define PAPI_PROFIL_BUCKET_32 0x10       
#define PAPI_PROFIL_BUCKET_64 0x20       
#define PAPI_PROFIL_FORCE_SW  0x40       
#define PAPI_PROFIL_DATA_EAR  0x80       
#define PAPI_PROFIL_INST_EAR  0x100      
#define PAPI_PROFIL_BUCKETS   (PAPI_PROFIL_BUCKET_16 | PAPI_PROFIL_BUCKET_32 | PAPI_PROFIL_BUCKET_64)
/* @defgroup overflow_defns Overflow definitions 
   @{ */
#define PAPI_OVERFLOW_FORCE_SW 0x40 
#define PAPI_OVERFLOW_HARDWARE 0x80 
#define PAPI_MULTIPLEX_DEFAULT  0x0 
#define PAPI_MULTIPLEX_FORCE_SW 0x1 
#define PAPI_INHERIT_ALL  1     
#define PAPI_INHERIT_NONE 0     
#define PAPI_DETACH         1       
#define PAPI_DEBUG          2       
#define PAPI_MULTIPLEX      3       
#define PAPI_DEFDOM         4       
#define PAPI_DOMAIN         5       
#define PAPI_DEFGRN         6       
#define PAPI_GRANUL         7       
#define PAPI_DEF_MPX_NS     8       
#define PAPI_MAX_MPX_CTRS   11      
#define PAPI_PROFIL         12      
#define PAPI_PRELOAD        13      
#define PAPI_CLOCKRATE      14      
#define PAPI_MAX_HWCTRS     15      
#define PAPI_HWINFO         16      
#define PAPI_EXEINFO        17      
#define PAPI_MAX_CPUS       18      
#define PAPI_ATTACH         19      
#define PAPI_SHLIBINFO      20      
#define PAPI_LIB_VERSION    21      
#define PAPI_COMPONENTINFO  22      
/* Currently the following options are only available on Itanium; they may be supported elsewhere in the future */
#define PAPI_DATA_ADDRESS   23      
#define PAPI_INSTR_ADDRESS  24      
#define PAPI_DEF_ITIMER     25      
#define PAPI_DEF_ITIMER_NS  26      
/* Currently the following options are only available on systems using the perf_events component within papi */
#define PAPI_CPU_ATTACH     27      
#define PAPI_INHERIT        28      
#define PAPI_USER_EVENTS_FILE 29    
#define PAPI_INIT_SLOTS    64     /*Number of initialized slots in
                                   DynamicArray of EventSets */
 
#define PAPI_MIN_STR_LEN        64      /* For small strings, like names & stuff */
#define PAPI_MAX_STR_LEN       128      /* For average run-of-the-mill strings */
#define PAPI_2MAX_STR_LEN      256      /* For somewhat longer run-of-the-mill strings */
#define PAPI_HUGE_STR_LEN     1024      /* This should be defined in terms of a system parameter */
 
#define PAPI_PMU_MAX           80      /* maximum number of pmu's supported by one component */
#define PAPI_DERIVED           0x1      /* Flag to indicate that the event is derived */
enum {
   PAPI_ENUM_EVENTS = 0,        
   PAPI_ENUM_FIRST,             
   PAPI_PRESET_ENUM_AVAIL,      
   /* PAPI PRESET section */
   PAPI_PRESET_ENUM_MSC,        
   PAPI_PRESET_ENUM_INS,        
   PAPI_PRESET_ENUM_IDL,        
   PAPI_PRESET_ENUM_BR,         
   PAPI_PRESET_ENUM_CND,        
   PAPI_PRESET_ENUM_MEM,        
   PAPI_PRESET_ENUM_CACH,       
   PAPI_PRESET_ENUM_L1,         
   PAPI_PRESET_ENUM_L2,         
   PAPI_PRESET_ENUM_L3,         
   PAPI_PRESET_ENUM_TLB,        
   PAPI_PRESET_ENUM_FP,         
   /* PAPI native event related section */
   PAPI_NTV_ENUM_UMASKS,        
   PAPI_NTV_ENUM_UMASK_COMBOS,  
   PAPI_NTV_ENUM_IARR,          
   PAPI_NTV_ENUM_DARR,          
   PAPI_NTV_ENUM_OPCM,          
   PAPI_NTV_ENUM_IEAR,          
   PAPI_NTV_ENUM_DEAR,          
   PAPI_NTV_ENUM_GROUPS         
};
 
#define PAPI_ENUM_ALL PAPI_ENUM_EVENTS
 
#define PAPI_PRESET_BIT_MSC     (1 << PAPI_PRESET_ENUM_MSC) /* Miscellaneous preset event bit */
#define PAPI_PRESET_BIT_INS     (1 << PAPI_PRESET_ENUM_INS) /* Instruction related preset event bit */
#define PAPI_PRESET_BIT_IDL     (1 << PAPI_PRESET_ENUM_IDL) /* Stalled or Idle preset event bit */
#define PAPI_PRESET_BIT_BR      (1 << PAPI_PRESET_ENUM_BR)  /* branch related preset events */
#define PAPI_PRESET_BIT_CND     (1 << PAPI_PRESET_ENUM_CND) /* conditional preset events */
#define PAPI_PRESET_BIT_MEM     (1 << PAPI_PRESET_ENUM_MEM) /* memory related preset events */
#define PAPI_PRESET_BIT_CACH    (1 << PAPI_PRESET_ENUM_CACH)    /* cache related preset events */
#define PAPI_PRESET_BIT_L1      (1 << PAPI_PRESET_ENUM_L1)  /* L1 cache related preset events */
#define PAPI_PRESET_BIT_L2      (1 << PAPI_PRESET_ENUM_L2)  /* L2 cache related preset events */
#define PAPI_PRESET_BIT_L3      (1 << PAPI_PRESET_ENUM_L3)  /* L3 cache related preset events */
#define PAPI_PRESET_BIT_TLB     (1 << PAPI_PRESET_ENUM_TLB) /* Translation Lookaside Buffer events */
#define PAPI_PRESET_BIT_FP      (1 << PAPI_PRESET_ENUM_FP)  /* Floating Point related preset events */
 
#define PAPI_NTV_GROUP_AND_MASK     0x00FF0000  /* bits occupied by group number */
#define PAPI_NTV_GROUP_SHIFT        16          /* bit shift to encode group number */
/* 
The Low Level API
 
The following functions represent the low level portion of the
PerfAPI. These functions provide greatly increased efficiency and
functionality over the high level API presented in the next
section. All of the following functions are callable from both C and
Fortran except where noted. As mentioned in the introduction, the low
level API is only as powerful as the component upon which it is
built. Thus some features may not be available on every platform. The
converse may also be true, that more advanced features may be
available and defined in the header file.  The user is encouraged to
read the documentation carefully.  */
 
 
#include <signal.h>
 
/*  Earlier versions of PAPI define a special long_long type to mask
    an incompatibility between the Windows compiler and gcc-style compilers.
    That problem no longer exists, so long_long has been purged from the source.
    The defines below preserve backward compatibility. Their use is deprecated,
    but will continue to be supported in the near term.
*/
#define long_long long long
#define u_long_long unsigned long long
 
    typedef unsigned long PAPI_thread_id_t;
 
    typedef struct _papi_all_thr_spec {
     int num;
     PAPI_thread_id_t *id;
     void **data;
   } PAPI_all_thr_spec_t;
 
  typedef void (*PAPI_overflow_handler_t) (int EventSet, void *address,
                                long long overflow_vector, void *context);
 
typedef void *vptr_t;
 
   typedef struct _papi_sprofil {
      void *pr_base;          
      unsigned pr_size;       
      vptr_t pr_off;         
      unsigned pr_scale;      
   } PAPI_sprofil_t;
 
   typedef struct _papi_itimer_option {
     int itimer_num;
     int itimer_sig;
     int ns;
     int flags;
   } PAPI_itimer_option_t;
 
   typedef struct _papi_inherit_option {
      int eventset;
      int inherit;
   } PAPI_inherit_option_t;
 
   typedef struct _papi_domain_option {
      int def_cidx; 
      int eventset;
      int domain;
   } PAPI_domain_option_t;
 
   typedef struct _papi_granularity_option {
      int def_cidx; 
      int eventset;
      int granularity;
   } PAPI_granularity_option_t;
 
   typedef struct _papi_preload_option {
      char lib_preload_env[PAPI_MAX_STR_LEN];   
      char lib_preload_sep;
      char lib_dir_env[PAPI_MAX_STR_LEN];
      char lib_dir_sep;
   } PAPI_preload_info_t;
 
   typedef struct _papi_component_option {
     char name[PAPI_MAX_STR_LEN];            
     char short_name[PAPI_MIN_STR_LEN];      
     char description[PAPI_MAX_STR_LEN];     
     char version[PAPI_MIN_STR_LEN];         
     char support_version[PAPI_MIN_STR_LEN]; 
     char kernel_version[PAPI_MIN_STR_LEN];  
     char disabled_reason[PAPI_HUGE_STR_LEN]; 
     int disabled;   
     int initialized;                        
     int CmpIdx;                
     int num_cntrs;               
     int num_mpx_cntrs;           
     int num_preset_events;       
     int num_native_events;       
     int default_domain;          
     int available_domains;       
     int default_granularity;     
     int available_granularities; 
     int hardware_intr_sig;       
     int component_type;          
     char *pmu_names[PAPI_PMU_MAX];         
     int reserved[8];             /* */
     unsigned int hardware_intr:1;         
     unsigned int precise_intr:1;          
     unsigned int posix1b_timers:1;        
     unsigned int kernel_profile:1;        
     unsigned int kernel_multiplex:1;      
     unsigned int fast_counter_read:1;     
     unsigned int fast_real_timer:1;       
     unsigned int fast_virtual_timer:1;    
     unsigned int attach:1;                
     unsigned int attach_must_ptrace:1;    
     unsigned int cntr_umasks:1;           
     /* This should be a granularity option */
     unsigned int cpu:1;                   
     unsigned int inherit:1;               
     unsigned int reserved_bits:19;
   } PAPI_component_info_t;
 
   typedef struct _papi_mpx_info {
     int timer_sig;             
     int timer_num;             
     int timer_us;              
   } PAPI_mpx_info_t;
 
   typedef int (*PAPI_debug_handler_t) (int code);
 
   typedef struct _papi_debug_option {
      int level;
      PAPI_debug_handler_t handler;
   } PAPI_debug_option_t;
 
   typedef struct _papi_address_map {
      char name[PAPI_HUGE_STR_LEN];
      vptr_t text_start;       
      vptr_t text_end;         
      vptr_t data_start;       
      vptr_t data_end;         
      vptr_t bss_start;        
      vptr_t bss_end;          
   } PAPI_address_map_t;
 
   typedef struct _papi_program_info {
      char fullname[PAPI_HUGE_STR_LEN];  
      PAPI_address_map_t address_info;   
   } PAPI_exe_info_t;
 
   typedef struct _papi_shared_lib_info {
      PAPI_address_map_t *map;
      int count;
   } PAPI_shlib_info_t;
 
typedef char* PAPI_user_defined_events_file_t;
 
   /* The following defines and next for structures define the memory hierarchy */
   /* All sizes are in BYTES */
   /* Associativity:
        0: Undefined;
        1: Direct Mapped
        SHRT_MAX: Full
        Other values == associativity
   */
#define PAPI_MH_TYPE_EMPTY    0x0
#define PAPI_MH_TYPE_INST     0x1
#define PAPI_MH_TYPE_DATA     0x2
#define PAPI_MH_TYPE_VECTOR   0x4
#define PAPI_MH_TYPE_TRACE    0x8
#define PAPI_MH_TYPE_UNIFIED  (PAPI_MH_TYPE_INST|PAPI_MH_TYPE_DATA)
#define PAPI_MH_CACHE_TYPE(a) (a & 0xf)
#define PAPI_MH_TYPE_WT       0x00     /* write-through cache */
#define PAPI_MH_TYPE_WB       0x10     /* write-back cache */
#define PAPI_MH_CACHE_WRITE_POLICY(a) (a & 0xf0)
#define PAPI_MH_TYPE_UNKNOWN  0x000
#define PAPI_MH_TYPE_LRU      0x100
#define PAPI_MH_TYPE_PSEUDO_LRU 0x200
#define PAPI_MH_TYPE_FIFO     0x400
#define PAPI_MH_CACHE_REPLACEMENT_POLICY(a) (a & 0xf00)
#define PAPI_MH_TYPE_TLB       0x1000  /* tlb, not memory cache */
#define PAPI_MH_TYPE_PREF      0x2000  /* prefetch buffer */
#define PAPI_MH_TYPE_RD_ALLOC       0x10000 /* read-allocation cache */
#define PAPI_MH_TYPE_WR_ALLOC       0x20000 /* write-allocation cache */
#define PAPI_MH_TYPE_RW_ALLOC       0x40000 /* read-write-allocation cache */
#define PAPI_MH_CACHE_ALLOCATION_POLICY(a) (a & 0xf0000)
#define PAPI_MH_MAX_LEVELS    6        /* # descriptors for each TLB or cache level */
#define PAPI_MAX_MEM_HIERARCHY_LEVELS     4
 
   typedef struct _papi_mh_tlb_info {
      int type; 
      int num_entries;
      int page_size;
      int associativity;
   } PAPI_mh_tlb_info_t;
 
   typedef struct _papi_mh_cache_info {
      int type; 
      int size;
      int line_size;
      int num_lines;
      int associativity;
   } PAPI_mh_cache_info_t;
 
   typedef struct _papi_mh_level_info {
      PAPI_mh_tlb_info_t   tlb[PAPI_MH_MAX_LEVELS];
      PAPI_mh_cache_info_t cache[PAPI_MH_MAX_LEVELS];
   } PAPI_mh_level_t;
 
   typedef struct _papi_mh_info { 
      int levels;
      PAPI_mh_level_t level[PAPI_MAX_MEM_HIERARCHY_LEVELS];
   } PAPI_mh_info_t;
 
   typedef struct _papi_hw_info {
      int ncpu;                     
      int threads;                  
      int cores;                    
      int sockets;                  
      int nnodes;                   
      int totalcpus;                
      int vendor;                   
      char vendor_string[PAPI_MAX_STR_LEN];     
      int model;                    
      char model_string[PAPI_MAX_STR_LEN];      
      float revision;               
      int cpuid_family;             
      int cpuid_model;              
      int cpuid_stepping;           
      int cpu_max_mhz;              
      int cpu_min_mhz;              
      PAPI_mh_info_t mem_hierarchy; 
      int virtualized;              
      char virtual_vendor_string[PAPI_MAX_STR_LEN]; 
      char virtual_vendor_version[PAPI_MAX_STR_LEN];
      /* Legacy Values, do not use */
      float mhz;                    
      int clock_mhz;                
      /* For future expansion */
      int reserved[8];
 
   } PAPI_hw_info_t;
 
   typedef struct _papi_attach_option {
      int eventset;
      unsigned long tid;
   } PAPI_attach_option_t;
 
      typedef struct _papi_cpu_option {
         int eventset;
         unsigned int cpu_num;
      } PAPI_cpu_option_t;
 
   typedef struct _papi_multiplex_option {
      int eventset;
      int ns;
      int flags;
   } PAPI_multiplex_option_t;
 
   typedef struct _papi_addr_range_option { 
      int eventset;           
      vptr_t start;          
      vptr_t end;            
      int start_off;          
      int end_off;            
   } PAPI_addr_range_option_t;
 
    typedef union
    {
        PAPI_preload_info_t preload;
        PAPI_debug_option_t debug;
        PAPI_inherit_option_t inherit;
        PAPI_granularity_option_t granularity;
        PAPI_granularity_option_t defgranularity;
        PAPI_domain_option_t domain;
        PAPI_domain_option_t defdomain;
        PAPI_attach_option_t attach;
        PAPI_cpu_option_t cpu;
        PAPI_multiplex_option_t multiplex;
        PAPI_itimer_option_t itimer;
        PAPI_hw_info_t *hw_info;
        PAPI_shlib_info_t *shlib_info;
        PAPI_exe_info_t *exe_info;
        PAPI_component_info_t *cmp_info;
        PAPI_addr_range_option_t addr;
        PAPI_user_defined_events_file_t events_file;
    } PAPI_option_t;
 
    typedef struct _dmem_t {
      long long peak;
      long long size;
      long long resident;
      long long high_water_mark;
      long long shared;
      long long text;
      long long library;
      long long heap;
      long long locked;
      long long stack;
      long long pagesize;
      long long pte;
    } PAPI_dmem_info_t;
 
/* Fortran offsets into PAPI_dmem_info_t structure. */
 
#define PAPIF_DMEM_VMPEAK     1
#define PAPIF_DMEM_VMSIZE     2
#define PAPIF_DMEM_RESIDENT   3
#define PAPIF_DMEM_HIGH_WATER 4
#define PAPIF_DMEM_SHARED     5
#define PAPIF_DMEM_TEXT       6
#define PAPIF_DMEM_LIBRARY    7
#define PAPIF_DMEM_HEAP       8
#define PAPIF_DMEM_LOCKED     9
#define PAPIF_DMEM_STACK      10
#define PAPIF_DMEM_PAGESIZE   11
#define PAPIF_DMEM_PTE        12
#define PAPIF_DMEM_MAXVAL     12
 
#define PAPI_MAX_INFO_TERMS  12        /* should match PAPI_EVENTS_IN_DERIVED_EVENT defined in papi_internal.h */
 
 
enum {
   PAPI_LOCATION_CORE = 0,          
   PAPI_LOCATION_CPU,               
   PAPI_LOCATION_PACKAGE,           
   PAPI_LOCATION_UNCORE,            
};
 
enum {
   PAPI_DATATYPE_INT64 = 0,         
   PAPI_DATATYPE_UINT64,            
   PAPI_DATATYPE_FP64,              
   PAPI_DATATYPE_BIT64,             
};
 
enum {
   PAPI_VALUETYPE_RUNNING_SUM = 0,  
   PAPI_VALUETYPE_ABSOLUTE,         
};
 
enum {
   PAPI_TIMESCOPE_SINCE_START = 0,  
   PAPI_TIMESCOPE_SINCE_LAST,       
   PAPI_TIMESCOPE_UNTIL_NEXT,       
   PAPI_TIMESCOPE_POINT,            
};
 
enum {
   PAPI_UPDATETYPE_ARBITRARY = 0,   
   PAPI_UPDATETYPE_PUSH,            
   PAPI_UPDATETYPE_PULL,            
   PAPI_UPDATETYPE_FIXEDFREQ,       
};
 
 
   typedef struct event_info {
      unsigned int event_code;             
      char symbol[PAPI_HUGE_STR_LEN];      
      char short_descr[PAPI_MIN_STR_LEN];  
      char long_descr[PAPI_HUGE_STR_LEN];  
      int component_index;           
      char units[PAPI_MIN_STR_LEN];  
      int location;                  
      int data_type;                 
      int value_type;                
      int timescope;                 
      int update_type;               
      int update_freq;               
     /* PRESET SPECIFIC FIELDS FOLLOW */
 
 
 
      unsigned int count;                
      unsigned int event_type;           
      char derived[PAPI_MIN_STR_LEN];    
      char postfix[PAPI_2MAX_STR_LEN];   
      unsigned int code[PAPI_MAX_INFO_TERMS]; 
      char name[PAPI_MAX_INFO_TERMS]         
               [PAPI_2MAX_STR_LEN];          
     char note[PAPI_HUGE_STR_LEN];          
   } PAPI_event_info_t;
 
 
typedef enum {
    PAPI_DEV_TYPE_ID__CPU,
    PAPI_DEV_TYPE_ID__CUDA,
    PAPI_DEV_TYPE_ID__ROCM,
    PAPI_DEV_TYPE_ID__MAX_NUM,
} PAPI_dev_type_id_e;
 
enum {
    PAPI_DEV_TYPE_ENUM__FIRST= (0                          ),
    PAPI_DEV_TYPE_ENUM__CPU  = (1 << PAPI_DEV_TYPE_ID__CPU ),
    PAPI_DEV_TYPE_ENUM__CUDA = (1 << PAPI_DEV_TYPE_ID__CUDA),
    PAPI_DEV_TYPE_ENUM__ROCM = (1 << PAPI_DEV_TYPE_ID__ROCM),
    PAPI_DEV_TYPE_ENUM__ALL  = (1 << PAPI_DEV_TYPE_ID__MAX_NUM) - 1,
};
 
typedef enum {
    PAPI_DEV_TYPE_ATTR__INT_PAPI_ID,
    PAPI_DEV_TYPE_ATTR__INT_VENDOR_ID,
    PAPI_DEV_TYPE_ATTR__CHAR_NAME,
    PAPI_DEV_TYPE_ATTR__INT_COUNT,
    PAPI_DEV_TYPE_ATTR__CHAR_STATUS,
} PAPI_dev_type_attr_e;
 
typedef enum {
    PAPI_DEV_ATTR__CPU_CHAR_NAME,
    PAPI_DEV_ATTR__CPU_UINT_L1I_CACHE_SIZE,
    PAPI_DEV_ATTR__CPU_UINT_L1D_CACHE_SIZE,
    PAPI_DEV_ATTR__CPU_UINT_L2U_CACHE_SIZE,
    PAPI_DEV_ATTR__CPU_UINT_L3U_CACHE_SIZE,
    PAPI_DEV_ATTR__CPU_UINT_L1I_CACHE_LINE_SIZE,
    PAPI_DEV_ATTR__CPU_UINT_L1D_CACHE_LINE_SIZE,
    PAPI_DEV_ATTR__CPU_UINT_L2U_CACHE_LINE_SIZE,
    PAPI_DEV_ATTR__CPU_UINT_L3U_CACHE_LINE_SIZE,
    PAPI_DEV_ATTR__CPU_UINT_L1I_CACHE_LINE_COUNT,
    PAPI_DEV_ATTR__CPU_UINT_L1D_CACHE_LINE_COUNT,
    PAPI_DEV_ATTR__CPU_UINT_L2U_CACHE_LINE_COUNT,
    PAPI_DEV_ATTR__CPU_UINT_L3U_CACHE_LINE_COUNT,
    PAPI_DEV_ATTR__CPU_UINT_L1I_CACHE_ASSOC,
    PAPI_DEV_ATTR__CPU_UINT_L1D_CACHE_ASSOC,
    PAPI_DEV_ATTR__CPU_UINT_L2U_CACHE_ASSOC,
    PAPI_DEV_ATTR__CPU_UINT_L3U_CACHE_ASSOC,
    PAPI_DEV_ATTR__CPU_UINT_SOCKET_COUNT,
    PAPI_DEV_ATTR__CPU_UINT_NUMA_COUNT,
    PAPI_DEV_ATTR__CPU_UINT_CORE_COUNT,
    PAPI_DEV_ATTR__CPU_UINT_THREAD_COUNT,
    PAPI_DEV_ATTR__CPU_UINT_FAMILY,
    PAPI_DEV_ATTR__CPU_UINT_MODEL,
    PAPI_DEV_ATTR__CPU_UINT_STEPPING,
    PAPI_DEV_ATTR__CPU_UINT_NUMA_MEM_SIZE,
    PAPI_DEV_ATTR__CPU_UINT_THR_NUMA_AFFINITY,
    PAPI_DEV_ATTR__CPU_UINT_THR_PER_NUMA,
    PAPI_DEV_ATTR__CUDA_ULONG_UID,
    PAPI_DEV_ATTR__CUDA_CHAR_DEVICE_NAME,
    PAPI_DEV_ATTR__CUDA_UINT_WARP_SIZE,
    PAPI_DEV_ATTR__CUDA_UINT_SHM_PER_BLK,
    PAPI_DEV_ATTR__CUDA_UINT_SHM_PER_SM,
    PAPI_DEV_ATTR__CUDA_UINT_BLK_DIM_X,
    PAPI_DEV_ATTR__CUDA_UINT_BLK_DIM_Y,
    PAPI_DEV_ATTR__CUDA_UINT_BLK_DIM_Z,
    PAPI_DEV_ATTR__CUDA_UINT_GRD_DIM_X,
    PAPI_DEV_ATTR__CUDA_UINT_GRD_DIM_Y,
    PAPI_DEV_ATTR__CUDA_UINT_GRD_DIM_Z,
    PAPI_DEV_ATTR__CUDA_UINT_THR_PER_BLK,
    PAPI_DEV_ATTR__CUDA_UINT_SM_COUNT,
    PAPI_DEV_ATTR__CUDA_UINT_MULTI_KERNEL,
    PAPI_DEV_ATTR__CUDA_UINT_MAP_HOST_MEM,
    PAPI_DEV_ATTR__CUDA_UINT_MEMCPY_OVERLAP,
    PAPI_DEV_ATTR__CUDA_UINT_UNIFIED_ADDR,
    PAPI_DEV_ATTR__CUDA_UINT_MANAGED_MEM,
    PAPI_DEV_ATTR__CUDA_UINT_COMP_CAP_MAJOR,
    PAPI_DEV_ATTR__CUDA_UINT_COMP_CAP_MINOR,
    PAPI_DEV_ATTR__CUDA_UINT_BLK_PER_SM,
    PAPI_DEV_ATTR__ROCM_ULONG_UID,
    PAPI_DEV_ATTR__ROCM_CHAR_DEVICE_NAME,
    PAPI_DEV_ATTR__ROCM_UINT_WAVEFRONT_SIZE,
    PAPI_DEV_ATTR__ROCM_UINT_WORKGROUP_SIZE,
    PAPI_DEV_ATTR__ROCM_UINT_WAVE_PER_CU,
    PAPI_DEV_ATTR__ROCM_UINT_SHM_PER_WG,
    PAPI_DEV_ATTR__ROCM_UINT_WG_DIM_X,
    PAPI_DEV_ATTR__ROCM_UINT_WG_DIM_Y,
    PAPI_DEV_ATTR__ROCM_UINT_WG_DIM_Z,
    PAPI_DEV_ATTR__ROCM_UINT_GRD_DIM_X,
    PAPI_DEV_ATTR__ROCM_UINT_GRD_DIM_Y,
    PAPI_DEV_ATTR__ROCM_UINT_GRD_DIM_Z,
    PAPI_DEV_ATTR__ROCM_UINT_CU_COUNT,
    PAPI_DEV_ATTR__ROCM_UINT_SIMD_PER_CU,
    PAPI_DEV_ATTR__ROCM_UINT_COMP_CAP_MAJOR,
    PAPI_DEV_ATTR__ROCM_UINT_COMP_CAP_MINOR,
} PAPI_dev_attr_e;
 
 
   int   PAPI_accum(int EventSet, long long * values); 
   int   PAPI_add_event(int EventSet, int Event); 
   int   PAPI_add_named_event(int EventSet, const char *EventName); 
   int   PAPI_add_events(int EventSet, int *Events, int number); 
   int   PAPI_assign_eventset_component(int EventSet, int cidx); 
   int   PAPI_attach(int EventSet, unsigned long tid); 
   int   PAPI_cleanup_eventset(int EventSet); 
   int   PAPI_create_eventset(int *EventSet); 
   int   PAPI_detach(int EventSet); 
   int   PAPI_destroy_eventset(int *EventSet); 
   int   PAPI_enum_event(int *EventCode, int modifier); 
   int   PAPI_enum_cmp_event(int *EventCode, int modifier, int cidx); 
   int   PAPI_event_code_to_name(int EventCode, char *out); 
   int   PAPI_event_name_to_code(const char *in, int *out); 
   int  PAPI_get_dmem_info(PAPI_dmem_info_t *dest); 
   int   PAPI_get_event_info(int EventCode, PAPI_event_info_t * info); 
   const PAPI_exe_info_t *PAPI_get_executable_info(void); 
   const PAPI_hw_info_t *PAPI_get_hardware_info(void); 
   const PAPI_component_info_t *PAPI_get_component_info(int cidx); 
   int   PAPI_get_multiplex(int EventSet); 
   int   PAPI_get_opt(int option, PAPI_option_t * ptr); 
   int   PAPI_get_cmp_opt(int option, PAPI_option_t * ptr,int cidx); 
   long long PAPI_get_real_cyc(void); 
   long long PAPI_get_real_nsec(void); 
   long long PAPI_get_real_usec(void); 
   const PAPI_shlib_info_t *PAPI_get_shared_lib_info(void); 
   int   PAPI_get_thr_specific(int tag, void **ptr); 
   int   PAPI_get_overflow_event_index(int Eventset, long long overflow_vector, int *array, int *number); 
   long long PAPI_get_virt_cyc(void); 
   long long PAPI_get_virt_nsec(void); 
   long long PAPI_get_virt_usec(void); 
   int   PAPI_is_initialized(void); 
   int   PAPI_library_init(int version); 
   int   PAPI_list_events(int EventSet, int *Events, int *number); 
   int   PAPI_list_threads(unsigned long *tids, int *number); 
   int   PAPI_lock(int); 
   int   PAPI_multiplex_init(void); 
   int   PAPI_num_cmp_hwctrs(int cidx); 
   int   PAPI_num_events(int EventSet); 
   int   PAPI_overflow(int EventSet, int EventCode, int threshold,
                     int flags, PAPI_overflow_handler_t handler); 
   void  PAPI_perror(const char *msg ); 
   int   PAPI_profil(void *buf, unsigned bufsiz, vptr_t offset,
                     unsigned scale, int EventSet, int EventCode,
                     int threshold, int flags); 
   int   PAPI_query_event(int EventCode); 
   int   PAPI_query_named_event(const char *EventName); 
   int   PAPI_read(int EventSet, long long * values); 
   int   PAPI_read_ts(int EventSet, long long * values, long long *cyc); 
   int   PAPI_register_thread(void); 
   int   PAPI_remove_event(int EventSet, int EventCode); 
   int   PAPI_remove_named_event(int EventSet, const char *EventName); 
   int   PAPI_remove_events(int EventSet, int *Events, int number); 
   int   PAPI_reset(int EventSet); 
   int   PAPI_set_debug(int level); 
   int   PAPI_set_cmp_domain(int domain, int cidx); 
   int   PAPI_set_domain(int domain); 
   int   PAPI_set_cmp_granularity(int granularity, int cidx); 
   int   PAPI_set_granularity(int granularity); 
   int   PAPI_set_multiplex(int EventSet); 
   int   PAPI_set_opt(int option, PAPI_option_t * ptr); 
   int   PAPI_set_thr_specific(int tag, void *ptr); 
   void  PAPI_shutdown(void); 
   int   PAPI_sprofil(PAPI_sprofil_t * prof, int profcnt, int EventSet, int EventCode, int threshold, int flags); 
   int   PAPI_start(int EventSet); 
   int   PAPI_state(int EventSet, int *status); 
   int   PAPI_stop(int EventSet, long long * values); 
   char *PAPI_strerror(int); 
   unsigned long PAPI_thread_id(void); 
   int   PAPI_thread_init(unsigned long (*id_fn) (void)); 
   int   PAPI_unlock(int); 
   int   PAPI_unregister_thread(void); 
   int   PAPI_write(int EventSet, long long * values); 
   int   PAPI_get_event_component(int EventCode);  
   int   PAPI_get_eventset_component(int EventSet);  
   int   PAPI_get_component_index(const char *name); 
   int   PAPI_disable_component(int cidx); 
   int   PAPI_disable_component_by_name(const char *name ); 
   int PAPI_num_components(void); 
   int PAPI_flips_rate(int event, float *rtime, float *ptime, long long *flpins, float *mflips); 
   int PAPI_flops_rate(int event, float *rtime, float *ptime, long long * flpops, float *mflops); 
   int PAPI_ipc(float *rtime, float *ptime, long long * ins, float *ipc); 
   int PAPI_epc(int event, float *rtime, float *ptime, long long *ref, long long *core, long long *evt, float *epc); 
   int PAPI_rate_stop(void); 
   int PAPI_enum_dev_type(int enum_modifier, void **handle); 
   int PAPI_get_dev_type_attr(void *handle, PAPI_dev_type_attr_e attr, void *value); 
   int PAPI_get_dev_attr(void *handle, int id, PAPI_dev_attr_e attr, void *value); 
   int PAPI_hl_region_begin(const char* region); 
   int PAPI_hl_read(const char* region); 
   int PAPI_hl_region_end(const char* region); 
   int PAPI_hl_stop(void); 
/* Backwards compatibility hacks.  Remove eventually? */
int   PAPI_num_hwctrs(void); 
#define PAPI_COMPONENT_INDEX(a) PAPI_get_event_component(a)
#define PAPI_descr_error(a) PAPI_strerror(a)
 
#ifdef __cplusplus
}
#endif
 
#pragma GCC visibility pop
 
#endif