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

 * >>>>>> "Development of a PAPI Backend for the Sun Niagara 2 Processor" <<<<<<

 * -----------------------------------------------------------------------------

 *

 * Fabian Gorsler <fabian.gorsler@smail.inf.h-bonn-rhein-sieg.de>

 *

 *       Hochschule Bonn-Rhein-Sieg, Sankt Augustin, Germany

 *       University of Applied Sciences

 *

 * -----------------------------------------------------------------------------

 *

 * File:   solaris-niagara2.c

 * Author: fg215045

 * 

 * Description: This source file is the implementation of a PAPI 

 * component for the Sun Niagara 2 processor (aka UltraSPARC T2) 

 * running on Solaris 10 with libcpc 2. 

 * The machine for implementing this component was courtesy of RWTH 

 * Aachen University, Germany. Thanks to the HPC-Team at RWTH! 

 *

 * Conventions used:

 *  - __cpc_*: Functions, variables, etc. related to libcpc handling

 *  - __sol_*: Functions, variables, etc. related to Solaris handling

 *  - __int_*: Functions, variables, etc. related to extensions of libcpc

 *  - _niagara*: Functions, variables, etc. needed by PAPI hardware dependent

 *                 layer, i.e. the component itself

 *

 * 

 *      ***** Feel free to convert this header to the PAPI default *****

 *

 * -----------------------------------------------------------------------------

 * Created on April 23, 2009, 7:31 PM

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

#include "papi.h"

#include "papi_internal.h"

#include "papi_vector.h"

#include "solaris-niagara2.h"

#include "papi_memory.h"

#include <libcpc.h>

#include <procfs.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>

#include <strings.h>

#include <sys/lwp.h>

#include <limits.h>

#include <sys/processor.h>

#include <sys/types.h>

#include <sys/time.h>

#include <stdarg.h>

#include <libgen.h>

#include <ucontext.h>

#include <sys/regset.h>

#include <sys/utsname.h>

#include "solaris-common.h"

#include "solaris-memory.h"

#define hwd_control_state_t _niagara2_control_state_t

#define hwd_context_t       _niagara2_context_t

#define hwd_register_t      _niagara2_register_t

extern caddr_t _start, _end, _etext, _edata;

extern papi_vector_t _niagara2_vector;

/* Synthetic events */

int __int_setup_synthetic_event( int, hwd_control_state_t *, void * );

uint64_t __int_get_synthetic_event( int, hwd_control_state_t *, void * );

void __int_walk_synthetic_events_action_count( void );

void __int_walk_synthetic_events_action_store( void );

/* Simple error handlers for convenience */

#define __CHECK_ERR_DFLT(retval) \

    if(retval != 0){ SUBDBG("RETVAL: %d\n", retval); return PAPI_ECMP;}

#define __CHECK_ERR_NULL(retval) \

    if(retval == NULL){ SUBDBG("RETVAL: NULL\n"); return PAPI_ECMP;}

#define __CHECK_ERR_PAPI(retval) \

    if(retval != PAPI_OK){ SUBDBG("RETVAL: %d\n", retval); return PAPI_ECMP;}

#define __CHECK_ERR_INVA(retval) \

    if(retval != 0){ SUBDBG("RETVAL: %d\n", retval); return PAPI_EINVAL;}

#define __CHECK_ERR_NEGV(retval) \

    if(retval < 0){ SUBDBG("RETVAL: %d\n", retval); return PAPI_ECMP;}

// PAPI defined variables

extern papi_mdi_t _papi_hwi_system_info;

// The instance of libcpc

static cpc_t *cpc = NULL;

typedef struct __t2_store

{

	// Number of counters for a processing unit

	int npic;

	int *pic_ntv_count;

	int syn_evt_count;

} __t2_store_t;

static __t2_store_t __t2_store;

static char **__t2_ntv_events;

// Variables copied from the old component

static int pid;

// Data types for utility functions

typedef struct __sol_processor_information

{

	int total;

	int clock;

} __sol_processor_information_t;

typedef struct __t2_pst_table

{

	int papi_pst;

	char *ntv_event[MAX_COUNTERS];

	int ntv_ctrs;

	int ntv_opcode;

} __t2_pst_table_t;

