/****************************/

/* THIS IS OPEN SOURCE CODE */

/****************************/

/* 

* File:    papivi.h

* CVS:     $Id$

* 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 CPUs in an SMP Node */

	int nnodes;						   /* Number of Nodes in the entire system */

	int totalcpus;					   /* Total number of CPUs 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( s ) \

          PAPI_perror( s )

#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)

/*

* 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( s ) \

          PAPI_perror( s )

#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 */