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

/* 
* File:    papivi.h
* CVS:     $Id: papivi.h 5064 2010-02-10 13:58:53Z knobi $
* Author:  dan terpstra
*          terpstra@cs.utk.edu
* Mods:    your name here
*          yourname@cs.esu.edu
*
* Include this file INSTEAD OF "papi.h" in your application code
* to provide semitransparent version independent PAPI support.
* Follow the rules described below and elsewhere to facilitate
* this support.
*
*/

#ifndef _PAPIVI
#define _PAPIVI

#include "papi.h"

/***************************************************************************
* If PAPI_VERSION is not defined, then papi.h is for PAPI 2.
* The preprocessor block below contains the definitions, data structures,
* macros and code needed to emulate much of the PAPI 3 interface in code
* linking to the PAPI 2 library.
****************************************************************************/
#ifndef PAPI_VERSION


#define PAPI_VERSION_NUMBER(maj,min,rev) (((maj)<<16) | ((min)<<8) | (rev))
#define PAPI_VERSION_MAJOR(x)   	(((x)>>16)    & 0xffff)
#define PAPI_VERSION_MINOR(x)		(((x)>>8)     & 0xff)
#define PAPI_VERSION_REVISION(x)	((x)          & 0xff)

/* This is the PAPI version on which we are running */
#define PAPI_VERSION  			PAPI_VERSION_NUMBER(2,3,4)

/* This is the PAPI 3 version with which we are compatible */
#define PAPI_VI_VERSION  			PAPI_VERSION_NUMBER(3,0,6)

/* PAPI 3 has an error code not defined for PAPI 2 */
#define PAPI_EPERM   PAPI_EMISC        /* You lack the necessary permissions */

/*
* These are defined in papi_internal.h for PAPI 2.
* They need to be exposed for version independent PAPI code to work.
*/
/*#define PRESET_MASK     0x80000000*/
#define PAPI_PRESET_MASK 0x80000000
/*#define PRESET_AND_MASK 0x7FFFFFFF*/
#define PAPI_PRESET_AND_MASK 0x7FFFFFFF
#define PAPI_NATIVE_MASK 0x40000000
#define PAPI_NATIVE_AND_MASK 0x3FFFFFFF

/*
* Some PAPI 3 definitions for PAPI_{set,get}_opt() map
* onto single definitions in PAPI 2. The new definitions
* (shown below) should be used to guarantee PAPI 3 compatibility.
*/
#define PAPI_CLOCKRATE     PAPI_GET_CLOCKRATE
#define PAPI_MAX_HWCTRS    PAPI_GET_MAX_HWCTRS
#define PAPI_HWINFO        PAPI_GET_HWINFO
#define PAPI_EXEINFO       PAPI_GET_EXEINFO
#define PAPI_MAX_CPUS      PAPI_GET_MAX_CPUS
#define PAPI_CPUS          PAPI_GET_CPUS
#define PAPI_THREADS       PAPI_GET_THREADS

/*
* PAPI 2 defined only one string length.
* PAPI 3 defines three. This insures limited compatibility.
*/
#define PAPI_MIN_STR_LEN   PAPI_MAX_STR_LEN
#define PAPI_HUGE_STR_LEN  PAPI_MAX_STR_LEN

/*
* PAPI 2 always profiles into 16-bit buckets.
* PAPI 3 supports multiple bucket sizes.
* Exercise caution if these defines appear in your code.
* There is a potential for data overflow in PAPI 2.
*/
#define PAPI_PROFIL_BUCKET_16 0
#define PAPI_PROFIL_BUCKET_32 0
#define PAPI_PROFIL_BUCKET_64 0

/*
* PAPI 3 defines a new eventcode that can often be emulated
* successfully on PAPI 2. PAPI 3 also deprecates two eventcodes
* found in PAPI 2:
* PAPI_IPS   (instructions per second)
* PAPI_FLOPS (floating point instructions per second)
* Don't use these eventcodes in version independent code
*/
#define PAPI_FP_OPS PAPI_FP_INS

/*
* Two new data structures are introduced in PAPI 3 that are 
* required to support the functionality of:
* PAPI_get_event_info() and
* PAPI_get_executable_info()
* These structures are reproduced below.
* They MUST stay synchronized with their counterparts in papi.h
*/
#define PAPI_MAX_INFO_TERMS 8
typedef struct event_info {
   unsigned int event_code;
   unsigned int count;
   char symbol[PAPI_MAX_STR_LEN+3];
   char short_descr[PAPI_MIN_STR_LEN];
   char long_descr[PAPI_HUGE_STR_LEN];
   char derived[PAPI_MIN_STR_LEN];
   char postfix[PAPI_MIN_STR_LEN]; 
   unsigned int code[PAPI_MAX_INFO_TERMS];
   char name[PAPI_MAX_INFO_TERMS]
            [PAPI_MIN_STR_LEN];
   char note[PAPI_HUGE_STR_LEN];
} PAPI_event_info_t;