#define SYNTHETIC_EVENTS_SUPPORTED  1

/* This table structure holds all preset events */

static __t2_pst_table_t __t2_table[] = {

	/* Presets defined by generic_events(3CPC) */

	{PAPI_L1_DCM,

	 {"DC_miss", NULL}, 1, NOT_DERIVED},

	{PAPI_L1_ICM,

	 {"IC_miss", NULL}, 1, NOT_DERIVED},

	{PAPI_L2_ICM,

	 {"L2_imiss", NULL}, 1, NOT_DERIVED},

	{PAPI_TLB_DM,

	 {"DTLB_miss", NULL}, 1, NOT_DERIVED},

	{PAPI_TLB_IM,

	 {"ITLB_miss", NULL}, 1, NOT_DERIVED},

	{PAPI_TLB_TL,

	 {"TLB_miss", NULL}, 1, NOT_DERIVED},

	{PAPI_L2_LDM,

	 {"L2_dmiss_ld", NULL}, 1, NOT_DERIVED},

	{PAPI_BR_TKN,

	 {"Br_taken", NULL}, 1, NOT_DERIVED},

	{PAPI_TOT_INS,

	 {"Instr_cnt", NULL}, 1, NOT_DERIVED},

	{PAPI_LD_INS,

	 {"Instr_ld", NULL}, 1, NOT_DERIVED},

	{PAPI_SR_INS,

	 {"Instr_st", NULL}, 1, NOT_DERIVED},

	{PAPI_BR_INS,

	 {"Br_completed", NULL}, 1, NOT_DERIVED},

	/* Presets additionally found, should be checked twice */

	{PAPI_BR_MSP,

	 {"Br_taken", NULL}, 1, NOT_DERIVED},

	{PAPI_FP_INS,

	 {"Instr_FGU_arithmetic", NULL}, 1, NOT_DERIVED},

	{PAPI_RES_STL,

	 {"Idle_strands", NULL}, 1, NOT_DERIVED},

	{PAPI_SYC_INS,

	 {"Atomics", NULL}, 1, NOT_DERIVED},

	{PAPI_L2_ICR,

	 {"CPU_ifetch_to_PCX", NULL}, 1, NOT_DERIVED},

	{PAPI_L1_TCR,

	 {"CPU_ld_to_PCX", NULL}, 1, NOT_DERIVED},

	{PAPI_L2_TCW,

	 {"CPU_st_to_PCX", NULL}, 1, NOT_DERIVED},

	/* Derived presets found, should be checked twice */

	{PAPI_L1_TCM,

	 {"IC_miss", "DC_miss"}, 2, DERIVED_ADD},

	{PAPI_BR_CN,

	 {"Br_completed", "Br_taken"}, 2, DERIVED_ADD},

	{PAPI_BR_PRC,

	 {"Br_completed", "Br_taken"}, 2, DERIVED_SUB},

	{PAPI_LST_INS,

	 {"Instr_st", "Instr_ld"}, 2, DERIVED_ADD},

#ifdef SYNTHETIC_EVENTS_SUPPORTED

	/* This preset does exist in order to support multiplexing */

	{PAPI_TOT_CYC,

	 {"_syn_cycles_elapsed", "DC_miss"}, 1, NOT_DERIVED},

#endif

	{0,

	 {NULL, NULL}, 0, 0},

};

hwi_search_t *preset_table;

#ifdef SYNTHETIC_EVENTS_SUPPORTED

enum

{

	SYNTHETIC_CYCLES_ELAPSED = 1,

	SYNTHETIC_RETURN_ONE,

	SYNTHETIC_RETURN_TWO,

} __int_synthetic_enum;

#endif

#ifdef SYNTHETIC_EVENTS_SUPPORTED

typedef struct __int_synthetic_table

{

	int code;

	char *name;

} __int_syn_table_t;

#endif

#ifdef SYNTHETIC_EVENTS_SUPPORTED

static __int_syn_table_t __int_syn_table[] = {

	{SYNTHETIC_CYCLES_ELAPSED, "_syn_cycles_elapsed"},

	{SYNTHETIC_RETURN_ONE, "_syn_return_one"},

	{SYNTHETIC_RETURN_TWO, "_syn_return_two"},

	{-1, NULL},

};