/* Possible values for the 'modifier' parameter of the PAPI_enum_event call.
   This enumeration is new in PAPI 3. It will act as a nop in PAPI 2, but
   must be defined for code compatibility.
*/
enum {
   PAPI_ENUM_ALL = 0,			/* Always enumerate all events */
   PAPI_PRESET_ENUM_AVAIL, 		/* Enumerate events that exist here */

   /* PAPI PRESET section */
   PAPI_PRESET_ENUM_INS,		/* Instruction related preset events */
   PAPI_PRESET_ENUM_BR,			/* branch related preset events */
   PAPI_PRESET_ENUM_MEM,		/* memory related preset events */
   PAPI_PRESET_ENUM_TLB,		/* Translation Lookaside Buffer events */
   PAPI_PRESET_ENUM_FP,			/* Floating Point related preset events */

   /* Pentium 4 specific section */
   PAPI_PENT4_ENUM_GROUPS = 0x100,      /* 45 groups + custom + user */
   PAPI_PENT4_ENUM_COMBOS,		/* all combinations of mask bits for given group */
   PAPI_PENT4_ENUM_BITS,		/* all individual bits for given group */

   /* POWER 4 specific section */
   PAPI_PWR4_ENUM_GROUPS = 0x200	/* Enumerate groups an event belongs to */
};

typedef struct _papi_address_map {
   char mapname[PAPI_HUGE_STR_LEN];
   caddr_t text_start;       /* Start address of program text segment */
   caddr_t text_end;         /* End address of program text segment */
   caddr_t data_start;       /* Start address of program data segment */
   caddr_t data_end;         /* End address of program data segment */
   caddr_t bss_start;        /* Start address of program bss segment */
   caddr_t bss_end;          /* End address of program bss segment */
} PAPI_address_map_t;

/*
 * PAPI 3 beta 3 introduces new structures for static memory description.
 * These include structures for tlb and cache description, a structure
 * to describe a level in the memory hierarchy, and a structure 
 * to describe all levels of the hierarchy.
 * These structures, and the requisite data types are defined below.
 */

   /* All sizes are in BYTES */
   /* Except tlb size, which is in entries */

#define PAPI_MAX_MEM_HIERARCHY_LEVELS 	  3
#define PAPI_MH_TYPE_EMPTY    0x0
#define PAPI_MH_TYPE_INST	   0x1
#define PAPI_MH_TYPE_DATA     0x2
#define PAPI_MH_TYPE_UNIFIED  PAPI_MH_TYPE_INST|PAPI_MH_TYPE_DATA

typedef struct _papi_mh_tlb_info {
   int type; /* Empty, unified, data, instr */
   int num_entries;
   int associativity;
} PAPI_mh_tlb_info_t;

typedef struct _papi_mh_cache_info {
   int type; /* Empty, unified, data, instr */
   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[2];
   PAPI_mh_cache_info_t cache[2];
} PAPI_mh_level_t;

typedef struct _papi_mh_info { /* mh for mem hierarchy maybe? */
   int levels;
   PAPI_mh_level_t level[PAPI_MAX_MEM_HIERARCHY_LEVELS];
} PAPI_mh_info_t;

/*
* Three data structures are modified in PAPI 3
* These modifications are 
* required to support the functionality of:
* PAPI_get_hardware_info() and
* PAPI_get_executable_info()
* These structures are reproduced below.
* They MUST stay synchronized with their counterparts in papi.h
* To avoid namespace collisions, these structures have been renamed
* to PAPIvi_xxx, and must also be renamed in your code.
*/
typedef struct _papi3_hw_info {
   int ncpu;                 /* Number of CPU's in an SMP Node */
   int nnodes;               /* Number of Nodes in the entire system */
   int totalcpus;            /* Total number of CPU's in the entire system */
   int vendor;               /* Vendor number of CPU */
   char vendor_string[PAPI_MAX_STR_LEN];     /* Vendor string of CPU */
   int model;                /* Model number of CPU */
   char model_string[PAPI_MAX_STR_LEN];      /* Model string of CPU */
   float revision;           /* Revision of CPU */
   float mhz;                /* Cycle time of this CPU, *may* be estimated at 
                                init time with a quick timing routine */

   PAPI_mh_info_t mem_hierarchy;
} PAPIvi_hw_info_t;

typedef struct _papi3_preload_option {
   char lib_preload_env[PAPI_MAX_STR_LEN];   /* Model string of CPU */
   char lib_preload_sep;
   char lib_dir_env[PAPI_MAX_STR_LEN];
   char lib_dir_sep;
} PAPIvi_preload_option_t;

typedef struct _papi3_program_info {
   char fullname[PAPI_MAX_STR_LEN];  /* path+name */
   char name[PAPI_MAX_STR_LEN];      /* name */
   PAPI_address_map_t address_info;
   PAPIvi_preload_option_t preload_info;
} PAPIvi_exe_info_t;


/*
* The Low Level API
* Functions in this API are classified in 4 basic categories:
* Modified:   13 functions
* New:         8 functions
* Unchanged:  32 functions
* Deprecated:  9 functions
*
* Each of these categories is discussed further below.
*/

/*
* Modified functions are further divided into 4 subcategories:
* Dereferencing changes: 6 functions
*     These functions simply substitute an EventSet value for
*     a pointer to an EventSet. In the case of PAPI_remove_event{s}()
*     there is also a name change.
* Name changes:          1 function
*     This is a simple name change with no change in functionality.
* Parameter changes:     4 functions
*     Several functions have changed functionality reflected in changed
*     parameters:
*     PAPI_{un}lock() supports multiple locks in PAPI 3
*     PAPI_profil() supports multiple bucket sizes in PAPI 3
*     PAPI_thread_init() removes an unused parameter in PAPI 3
* New functionality:     2 functions
*     These functions support new data in revised data structures
*     The code implemented here maps the old structures to the new
*     where possible.
*/

 /* Modified Functons: Dereferencing changes */
#define PAPIvi_add_event(EventSet, Event) \
          PAPI_add_event(&EventSet, Event)
#define PAPIvi_add_events(EventSet, Events, number) \
          PAPI_add_events(&EventSet, Events, number)
#define PAPIvi_cleanup_eventset(EventSet) \
          PAPI_cleanup_eventset(&EventSet)
#define PAPIvi_remove_event(EventSet, EventCode) \
          PAPI_rem_event(&EventSet, EventCode)
#define PAPIvi_remove_events(EventSet, Events, number) \
          PAPI_rem_events(&EventSet, Events, number)
#define PAPIvi_set_multiplex(EventSet) \
          PAPI_set_multiplex(&EventSet)

 /* Modified Functons: Name changes */
#define PAPIvi_is_initialized \
          PAPI_initialized

 /* Modified Functons: Parameter changes */
#define PAPIvi_lock(lck) \
          PAPI_lock()
#define PAPIvi_profil(buf, bufsiz, offset, scale, EventSet, EventCode, threshold, flags) \
          PAPI_profil((unsigned short *)buf, bufsiz, (unsigned long)offset, scale, EventSet, EventCode, threshold, flags)
#define PAPIvi_thread_init(id_fn) \
          PAPI_thread_init(id_fn, 0)
#define PAPIvi_unlock(lck) \
          PAPI_unlock()

 /* Modified Functons: New functionality */
static const PAPIvi_exe_info_t *PAPIvi_get_executable_info(void)
{
   static PAPIvi_exe_info_t prginfo3;
   const PAPI_exe_info_t *prginfo2 = PAPI_get_executable_info();

   if (prginfo2 == NULL) return(NULL);

   strcpy(prginfo3.fullname, prginfo2->fullname);
   strcpy(prginfo3.name, prginfo2->name);
   prginfo3.address_info.mapname[0] = 0;
   prginfo3.address_info.text_start = prginfo2->text_start;
   prginfo3.address_info.text_end = prginfo2->text_end;
   prginfo3.address_info.data_start = prginfo2->data_start;
   prginfo3.address_info.data_end = prginfo2->data_end;
   prginfo3.address_info.bss_start = prginfo2->bss_start;
   prginfo3.address_info.bss_end = prginfo2->bss_end;
   strcpy(prginfo3.preload_info.lib_preload_env, prginfo2->lib_preload_env);

   return(&prginfo3);
}