#endif

////////////////////////////////////////////////////////////////////////////////

/// PAPI HWD LAYER RELATED FUNCTIONS ///////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////

/* DESCRIPTION:

 * -----------------------------------------------------------------------------

 * Functions in this section are related to the PAPI hardware dependend layer,

 * also known as "HWD". In this case the HWD layer is the interface from PAPI

 * to libcpc 2/Solaris 10.

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

int

_niagara2_set_domain( hwd_control_state_t * ctrl, int domain )

{

	int i;

#ifdef DEBUG

	SUBDBG( "ENTERING FUNCTION >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	/* Clean and set the new flag for each counter */

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

#ifdef DEBUG

		SUBDBG( " -> %s: Setting flags for PIC#%d, old value: %p\n",

				__func__, i, ctrl->flags[i] );

#endif

		ctrl->flags[i] &= ~( CPC_COUNTING_DOMAINS );

#ifdef DEBUG

		SUBDBG( " -> %s: +++                      cleaned value: %p\n",

				__func__, ctrl->flags[i] );

#endif

		ctrl->flags[i] |= __cpc_domain_translator( domain );

#ifdef DEBUG

		SUBDBG( " -> %s: +++                      new value: %p\n",

				__func__, ctrl->flags[i] );

#endif

	}

	/* Recreate the set */

	__CHECK_ERR_PAPI( __cpc_recreate_set( ctrl ) );

#ifdef DEBUG

	SUBDBG( "LEAVING FUNCTION  >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	return PAPI_OK;

}

int

_niagara2_ctl( hwd_context_t * ctx, int code, _papi_int_option_t * option )