static const PAPIvi_hw_info_t *PAPIvi_get_hardware_info(void)
{
   static PAPIvi_hw_info_t papi3_hw_info;
   const PAPI_hw_info_t *papi2_hw_info = PAPI_get_hardware_info();
   const PAPI_mem_info_t *papi2_mem_info = PAPI_get_memory_info();

   /* Copy the basic hardware info (same in both structures */
   memcpy(&papi3_hw_info, papi2_hw_info, sizeof(PAPI_hw_info_t));

   memset(&papi3_hw_info.mem_hierarchy, 0, sizeof(PAPI_mh_info_t));
   /* check for a unified tlb */
   if (papi2_mem_info->total_tlb_size && 
      papi2_mem_info->itlb_size == 0 &&
      papi2_mem_info->dtlb_size == 0) {
      papi3_hw_info.mem_hierarchy.level[0].tlb[0].type = PAPI_MH_TYPE_UNIFIED;
      papi3_hw_info.mem_hierarchy.level[0].tlb[0].num_entries = papi2_mem_info->total_tlb_size;
   } else {
      if (papi2_mem_info->itlb_size) {
         papi3_hw_info.mem_hierarchy.level[0].tlb[0].type = PAPI_MH_TYPE_INST;
         papi3_hw_info.mem_hierarchy.level[0].tlb[0].num_entries = papi2_mem_info->itlb_size;
         papi3_hw_info.mem_hierarchy.level[0].tlb[0].associativity = papi2_mem_info->itlb_assoc;
      }
      if (papi2_mem_info->dtlb_size) {
         papi3_hw_info.mem_hierarchy.level[0].tlb[1].type = PAPI_MH_TYPE_DATA;
         papi3_hw_info.mem_hierarchy.level[0].tlb[1].num_entries = papi2_mem_info->dtlb_size;
         papi3_hw_info.mem_hierarchy.level[0].tlb[1].associativity = papi2_mem_info->dtlb_assoc;
      }
   }
   /* check for a unified level 1 cache */
   if (papi2_mem_info->total_L1_size) papi3_hw_info.mem_hierarchy.levels = 1;
   if (papi2_mem_info->total_L1_size && 
      papi2_mem_info->L1_icache_size == 0 &&
      papi2_mem_info->L1_dcache_size == 0) {
      papi3_hw_info.mem_hierarchy.level[0].cache[0].type = PAPI_MH_TYPE_UNIFIED;
      papi3_hw_info.mem_hierarchy.level[0].cache[0].size = papi2_mem_info->total_L1_size << 10;
   } else {
      if (papi2_mem_info->L1_icache_size) {
         papi3_hw_info.mem_hierarchy.level[0].cache[0].type = PAPI_MH_TYPE_INST;
         papi3_hw_info.mem_hierarchy.level[0].cache[0].size = papi2_mem_info->L1_icache_size << 10;
         papi3_hw_info.mem_hierarchy.level[0].cache[0].associativity = papi2_mem_info->L1_icache_assoc;
         papi3_hw_info.mem_hierarchy.level[0].cache[0].num_lines = papi2_mem_info->L1_icache_lines;
         papi3_hw_info.mem_hierarchy.level[0].cache[0].line_size = papi2_mem_info->L1_icache_linesize;
      }
      if (papi2_mem_info->L1_dcache_size) {
         papi3_hw_info.mem_hierarchy.level[0].cache[1].type = PAPI_MH_TYPE_DATA;
         papi3_hw_info.mem_hierarchy.level[0].cache[1].size = papi2_mem_info->L1_dcache_size << 10;
         papi3_hw_info.mem_hierarchy.level[0].cache[1].associativity = papi2_mem_info->L1_dcache_assoc;
         papi3_hw_info.mem_hierarchy.level[0].cache[1].num_lines = papi2_mem_info->L1_dcache_lines;
         papi3_hw_info.mem_hierarchy.level[0].cache[1].line_size = papi2_mem_info->L1_dcache_linesize;
      }
   }

   /* check for level 2 cache info */
   if (papi2_mem_info->L2_cache_size) {
      papi3_hw_info.mem_hierarchy.levels = 2;
      papi3_hw_info.mem_hierarchy.level[1].cache[0].type = PAPI_MH_TYPE_UNIFIED;
      papi3_hw_info.mem_hierarchy.level[1].cache[0].size = papi2_mem_info->L2_cache_size << 10;
      papi3_hw_info.mem_hierarchy.level[1].cache[0].associativity = papi2_mem_info->L2_cache_assoc;
      papi3_hw_info.mem_hierarchy.level[1].cache[0].num_lines = papi2_mem_info->L2_cache_lines;
      papi3_hw_info.mem_hierarchy.level[1].cache[0].line_size = papi2_mem_info->L2_cache_linesize;
   }

   /* check for level 3 cache info */
   if (papi2_mem_info->L3_cache_size) {
      papi3_hw_info.mem_hierarchy.levels = 3;
      papi3_hw_info.mem_hierarchy.level[2].cache[0].type = PAPI_MH_TYPE_UNIFIED;
      papi3_hw_info.mem_hierarchy.level[2].cache[0].size = papi2_mem_info->L3_cache_size << 10;
      papi3_hw_info.mem_hierarchy.level[2].cache[0].associativity = papi2_mem_info->L3_cache_assoc;
      papi3_hw_info.mem_hierarchy.level[2].cache[0].num_lines = papi2_mem_info->L3_cache_lines;
      papi3_hw_info.mem_hierarchy.level[2].cache[0].line_size = papi2_mem_info->L3_cache_linesize;
   }

   return(&papi3_hw_info);
}

/*
* New functions are either supported or unsupported.
* Of the three supported functions, two replaced deprecated functions
* to describe events, and one is simply a convenience function.
* The five unsupported new functions include three related to thread
* functionality, a convenience function to return the number of events
* in an event set, and a function to query information about shared libraries.
*/

 /* New Supported Functions */
static int PAPIvi_enum_event(int *EventCode, int modifier)
{
   int i = *EventCode;
   const PAPI_preset_info_t *presets = PAPI_query_all_events_verbose();
   i &= PAPI_PRESET_AND_MASK;
   while (++i < PAPI_MAX_PRESET_EVENTS) {
      if ((!modifier) || (presets[i].avail)) {
         *EventCode = i | PAPI_PRESET_MASK;
         if (presets[i].event_name != NULL)
            return (PAPI_OK);
         else
            return (PAPI_ENOEVNT);
      }
   }
   return (PAPI_ENOEVNT);
}

static int PAPIvi_get_event_info(int EventCode, PAPI_event_info_t * info)
{
   int i;
   const PAPI_preset_info_t *info2 = PAPI_query_all_events_verbose();

   i = EventCode & PAPI_PRESET_AND_MASK;
   if ((i >= PAPI_MAX_PRESET_EVENTS) || (info2[i].event_name == NULL))
      return(PAPI_ENOTPRESET);

   info->event_code = info2[i].event_code;
   info->count = info2[i].avail;
   if (info2[i].flags & PAPI_DERIVED) {
      info->count++;
      strcpy(info->derived, "DERIVED");
   }
   if (info2[i].event_name == NULL)  info->symbol[0] = 0;
   else strcpy(info->symbol, info2[i].event_name);
   if (info2[i].event_label == NULL)  info->short_descr[0] = 0;
   else strcpy(info->short_descr, info2[i].event_label);
   if (info2[i].event_descr == NULL)  info->long_descr[0] = 0;
   else strcpy(info->long_descr, info2[i].event_descr);
   if (info2[i].event_note == NULL)  info->note[0] = 0;
   else strcpy(info->note, info2[i].event_note);
   return(PAPI_OK);
}

/*
static int PAPI_get_multiplex(int EventSet)
{
   PAPI_option_t popt;
   int retval;

   popt.multiplex.eventset = EventSet;
   retval = PAPI_get_opt(PAPI_GET_MULTIPLEX, &popt);
   if (retval < 0)
      retval = 0;
   return retval;
}
*/

 /* New Unsupported Functions */
#define PAPIvi_get_shared_lib_info \
          PAPI_get_shared_lib_info
#define PAPIvi_get_thr_specific(tag, ptr) \
          PAPI_get_thr_specific(tag, ptr)
#define PAPIvi_num_events(EventSet) \
          PAPI_num_events(EventSet)
#define PAPIvi_register_thread \
          PAPI_register_thread
#define PAPIvi_set_thr_specific(tag, ptr) \
          PAPI_set_thr_specific(tag, ptr)

/*
* Over half of the functions in the Low Level API remain unchanged
* These are included in the macro list in case they do change in future
* revisions, and to simplify the naming conventions for writing 
* version independent PAPI code.
*/

#define PAPIvi_accum(EventSet, values) \
          PAPI_accum(EventSet, values)
#define PAPIvi_create_eventset(EventSet) \
          PAPI_create_eventset(EventSet)
#define PAPIvi_destroy_eventset(EventSet) \
          PAPI_destroy_eventset(EventSet)
#define PAPIvi_event_code_to_name(EventCode, out) \
          PAPI_event_code_to_name(EventCode, out)
#define PAPIvi_event_name_to_code(in, out) \
          PAPI_event_name_to_code(in, out)
#define PAPIvi_get_dmem_info(option) \
          PAPI_get_dmem_info(option)