{

#ifdef DEBUG

	SUBDBG( "ENTERING FUNCTION >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

	SUBDBG( " -> %s: Option #%d requested\n", __func__, code );

#endif

	/* Only these options are handled which are handled in PAPI_set_opt, as many

	   of the left out options are not settable, like PAPI_MAX_CPUS. */

	switch ( code ) {

	case PAPI_DEFDOM:

		/* From papi.h: Domain for all new eventsets. Takes non-NULL option

		   pointer. */

		_niagara2_vector.cmp_info.default_domain = option->domain.domain;

		return PAPI_OK;

	case PAPI_DOMAIN:

		/* From papi.h: Domain for an eventset */

		return _niagara2_set_domain( ctx, option->domain.domain );

	case PAPI_DEFGRN:

		/* From papi.h: Granularity for all new eventsets */

		_niagara2_vector.cmp_info.default_granularity =

			option->granularity.granularity;

		return PAPI_OK;

	case PAPI_GRANUL:

		/* From papi.h: Granularity for an eventset */

		/* Only supported granularity is PAPI_GRN_THREAD */

		return PAPI_OK;

	case PAPI_DEF_MPX_NS:

		/* From papi.h: Multiplexing/overflowing interval in ns, same as

		   PAPI_DEF_ITIMER_NS */

		/* From the old component */

		option->itimer.ns = __sol_get_itimer_ns( option->itimer.ns );

#ifdef DEBUG

		SUBDBG( " -> %s: PAPI_DEF_MPX_NS, option->itimer.ns=%d\n",

				__func__, option->itimer.ns );

#endif

		return PAPI_OK;

	case PAPI_DEF_ITIMER:	 // IN THE OLD COMPONENT // USED

		/* From papi.h: Option to set the type of itimer used in both software

		   multiplexing, overflowing and profiling */

		/* These tests are taken from the old component. For Solaris 10 the

		   same rules apply as documented in getitimer(2). */

		if ( ( option->itimer.itimer_num == ITIMER_REAL ) &&

			 ( option->itimer.itimer_sig != SIGALRM ) ) {

#ifdef DEBUG

			SUBDBG( " -> %s: PAPI_DEF_ITIMER, ITIMER_REAL needs SIGALRM\n",

					__func__ );

#endif

			return PAPI_EINVAL;

		}

		if ( ( option->itimer.itimer_num == ITIMER_VIRTUAL ) &&

			 ( option->itimer.itimer_sig != SIGVTALRM ) ) {

#ifdef DEBUG

			SUBDBG( " -> %s: PAPI_DEF_ITIMER, ITIMER_VIRTUAL needs SIGVTALRM\n",

					__func__ );

#endif

			return PAPI_EINVAL;

		}

		if ( ( option->itimer.itimer_num == ITIMER_PROF ) &&

			 ( option->itimer.itimer_sig != SIGPROF ) ) {

#ifdef DEBUG

			SUBDBG( " -> %s: PAPI_DEF_ITIMER, ITIMER_PROF needs SIGPROF\n",

					__func__ );

#endif

			return PAPI_EINVAL;

		}

		/* As in the old component defined, timer values below 0 are NOT

		   filtered out, but timer values greater than 0 are rounded, either to

		   a value which is at least itimer_res_ns or padded to a multiple of

		   itimer_res_ns. */

		if ( option->itimer.ns > 0 ) {

			option->itimer.ns = __sol_get_itimer_ns( option->itimer.ns );

#ifdef DEBUG

			SUBDBG( " -> %s: PAPI_DEF_ITIMER, option->itimer.ns=%d\n",

					__func__, option->itimer.ns );

#endif

		}

		return PAPI_OK;

	case PAPI_DEF_ITIMER_NS:	// IN THE OLD COMPONENT // USED

		/* From papi.h: Multiplexing/overflowing interval in ns, same as

		   PAPI_DEF_MPX_NS */

		/* From the old component */

		option->itimer.ns = __sol_get_itimer_ns( option->itimer.ns );

#ifdef DEBUG

		SUBDBG( " -> %s: PAPI_DEF_ITIMER_NS, option->itimer.ns=%d\n",

				__func__, option->itimer.ns );

#endif

		return PAPI_OK;

	}

#ifdef DEBUG

	SUBDBG( " -> %s: Option not found\n", __func__ );

	SUBDBG( "LEAVING FUNCTION  >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	/* This place should never be reached */

	return PAPI_EINVAL;

}

void

_niagara2_dispatch_timer( int signal, siginfo_t * si, void *info )

{

	EventSetInfo_t *ESI = NULL;

	ThreadInfo_t *thread = NULL;

	int overflow_vector = 0;

	hwd_control_state_t *ctrl = NULL;

	long_long results[MAX_COUNTERS];

	int i;

	// Hint from perf_events.c

	int cidx = _niagara2_vector.cmp_info.CmpIdx;

#ifdef DEBUG

	SUBDBG( "ENTERING FUNCTION >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

	SUBDBG( " -> %s: Overflow handler called by signal #%d\n", __func__,

			signal );

#endif

	/* From the old component */

	thread = _papi_hwi_lookup_thread( 0 );

	ESI = ( EventSetInfo_t * ) thread->running_eventset[cidx];

	/* From the old component, modified */

	// 

	if ( ESI == NULL || ESI->master != thread || ESI->ctl_state == NULL ||

		 ( ( ESI->state & PAPI_OVERFLOWING ) == 0 ) ) {

#ifdef DEBUG

		SUBDBG( " -> %s: Problems with ESI, not necessarily serious\n",

				__func__ );

		if ( ESI == NULL ) {

			SUBDBG( " -> %s: +++ ESI is NULL\n", __func__ );

		}

		if ( ESI->master != thread ) {

			SUBDBG( " -> %s: +++ Thread mismatch, ESI->master=%#x thread=%#x\n",

					__func__, ESI->master, thread );

		}

		if ( ESI->ctl_state == NULL ) {

			SUBDBG( " -> %s: +++ Counter state invalid\n", __func__ );

		}

		if ( ( ( ESI->state & PAPI_OVERFLOWING ) == 0 ) ) {

			SUBDBG

				( " -> %s: +++ Overflow flag missing, ESI->overflow.flags=%#x\n",

				  __func__, ESI->overflow.flags );

		}

#endif

		return;

	}

#ifdef DEBUG

	printf( " -> %s: Preconditions valid, trying to read counters\n",

			__func__ );

#endif

	ctrl = ESI->ctl_state;

	if ( _niagara2_read

		 ( ctrl, ctrl, ( long_long ** ) & results, NOT_A_PAPI_HWD_READ )

		 != PAPI_OK ) {

		/* Failure */

#ifdef DEBUG

		printf( "%s: Failed to read counters\n", __func__ );

#endif

		return;

	} else {

		/* Success */

#ifdef DEBUG

		SUBDBG( " -> %s: Counters read\n", __func__ );

#endif

		/* Iterate over all available counters in order to detect which counter

		   overflowed (counter value should be 0 if an hw overflow happened),

		   store the position in the overflow_vector, calculte the offset and

		   shift (value range signed long long vs. unsigned long long). */

		for ( i = 0; i < ctrl->count; i++ ) {

			if ( results[i] >= 0 ) {

#ifdef DEBUG

				SUBDBG( " -> %s: Overflow detected at PIC #%d\n", __func__, i );

#endif

				/* Set the bit in the overflow_vector */

				overflow_vector = overflow_vector | ( 1 << i );

				/* hoose which method to use depending on the overflow signal. */

				if ( signal == SIGEMT ) {

					/* Store the counter value, but only if we have a real *

					   hardware overflow counting with libcpc/SIGEMT. */

					ctrl->preset[i] = UINT64_MAX - ctrl->threshold[i];

					ctrl->hangover[i] += ctrl->threshold[i];

				} else {

					/* Push the value back, this time PAPI does the work. This is

					   software overflow handling. */

					cpc_request_preset( cpc, ctrl->idx[i], ctrl->result[i] );

				}

			} else {

#ifdef DEBUG

				SUBDBG( " -> %s: No overflow detected at PIC #%d, value=%ld\n",

						__func__, i, results[i] );

#endif

				/* Save the results read from the counter as we can not store the

				   temporary value in hardware or libcpc. */

				if ( signal == SIGEMT ) {

					ctrl->preset[i] += results[i];

					ctrl->hangover[i] = results[i];

				}

			}

		}

#ifdef DEBUG

		SUBDBG( " -> %s: Restarting set to push values back\n", __func__ );

#endif

		/* Push all values back to the counter as preset */

		cpc_set_restart( cpc, ctrl->set );

	}

#ifdef DEBUG

	SUBDBG( " -> %s: Passing overflow to PAPI with overflow_vector=%p\n",

			__func__, overflow_vector );

#endif

	{

		/* hw is used as pointer in the dispatching routine of PAPI and might be

		   changed. For safety it is not a pseudo pointer to NULL. */

		int hw;

		if ( signal == SIGEMT ) {

			/* This is a hardware overflow */

			hw = 1;

			_papi_hwi_dispatch_overflow_signal( ctrl, ( caddr_t )

												_niagara2_get_overflow_address

												( info ), &hw, overflow_vector,

												1, &thread, ESI->CmpIdx );

		} else {

			/* This is a software overflow */

			hw = 0;

			_papi_hwi_dispatch_overflow_signal( ctrl, ( caddr_t )

												_niagara2_get_overflow_address

												( info ), &hw, overflow_vector,

												1, &thread, ESI->CmpIdx );

		}

	}

#ifdef DEBUG

	SUBDBG( "LEAVING FUNCTION  >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

}

static inline void *

_niagara2_get_overflow_address( void *context )

{

	ucontext_t *ctx = ( ucontext_t * ) context;

#ifdef DEBUG

	SUBDBG( "ENTERING/LEAVING FUNCTION >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	return ( void * ) ctx->uc_mcontext.gregs[REG_PC];

}

/** Although the created set in this function will be destroyed by 

 * _papi_update_control_state later, at least the functionality of the

 * underlying CPU driver will be tested completly.

 */

int

_niagara2_init_control_state( hwd_control_state_t * ctrl )

{

	int i;

#ifdef DEBUG

	SUBDBG( "ENTERING FUNCTION >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	// cpc_seterrhndlr(cpc, myapp_errfn);

	/* Clear the buffer */

	if ( ctrl->counter_buffer != NULL ) {

#ifdef DEBUG

		SUBDBG( " -> %s: Cleaning buffer\n", __func__ );

#endif

		cpc_buf_destroy( cpc, ctrl->counter_buffer );

		ctrl->counter_buffer = NULL;

	}

	/* Clear the set */

	if ( ctrl->set != NULL ) {

#ifdef DEBUG

		SUBDBG( " -> %s: Cleaning set\n", __func__ );

#endif

		cpc_set_destroy( cpc, ctrl->set );

		ctrl->set = NULL;

	}

	/* Indicate this idx has no request associated, this counter is unused. */

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

#ifdef DEBUG

		SUBDBG( " -> %s: Cleaning counter state #%d\n", __func__, i );

#endif

		/* Indicate missing setup values */

		ctrl->idx[i] = EVENT_NOT_SET;

		ctrl->code[i].event_code = EVENT_NOT_SET;

		/* No flags yet set, this is for overflow and binding */

		ctrl->flags[i] = 0;

		/* Preset value for counting results */

		ctrl->preset[i] = DEFAULT_CNTR_PRESET;

		/* Needed for overflow handling, will be set later */

		ctrl->threshold[i] = 0;

		ctrl->hangover[i] = 0;

#ifdef SYNTHETIC_EVENTS_SUPPORTED

		ctrl->syn_hangover[i] = 0;

#endif

	}

	/* No counters active in this set */

	ctrl->count = 0;

#ifdef SYNTHETIC_EVENTS_SUPPORTED

	ctrl->syn_count = 0;

#endif

#ifdef DEBUG

	SUBDBG( "LEAVING FUNCTION  >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	return PAPI_OK;

}

int

_niagara2_init_component( int cidx )

{

#ifdef DEBUG

	SUBDBG( "ENTERING FUNCTION >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	/* Create an instance of libcpc */

#ifdef DEBUG

	SUBDBG( " -> %s: Trying to initalize libcpc\n", __func__ );

#endif

	cpc = cpc_open( CPC_VER_CURRENT );

	__CHECK_ERR_NULL( cpc );

#ifdef DEBUG

	SUBDBG( " -> %s: Registering libcpc error handler\n", __func__ );

#endif

	cpc_seterrhndlr( cpc, __cpc_error_handler );

#ifdef DEBUG

	SUBDBG( " -> %s: Detecting supported PICs", __func__ );

#endif

	__t2_store.npic = cpc_npic( cpc );

#ifdef DEBUG

	SUBDBG( " -> %s: Storing component index, cidx=%d\n", __func__, cidx );

#endif

	_niagara2_vector.cmp_info.CmpIdx = cidx;

#ifdef DEBUG

	SUBDBG( " -> %s: Gathering system information for PAPI\n", __func__ );

#endif

	/* Store system info in central data structure */

	__CHECK_ERR_PAPI( _niagara2_get_system_info( &_papi_hwi_system_info ) );

#ifdef DEBUG

	SUBDBG( " -> %s: Initializing locks\n", __func__ );

#endif

	/* Set up the lock after initialization */

	_niagara2_lock_init(  );

	// Copied from the old component, _papi_init_component()

	SUBDBG( "Found %d %s %s CPUs at %d Mhz.\n",

			_papi_hwi_system_info.hw_info.totalcpus,

			_papi_hwi_system_info.hw_info.vendor_string,

			_papi_hwi_system_info.hw_info.model_string,

			_papi_hwi_system_info.hw_info.cpu_max_mhz );

	/* Build native event table */

#ifdef DEBUG

	SUBDBG( " -> %s: Building native event table\n", __func__ );

#endif

	__CHECK_ERR_PAPI( __cpc_build_ntv_table(  ) );

	/* Build preset event table */

#ifdef DEBUG

	SUBDBG( " -> %s: Building PAPI preset table\n", __func__ );

#endif

	__CHECK_ERR_PAPI( __cpc_build_pst_table(  ) );

	/* Register presets and finish event related setup */

#ifdef DEBUG

	SUBDBG( " -> %s: Registering presets in PAPI\n", __func__ );

#endif

	__CHECK_ERR_PAPI( _papi_hwi_setup_all_presets( preset_table, NULL ) );

#ifdef DEBUG

	SUBDBG( "LEAVING FUNCTION  >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	/* Everything is ok */

	return PAPI_OK;

}

static void

_niagara2_lock_init( void )

{

#ifdef DEBUG

	SUBDBG( "ENTERING FUNCTION >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	/* Copied from old component, lock_init() */

	memset( lock, 0x0, sizeof ( rwlock_t ) * PAPI_MAX_LOCK );

#ifdef DEBUG

	SUBDBG( "LEAVING FUNCTION  >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

}

int

_niagara2_ntv_code_to_bits( unsigned int EventCode, hwd_register_t * bits )

{

	int event_code = EventCode & PAPI_NATIVE_AND_MASK;

#ifdef DEBUG

	SUBDBG( "ENTERING FUNCTION >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	if ( event_code >= 0 &&

		 event_code <= _niagara2_vector.cmp_info.num_native_events ) {

		return PAPI_ENOEVNT;

	}

	bits->event_code = event_code;

#ifdef DEBUG

	SUBDBG( "LEAVING FUNCTION  >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	return PAPI_OK;

}

int

_niagara2_ntv_code_to_descr( unsigned int EventCode, char *ntv_descr, int len )

{

#ifdef DEBUG

	SUBDBG( "ENTERING/LEAVING FUNCTION >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	/* libcpc offers no descriptions, just a link to the reference manual */

	return _niagara2_ntv_code_to_name( EventCode, ntv_descr, len );

}

int

_niagara2_ntv_code_to_name( unsigned int EventCode, char *ntv_name, int len )

{

	int event_code = EventCode & PAPI_NATIVE_AND_MASK;

#ifdef DEBUG

	SUBDBG( "ENTERING FUNCTION >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	if ( event_code >= 0 &&

		 event_code <= _niagara2_vector.cmp_info.num_native_events ) {

		strlcpy( ntv_name, __t2_ntv_events[event_code], len );

		if ( strlen( __t2_ntv_events[event_code] ) > len - 1 ) {

#ifdef DEBUG

			SUBDBG( "LEAVING FUNCTION  >>%s<< at %s:%d\n", __func__, __FILE__,

					__LINE__ );

#endif

			/* It's not a real error, but at least a hint */

			return PAPI_EBUF;

		}

#ifdef DEBUG

		SUBDBG( "LEAVING FUNCTION  >>%s<< at %s:%d\n", __func__, __FILE__,

				__LINE__ );

#endif

		return PAPI_OK;

	}

#ifdef DEBUG

	SUBDBG( "LEAVING FUNCTION  >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	return PAPI_ENOEVNT;

}

int

_niagara2_ntv_enum_events( unsigned int *EventCode, int modifier )

{

	/* This code is very similar to the code from the old component. */

	int event_code = *EventCode & PAPI_NATIVE_AND_MASK;

#ifdef DEBUG

	SUBDBG( "ENTERING FUNCTION >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	if ( modifier == PAPI_ENUM_FIRST ) {

		*EventCode = PAPI_NATIVE_MASK + 1;

#ifdef DEBUG

		SUBDBG( "LEAVING FUNCTION  >>%s<< at %s:%d\n", __func__, __FILE__,

				__LINE__ );

#endif

		return PAPI_OK;

	}

	/* The table needs to be shifted by one position (starting index 1), as PAPI

	   expects native event codes not to be 0 (papi_internal.c:744). */

	if ( event_code >= 1 &&

		 event_code <= _niagara2_vector.cmp_info.num_native_events - 1 ) {

		*EventCode = *EventCode + 1;

#ifdef DEBUG

		SUBDBG( "LEAVING FUNCTION  >>%s<< at %s:%d\n", __func__, __FILE__,

				__LINE__ );

#endif

		return PAPI_OK;

	}

#ifdef DEBUG

	SUBDBG( "LEAVING FUNCTION  >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

#endif

	// If nothing found report an error

	return PAPI_ENOEVNT;

}

int

_niagara2_read( hwd_context_t * ctx, hwd_control_state_t * ctrl,

				long_long ** events, int flags )

{

	int i;

#ifdef DEBUG

	SUBDBG( "ENTERING FUNCTION >>%s<< at %s:%d\n", __func__, __FILE__,

			__LINE__ );

	SUBDBG( " -> %s: called with flags=%p\n", __func__, flags );

#endif

	/* Take a new sample from the PIC to the buffer */

	__CHECK_ERR_DFLT( cpc_set_sample( cpc, ctrl->set, ctrl->counter_buffer ) );