#define PAPIvi_get_opt(option, ptr) \
          PAPI_get_opt(option, ptr)
#define PAPIvi_get_real_cyc \
          PAPI_get_real_cyc
#define PAPIvi_get_real_usec \
          PAPI_get_real_usec
#define PAPIvi_get_virt_cyc \
          PAPI_get_virt_cyc
#define PAPIvi_get_virt_usec \
          PAPI_get_virt_usec
#define PAPIvi_library_init(version) \
          PAPI_library_init(version)
#define PAPIvi_list_events(EventSet, Events, number) \
          PAPI_list_events(EventSet, Events, number)
#define PAPIvi_multiplex_init \
          PAPI_multiplex_init
#define PAPIvi_num_hwctrs \
          PAPI_num_hwctrs
#define PAPIvi_overflow(EventSet, EventCode, threshold, flags, handler) \
          PAPI_overflow(EventSet, EventCode, threshold, flags, handler)
#define PAPIvi_perror(code, destination, length) \
          PAPI_perror(code, destination, length)
#define PAPIvi_query_event(EventCode) \
          PAPI_query_event(EventCode)
#define PAPIvi_read(EventSet, values) \
          PAPI_read(EventSet, values)
#define PAPIvi_reset(EventSet) \
          PAPI_reset(EventSet)
#define PAPIvi_set_debug(level) \
          PAPI_set_debug(level)
#define PAPIvi_set_domain(domain) \
          PAPI_set_domain(domain)
#define PAPIvi_set_granularity(granularity) \
          PAPI_set_granularity(granularity)
#define PAPIvi_set_opt(option, ptr) \
          PAPI_set_opt(option, ptr)
#define PAPIvi_shutdown \
          PAPI_shutdown
#define PAPIvi_sprofil(prof, profcnt, EventSet, EventCode, threshold, flags) \
          PAPI_sprofil(prof, profcnt, EventSet, EventCode, threshold, flags)
#define PAPIvi_start(EventSet) \
          PAPI_start(EventSet)
#define PAPIvi_state(EventSet, status) \
          PAPI_state(EventSet, status)
#define PAPIvi_stop(EventSet, values) \
          PAPI_stop(EventSet, values)
#define PAPIvi_strerror(err) \
          PAPI_strerror(err)
#define PAPIvi_thread_id \
          PAPI_thread_id
#define PAPIvi_write(EventSet, values) \
          PAPI_write(EventSet, values)

/*
* Of the nine functions deprecated from PAPI 2 to PAPI 3,
* three (PAPI_add_pevent, PAPI_restore, and PAPI_save) were
* never implemented, and four dealt with describing events.
* Two remain:
* PAPI_get_overflow_address() must still be used in version specific overflow handlers
* PAPI_profil_hw() was rarely used, and only on platforms supporting hardware overflow.
* The prototypes of these functions are shown below for completeness.
*/
/*
int PAPI_add_pevent(int *EventSet, int code, void *inout);
void *PAPI_get_overflow_address(void *context);
int PAPI_profil_hw(unsigned short *buf, unsigned bufsiz, unsigned long offset, \
          unsigned scale, int EventSet, int EventCode, int threshold, int flags);
const PAPI_preset_info_t *PAPI_query_all_events_verbose(void);
int PAPI_describe_event(char *name, int *EventCode, char *description);
int PAPI_label_event(int EventCode, char *label);
int PAPI_query_event_verbose(int EventCode, PAPI_preset_info_t *info);
int PAPI_restore(void);
int PAPI_save(void);
*/


/*
* The High Level API
* There are 8 functions in this API.
* 6 are unchanged, and 2 are new.
* Of the new functions, one is emulated and one is unsupported.
*/

/* Unchanged Functions */
#define PAPIvi_accum_counters(values, array_len) \
          PAPI_accum_counters(values, array_len)
#define PAPIvi_num_counters \
          PAPI_num_counters
#define PAPIvi_read_counters(values, array_len) \
          PAPI_read_counters(values, array_len)
#define PAPIvi_start_counters(Events, array_len) \
          PAPI_start_counters(Events, array_len)
#define PAPIvi_stop_counters(values, array_len) \
          PAPI_stop_counters(values, array_len)
#define PAPIvi_flops(rtime, ptime, flpops, mflops) \
          PAPI_flops(rtime, ptime, flpops, mflops)

 /* New Supported Functions */
#define PAPIvi_flips(rtime, ptime, flpins, mflips) \
          PAPI_flops(rtime, ptime, flpins, mflips)

 /* New Unupported Functions */
#define PAPIvi_ipc(rtime, ptime, ins, ipc) \
          PAPI_ipc(rtime, ptime, ins, ipc)


/*******************************************************************************
* If PAPI_VERSION is defined, and the MAJOR version number is 3,
* then papi.h is for PAPI 3.
* The preprocessor block below contains definitions and macros needed to 
* allow version independent linking to the PAPI 3 library.
* Other than a handful of definitions to support calls to PAPI_{get,set}_opt(),
* this layer simply converts version independent names to PAPI 3 library calls.
********************************************************************************/
#elif (PAPI_VERSION_MAJOR(PAPI_VERSION) == 3 || PAPI_VERSION_MAJOR(PAPI_VERSION) == 4)

/*
* The following option definitions reflect the fact that PAPI 2 had separate 
* definitions for options to PAPI_set_opt and PAPI_get_opt, while PAPI 3 has
* only a single set for both. By using the older naming convention, you can 
* create platform independent code for these calls.
*/

#define PAPI_SET_DEBUG     PAPI_DEBUG
#define PAPI_GET_DEBUG     PAPI_DEBUG

#define PAPI_SET_MULTIPLEX PAPI_MULTIPLEX
#define PAPI_GET_MULTIPLEX PAPI_MULTIPLEX

#define PAPI_SET_DEFDOM    PAPI_DEFDOM
#define PAPI_GET_DEFDOM    PAPI_DEFDOM

#define PAPI_SET_DOMAIN    PAPI_DOMAIN
#define PAPI_GET_DOMAIN    PAPI_DOMAIN

#define PAPI_SET_DEFGRN    PAPI_DEFGRN
#define PAPI_GET_DEFGRN    PAPI_DEFGRN

#define PAPI_SET_GRANUL    PAPI_GRANUL
#define PAPI_GET_GRANUL    PAPI_GRANUL

#define PAPI_SET_INHERIT   PAPI_INHERIT
#define PAPI_GET_INHERIT   PAPI_INHERIT

#define PAPI_GET_NUMCTRS   PAPI_NUMCTRS
#define PAPI_SET_NUMCTRS   PAPI_NUMCTRS

#define PAPI_SET_PROFIL    PAPI_PROFIL
#define PAPI_GET_PROFIL    PAPI_PROFIL

/*
* These macros are simple pass-throughs to PAPI 3 structures
*/
#define PAPIvi_hw_info_t   PAPI_hw_info_t
#define PAPIvi_exe_info_t  PAPI_exe_info_t

/*
* The following macros are simple pass-throughs to PAPI 3 library calls
*/
 /* The Low Level API */
#define PAPIvi_accum(EventSet, values) \
          PAPI_accum(EventSet, values)
#define PAPIvi_add_event(EventSet, Event) \
          PAPI_add_event(EventSet, Event)
#define PAPIvi_add_events(EventSet, Events, number) \
          PAPI_add_events(EventSet, Events, number)
#define PAPIvi_cleanup_eventset(EventSet) \
          PAPI_cleanup_eventset(EventSet)
#define PAPIvi_create_eventset(EventSet) \
          PAPI_create_eventset(EventSet)
#define PAPIvi_destroy_eventset(EventSet) \
          PAPI_destroy_eventset(EventSet)
#define PAPIvi_enum_event(EventCode, modifier) \
          PAPI_enum_event(EventCode, modifier)
#define PAPIvi_event_code_to_name(EventCode, out) \
          PAPI_event_code_to_name(EventCode, out)
#define PAPIvi_event_name_to_code(in, out) \
          PAPI_event_name_to_code(in, out)
#define PAPIvi_get_dmem_info(option) \
          PAPI_get_dmem_info(option)
#define PAPIvi_get_event_info(EventCode, info) \
          PAPI_get_event_info(EventCode, info)
#define PAPIvi_get_executable_info \
          PAPI_get_executable_info
#define PAPIvi_get_hardware_info \
          PAPI_get_hardware_info
#define PAPIvi_get_multiplex(EventSet) \
          PAPI_get_multiplex(EventSet)
#define PAPIvi_get_opt(option, ptr) \
          PAPI_get_opt(option, ptr)
#define PAPIvi_get_real_cyc \
          PAPI_get_real_cyc
#define PAPIvi_get_real_usec \
          PAPI_get_real_usec
#define PAPIvi_get_shared_lib_info \
          PAPI_get_shared_lib_info
#define PAPIvi_get_thr_specific(tag, ptr) \
          PAPI_get_thr_specific(tag, ptr)
#define PAPIvi_get_virt_cyc \
          PAPI_get_virt_cyc
#define PAPIvi_get_virt_usec \
          PAPI_get_virt_usec
#define PAPIvi_is_initialized \
          PAPI_is_initialized
#define PAPIvi_library_init(version) \
          PAPI_library_init(version)
#define PAPIvi_list_events(EventSet, Events, number) \
          PAPI_list_events(EventSet, Events, number)
#define PAPIvi_lock(lck) \
          PAPI_lock(lck)
#define PAPIvi_multiplex_init \
          PAPI_multiplex_init
#define PAPIvi_num_hwctrs \
          PAPI_num_hwctrs
#define PAPIvi_num_events(EventSet) \
          PAPI_num_events(EventSet)
#define PAPIvi_overflow(EventSet, EventCode, threshold, flags, handler) \
          PAPI_overflow(EventSet, EventCode, threshold, flags, handler)
#define PAPIvi_perror(code, destination, length) \
          PAPI_perror(code, destination, length)
#define PAPIvi_profil(buf, bufsiz, offset, scale, EventSet, EventCode, threshold, flags) \
          PAPI_profil(buf, bufsiz, offset, scale, EventSet, EventCode, threshold, flags)
#define PAPIvi_query_event(EventCode) \
          PAPI_query_event(EventCode)
#define PAPIvi_read(EventSet, values) \
          PAPI_read(EventSet, values)
#define PAPIvi_register_thread \
          PAPI_register_thread
#define PAPIvi_remove_event(EventSet, EventCode) \
          PAPI_remove_event(EventSet, EventCode)
#define PAPIvi_remove_events(EventSet, Events, number) \
          PAPI_remove_events(EventSet, Events, number)
#define PAPIvi_reset(EventSet) \
          PAPI_reset(EventSet)
#define PAPIvi_set_debug(level) \
          PAPI_set_debug(level)
#define PAPIvi_set_domain(domain) \
          PAPI_set_domain(domain)
#define PAPIvi_set_granularity(granularity) \
          PAPI_set_granularity(granularity)
#define PAPIvi_set_multiplex(EventSet) \
          PAPI_set_multiplex(EventSet)
#define PAPIvi_set_opt(option, ptr) \
          PAPI_set_opt(option, ptr)
#define PAPIvi_set_thr_specific(tag, ptr) \
          PAPI_set_thr_specific(tag, ptr)
#define PAPIvi_shutdown \
          PAPI_shutdown
#define PAPIvi_sprofil(prof, profcnt, EventSet, EventCode, threshold, flags) \
          PAPI_sprofil(prof, profcnt, EventSet, EventCode, threshold, flags)
#define PAPIvi_start(EventSet) \
          PAPI_start(EventSet)
#define PAPIvi_state(EventSet, status) \
          PAPI_state(EventSet, status)
#define PAPIvi_stop(EventSet, values) \
          PAPI_stop(EventSet, values)
#define PAPIvi_strerror(err) \
          PAPI_strerror(err)
#define PAPIvi_thread_id \
          PAPI_thread_id
#define PAPIvi_thread_init(id_fn) \
          PAPI_thread_init(id_fn)
#define PAPIvi_unlock(lck) \
          PAPI_unlock(lck)
#define PAPIvi_write(EventSet, values) \
          PAPI_write(EventSet, values)

   /* The High Level API */

#define PAPIvi_accum_counters(values, array_len) \
          PAPI_accum_counters(values, array_len)
#define PAPIvi_num_counters \
          PAPI_num_counters
#define PAPIvi_read_counters(values, array_len) \
          PAPI_read_counters(values, array_len)
#define PAPIvi_start_counters(Events, array_len) \
          PAPI_start_counters(Events, array_len)
#define PAPIvi_stop_counters(values, array_len) \
          PAPI_stop_counters(values, array_len)
#define PAPIvi_flips(rtime, ptime, flpins, mflips) \
          PAPI_flips(rtime, ptime, flpins, mflips)
#define PAPIvi_flops(rtime, ptime, flpops, mflops) \
          PAPI_flops(rtime, ptime, flpops, mflops)
#define PAPIvi_ipc(rtime, ptime, ins, ipc) \
          PAPI_ipc(rtime, ptime, ins, ipc)


/*******************************************************************************
* If PAPI_VERSION is defined, and the MAJOR version number is not 3, then we
* generate an error message.
* This block allows us to support future version with a 
* version independent syntax.
********************************************************************************/
#else
#error Compiling against a not yet released PAPI version
#endif

#endif /* _PAPIVI */
