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

/* THIS IS OPEN SOURCE CODE */

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

/*

* File:    papi_internal.c

*

* Author:  Philip Mucci

*          mucci@cs.utk.edu

* Mods:    dan terpstra

*          terpstra@cs.utk.edu

* Mods:    Min Zhou

*          min@cs.utk.edu

* Mods:    Kevin London

*	   london@cs.utk.edu

* Mods:    Per Ekman

*          pek@pdc.kth.se

* Mods:    Haihang You

*          you@cs.utk.edu

* Mods:    Maynard Johnson

*          maynardj@us.ibm.com

* Mods:    Brian Sheely

*          bsheely@eecs.utk.edu

* Mods:    <Gary Mohr>

*          <gary.mohr@bull.com>

* Mods:    <your name here>

*          <your email address>

*/

#include <stdarg.h>

#include <stdio.h>

#include <errno.h>

#include <string.h>

#include <ctype.h>

#include <assert.h>

#include "papi.h"

#include "papi_internal.h"

#include "papi_vector.h"

#include "papi_memory.h"

#include "sw_multiplex.h"

#include "extras.h"

#include "papi_preset.h"

#include "cpus.h"

#include "papi_common_strings.h"

/* Advanced definitons */

static int default_debug_handler( int errorCode );

static long long handle_derived( EventInfo_t * evi, long long *from );

/* Global definitions used by other files */

int init_level = PAPI_NOT_INITED;

int _papi_hwi_error_level = PAPI_QUIET;

PAPI_debug_handler_t _papi_hwi_debug_handler = default_debug_handler;

papi_mdi_t _papi_hwi_system_info;

int _papi_hwi_errno = PAPI_OK;

int _papi_hwi_num_errors = 0;

hwi_presets_t user_defined_events[PAPI_MAX_USER_EVENTS];

int user_defined_events_count = 0;

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

/* Native Event Mapping Code */

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

#define NATIVE_EVENT_CHUNKSIZE 1024

struct native_event_info {

  int cidx;

  int component_event;

  int ntv_idx;

  char *evt_name;

};

// The following array is indexed by the papi event code (after the native bit has been removed)

static struct native_event_info *_papi_native_events=NULL;

static int num_native_events=0;

static int num_native_chunks=0;

char **_papi_errlist= NULL;

static int num_error_chunks = 0;

// pointer to event:mask string associated with last enum call to a components

// will be NULL for non libpfm4 components

// this is needed because libpfm4 event codes and papi event codes do not contain mask information

char *papi_event_string = NULL;

void

_papi_hwi_set_papi_event_string (const char *event_string) {

	INTDBG("event_string: %s\n", event_string);

	if (papi_event_string != NULL) {

		free (papi_event_string);

		papi_event_string = NULL;

	}

	if (event_string != NULL) {

		papi_event_string = strdup(event_string);

	}

	return;

}

char *

_papi_hwi_get_papi_event_string () {

	INTDBG("papi_event_string: %s\n", papi_event_string);

	return papi_event_string;

}

void

_papi_hwi_free_papi_event_string() {

	if (papi_event_string != NULL) {

		free(papi_event_string);

		papi_event_string = NULL;

	}

	return;

}

// A place to keep the current papi event code so some component functions can fetch its value

// The current event code can be stored here prior to component calls and cleared after the component returns

static THREAD_LOCAL_STORAGE_KEYWORD unsigned int papi_event_code = -1;

static THREAD_LOCAL_STORAGE_KEYWORD int papi_event_code_changed = -1;

void

_papi_hwi_set_papi_event_code (unsigned int event_code, int update_flag) {

	INTDBG("new event_code: %#x, update_flag: %d, previous event_code: %#x\n", event_code, update_flag, papi_event_code);

	// if call is just to reset and start over, set both flags to show nothing saved yet

	if (update_flag < 0) {

		papi_event_code_changed = -1;

		papi_event_code = -1;

		return;

	}

	// if 0, it is being set prior to calling a component, if >0 it is being changed by the component

	papi_event_code_changed = update_flag;

	// save the event code passed in

	papi_event_code = event_code;

	return;

}

unsigned int

_papi_hwi_get_papi_event_code () {

	INTDBG("papi_event_code: %#x\n", papi_event_code);

	return papi_event_code;

}

/* Get the index into the ESI->NativeInfoArray for the current PAPI event code */

int

_papi_hwi_get_ntv_idx (unsigned int papi_evt_code) {

	INTDBG("ENTER: papi_evt_code: %#x\n", papi_evt_code);

	int result;

	int event_index;

	if (papi_evt_code == 0) {

		INTDBG("EXIT: PAPI_ENOEVNT, invalid papi event code\n");

		return PAPI_ENOEVNT;

	}

	event_index=papi_evt_code&PAPI_NATIVE_AND_MASK;

	if ((event_index<0) || (event_index>=num_native_events)) {

		INTDBG("EXIT: PAPI_ENOEVNT, invalid index into native event array\n");

		return PAPI_ENOEVNT;

	}

	result=_papi_native_events[event_index].ntv_idx;

	INTDBG("EXIT: result: %d\n", result);

	return result;

}

//

// Check for the presence of a component name or pmu name in the event string.

// If found check if it matches this component or one of the pmu's supported by this component.

//

// returns true if the event could be for this component and false if it is not for this component.

//    if there is no component or pmu name then it could be for this component and returns true.

//

static int

is_supported_by_component(int cidx, char *event_name) {

	INTDBG("ENTER: cidx: %d, event_name: %s\n", cidx, event_name);

	int i;

	int component_name = 0;

	int pmu_name = 0;

	char *wptr = NULL;

	// if event does not have a component name or pmu name, return to show it could be supported by this component

	// when component and pmu names are not provided, we just have to call the components to see if they recognize the event

	//

	// look for component names first

	if ((wptr = strstr(event_name, ":::")) != NULL) {

		component_name = 1;

	} else if ((wptr = strstr(event_name, "::")) != NULL) {

		pmu_name = 1;

	} else {

		INTDBG("EXIT: No Component or PMU name in event string, try this component\n");

		// need to force all components to be called to find owner of this event

		// ????  can we assume the default pmu when no component or pmu name is provided ????

		return 1;

	}

	// get a temporary copy of the component or pmu name

	int name_len = wptr - event_name;

	wptr = strdup(event_name);

	wptr[name_len] = '\0';

	// if a component name was found, compare it to the component name in the component info structure

	if (component_name) {

//		INTDBG("component_name: %s\n", _papi_hwd[cidx]->cmp_info.name);

		if (strcmp (wptr, _papi_hwd[cidx]->cmp_info.name) == 0) {

			free (wptr);

			INTDBG("EXIT: Component %s supports this event\n", _papi_hwd[cidx]->cmp_info.name);

			return 1;

		}

	}

	// if a pmu name was found, compare it to the pmu name list if the component info structure (if there is one)

	if (pmu_name) {

		for ( i=0 ; i

			if (_papi_hwd[cidx]->cmp_info.pmu_names[i] == NULL) {

				continue;

			}

//			INTDBG("pmu_name[%d]: %p (%s)\n", i, _papi_hwd[cidx]->cmp_info.pmu_names[i], _papi_hwd[cidx]->cmp_info.pmu_names[i]);

			if (strcmp (wptr, _papi_hwd[cidx]->cmp_info.pmu_names[i]) == 0) {

				INTDBG("EXIT: Component %s supports PMU %s and this event\n", _papi_hwd[cidx]->cmp_info.name, wptr);

				free (wptr);

				return 1;

			}

		}

	}

	free (wptr);

	INTDBG("EXIT: Component does not support this event\n");

	return 0;

}

/** @internal

 * @class _papi_hwi_prefix_component_name

 * @brief Prefixes a component's name to each of its events. 

 * @param *component_name

 * @param *event_name

 * @param *out

 * @param *out_len

 *

 * Given sane component_name and event_name it returns component_name:::event_name. 

 * It is safe in the case that event_name == out and it checks against the 

 * traditional PAPI 'cpu' components, opting to not prepend those. 

 */

int

_papi_hwi_prefix_component_name( char *component_name, char *event_name, char *out, int out_len) 

{

	int size1, size2;

	char temp[out_len];

	size1 = strlen(event_name);

	size2 = strlen(component_name);

/* sanity checks */

	if ( size1 == 0 ) {

		return (PAPI_EBUG); /* hopefully event_name always has length?! */

	}	

	if ( size1 >= out_len )

		return (PAPI_ENOMEM);

/* Guard against event_name == out */

	memcpy( temp, event_name, out_len );

/* no component name to prefix */

	if ( size2 == 0 ) {

		sprintf(out, "%s%c", temp, '\0' );

		return (PAPI_OK);

	}

/* Don't prefix 'cpu' component names for now */

	if ( strstr(component_name, "pe") ||

		 strstr(component_name, "bgq") ||

		 strstr(component_name, "bgp") ) {

		sprintf( out, "%s%c", temp, '\0'); 

		return (PAPI_OK);

	}

/* strlen(component_name) + ::: + strlen(event_name) + NULL */

	if ( size1+size2+3+1 > out_len )

		return (PAPI_ENOMEM);

	sprintf( out, "%s:::%s%c" , component_name, temp, '\0');

	return (PAPI_OK);

}

/** @internal

 *  @class _papi_hwi_strip_component_prefix

 *  @brief Strip off cmp_name::: from an event name. 

 *

 *  @param *event_name

 *  @return Start of the component consumable portion of the name. 

 *

 *  This function checks specifically for ':::' and will return the start of 

 *  event_name if it doesn't find the ::: .

 */

const char *_papi_hwi_strip_component_prefix(const char *event_name)

{

	const char *start = NULL;

/* We assume ::: is the seperator 

 * eg: 

 * 		papi_component:::event_name 

 */

	start = strstr( event_name, ":::" );

	if ( start != NULL )

		start+= 3; /* return the actual start of event_name */

	else

		start = event_name;

	return (start);

}

/* find the papi event code (4000xxx) associated with the specified component, native event, and event name */

static int

_papi_hwi_find_native_event(int cidx, int event, const char *event_name) {

  INTDBG("ENTER: cidx: %x, event: %#x, event_name: %s\n", cidx, event, event_name);

  int i;

  // if no event name passed in, it can not be found

  if (event_name == NULL) {

		INTDBG("EXIT: PAPI_ENOEVNT\n");

		return PAPI_ENOEVNT;

  }

  for(i=0;i

  	// if we have have not set up this event name yet, look at next

  	if (_papi_native_events[i].evt_name == NULL) {

  		continue;

  	}

  	// is this entry for the correct component and event code

  	if ((_papi_native_events[i].cidx==cidx) &&

	(_papi_native_events[i].component_event==event)) {

		// if this event name matches what we want, return its papi event code

		if (strcmp(event_name, _papi_native_events[i].evt_name) == 0) {

			INTDBG("EXIT: event: %#x, component_event: %#x, ntv_idx: %d, event_name: %s\n",

				i|PAPI_NATIVE_MASK, _papi_native_events[i].component_event, _papi_native_events[i].ntv_idx, _papi_native_events[i].evt_name);

			return i|PAPI_NATIVE_MASK;

		}

    }

  }

	INTDBG("EXIT: PAPI_ENOEVNT\n");

	return PAPI_ENOEVNT;

}

static int

_papi_hwi_add_native_event(int cidx, int ntv_event, int ntv_idx, const char *event_name) {

	INTDBG("ENTER: cidx: %d, ntv_event: %#x, ntv_idx: %d, event_name: %s\n", cidx, ntv_event, ntv_idx, event_name);

  int new_native_event;

  _papi_hwi_lock( INTERNAL_LOCK );

  if (num_native_events>=num_native_chunks*NATIVE_EVENT_CHUNKSIZE) {

     num_native_chunks++;

     _papi_native_events=(struct native_event_info *) realloc(_papi_native_events,

				 num_native_chunks*NATIVE_EVENT_CHUNKSIZE*

				 sizeof(struct native_event_info));

     if (_papi_native_events==NULL) {

        new_native_event=PAPI_ENOMEM;

	goto native_alloc_early_out;

     }

  }

  _papi_native_events[num_native_events].cidx=cidx;

  _papi_native_events[num_native_events].component_event=ntv_event;

  _papi_native_events[num_native_events].ntv_idx=ntv_idx;

  if (event_name != NULL) {

	  _papi_native_events[num_native_events].evt_name=strdup(event_name);

  } else {

	  _papi_native_events[num_native_events].evt_name=NULL;

  }

  new_native_event=num_native_events|PAPI_NATIVE_MASK;

  num_native_events++;

native_alloc_early_out:

  _papi_hwi_unlock( INTERNAL_LOCK );

  INTDBG("EXIT: new_native_event: %#x, num_native_events: %d\n", new_native_event, num_native_events);

  return new_native_event;

}

/** @internal

 * @class _papi_hwi_add_error

 *

 * Adds a new error string to PAPI's internal store.

 * MAKE SURE you are not holding INTERNAL_LOCK when you call me!

 */ 

static int

_papi_hwi_add_error( char *error )

{

	INTDBG("Adding a new Error message |%s|\n", error);

	_papi_hwi_lock(INTERNAL_LOCK);

	if (_papi_hwi_num_errors >= num_error_chunks*NATIVE_EVENT_CHUNKSIZE) {

		num_error_chunks++;

		_papi_errlist= (char **) realloc(_papi_errlist, 

						num_error_chunks*NATIVE_EVENT_CHUNKSIZE*sizeof(char *));

		if (_papi_errlist==NULL) {

			_papi_hwi_num_errors = -2;

			goto bail;

		}

	}

	_papi_errlist[_papi_hwi_num_errors] = strdup( error );

	if ( _papi_errlist[_papi_hwi_num_errors] == NULL )

		_papi_hwi_num_errors = -2;

bail:

	_papi_hwi_unlock(INTERNAL_LOCK);

	return _papi_hwi_num_errors++;

}

static void

_papi_hwi_cleanup_errors()

{

	int i; 

	if ( _papi_errlist == NULL || 

			_papi_hwi_num_errors == 0 )

		return; 

	_papi_hwi_lock( INTERNAL_LOCK );

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

		free( _papi_errlist[i]);

		_papi_errlist[i] = NULL;

	} 

	free( _papi_errlist );

	_papi_errlist = NULL;

	_papi_hwi_num_errors = 0;

	num_error_chunks=0;

	_papi_hwi_unlock( INTERNAL_LOCK );

}

static int

_papi_hwi_lookup_error( char *error ) 

{

	int i;

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

		if ( !strncasecmp( _papi_errlist[i], error, strlen( error ) ) )

			return i; 

	} 

	return (-1);

}

/** @internal

 *  @class _papi_hwi_publish_error 

 *

 *  @return 

 *  	<= 0 : Code for the error. 

 *  	< 0  : We couldn't get memory to allocate for your error.

 *  	 	

 * 	An internal interface for adding an error code to the library. 

 * 	The returned code is suitable for returning to users. 

 *  */

int _papi_hwi_publish_error( char *error )

{

	int error_code = -1;

	if ( (error_code = _papi_hwi_lookup_error( error )) < 0 )

		error_code = _papi_hwi_add_error(error);

	return (-error_code); /* internally error_code is an index, externally, it should be <= 0 */

}

void

_papi_hwi_init_errors(void) {

/* we use add error to avoid the cost of lookups, we know the errors are not there yet */

	_papi_hwi_add_error("No error");

    _papi_hwi_add_error("Invalid argument");

    _papi_hwi_add_error("Insufficient memory");

    _papi_hwi_add_error("A System/C library call failed");

    _papi_hwi_add_error("Not supported by component");

    _papi_hwi_add_error("Access to the counters was lost or interrupted");

    _papi_hwi_add_error("Internal error, please send mail to the developers");

    _papi_hwi_add_error("Event does not exist");

    _papi_hwi_add_error("Event exists, but cannot be counted due to hardware resource limits");

    _papi_hwi_add_error("EventSet is currently not running");

    _papi_hwi_add_error("EventSet is currently counting");

    _papi_hwi_add_error("No such EventSet available");

    _papi_hwi_add_error("Event in argument is not a valid preset");

    _papi_hwi_add_error("Hardware does not support performance counters");

    _papi_hwi_add_error("Unknown error code");

    _papi_hwi_add_error("Permission level does not permit operation");

    _papi_hwi_add_error("PAPI hasn't been initialized yet");

    _papi_hwi_add_error("Component Index isn't set");

    _papi_hwi_add_error("Not supported");

    _papi_hwi_add_error("Not implemented");

    _papi_hwi_add_error("Buffer size exceeded");

    _papi_hwi_add_error("EventSet domain is not supported for the operation");

    _papi_hwi_add_error("Invalid or missing event attributes");

    _papi_hwi_add_error("Too many events or attributes");

    _papi_hwi_add_error("Bad combination of features");

}

int

_papi_hwi_invalid_cmp( int cidx )

{

  return ( cidx < 0 || cidx >= papi_num_components );

}

int 

_papi_hwi_component_index( int event_code ) {

	INTDBG("ENTER: event_code: %#x\n", event_code);

  int cidx;

  int event_index;

  /* currently assume presets are for component 0 only */

  if (IS_PRESET(event_code)) {

     INTDBG("EXIT: Event %#x is a PRESET, assigning component %d\n", event_code,0);

     return 0;

  }

  /* user defined events are treated like preset events (component 0 only) */

  if (IS_USER_DEFINED(event_code)) {

     INTDBG("EXIT: Event %#x is USER DEFINED, assigning component %d\n", event_code,0);

     return 0;

  }

  event_index=event_code&PAPI_NATIVE_AND_MASK;

  if ( (event_index < 0) || (event_index>=num_native_events)) {

     INTDBG("EXIT: Event index %#x is out of range, num_native_events: %d\n", event_index, num_native_events);

     return PAPI_ENOEVNT;

  }

  cidx=_papi_native_events[event_index].cidx;

  if ((cidx<0) || (cidx >= papi_num_components)) {

	  INTDBG("EXIT: Component index %#x is out of range, papi_num_components: %d\n", cidx, papi_num_components);

	  return PAPI_ENOCMP;

  }

  INTDBG("EXIT: Found cidx: %d event_index: %d, event_code: %#x\n", cidx, event_index, event_code);

  return cidx;

}

/* Convert an internal component event to a papi event code */

int 

_papi_hwi_native_to_eventcode(int cidx, int event_code, int ntv_idx, const char *event_name) {

  INTDBG("Entry: cidx: %d, event: %#x, ntv_idx: %d, event_name: %s\n", cidx, event_code, ntv_idx, event_name);

  int result;

  if (papi_event_code_changed > 0) {

	  result = _papi_hwi_get_papi_event_code();

	  INTDBG("EXIT: papi_event_code: %#x set by the component\n", result);

	  return result;

  }

  result=_papi_hwi_find_native_event(cidx, event_code, event_name);

  if (result==PAPI_ENOEVNT) {

     // Need to create one

     result=_papi_hwi_add_native_event(cidx, event_code, ntv_idx, event_name);

  }

  INTDBG("EXIT: result: %#x\n", result);

  return result;

}

/* Convert a native_event code to an internal event code */

int

_papi_hwi_eventcode_to_native(int event_code) {

	INTDBG("ENTER: event_code: %#x\n", event_code);

  int result;

  int event_index;

  event_index=event_code&PAPI_NATIVE_AND_MASK;

 if ((event_index < 0)  ||  (event_index>=num_native_events)) {

    INTDBG("EXIT: PAPI_ENOEVNT\n");

    return PAPI_ENOEVNT;

  }

  result=_papi_native_events[event_index].component_event;

  INTDBG("EXIT: result: %#x\n", result);

  return result;

}

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

/* Utility functions */

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

void

PAPIERROR( char *format, ... )

{

	va_list args;

	if ( ( _papi_hwi_error_level != PAPI_QUIET ) ||

		 ( getenv( "PAPI_VERBOSE" ) ) ) {

		va_start( args, format );

		fprintf( stderr, "PAPI Error: " );

		vfprintf( stderr, format, args );

		fprintf( stderr, "\n" );

		va_end( args );

	}

}

void

PAPIWARN( char *format, ... )

{

	va_list args;

	if ( ( _papi_hwi_error_level != PAPI_QUIET ) ||

		 ( getenv( "PAPI_VERBOSE" ) ) ) {

		va_start( args, format );

		fprintf( stderr, "PAPI Warning: " );

		vfprintf( stderr, format, args );

		fprintf( stderr, "\n" );

		va_end( args );

	}

}

static int

default_debug_handler( int errorCode )

{

	char str[PAPI_HUGE_STR_LEN];

	if ( errorCode == PAPI_OK )

		return ( errorCode );

	if ( ( errorCode > 0 ) || ( -errorCode > _papi_hwi_num_errors ) ) {

		PAPIERROR( "%s %d,%s,Bug! Unknown error code", PAPI_ERROR_CODE_str,

				   errorCode, "" );

		return ( PAPI_EBUG );

	}

	switch ( _papi_hwi_error_level ) {

	case PAPI_VERB_ECONT:

	case PAPI_VERB_ESTOP:

		/* gcc 2.96 bug fix, do not change */

		/* fprintf(stderr,"%s %d: %s: %s\n",PAPI_ERROR_CODE_str,errorCode,_papi_hwi_err[-errorCode].name,_papi_hwi_err[-errorCode].descr); */

		sprintf( str, "%s %d,%s", PAPI_ERROR_CODE_str, errorCode,

				 _papi_errlist[-errorCode] );

		if ( errorCode == PAPI_ESYS )

			sprintf( str + strlen( str ), ": %s", strerror( errno ) );

		PAPIERROR( str );

		if ( _papi_hwi_error_level == PAPI_VERB_ESTOP )

			abort(  );		 /* patch provided by will cohen of redhat */

		else

			return errorCode;

		break;

	case PAPI_QUIET:

	default:

		return errorCode;

	}

	return ( PAPI_EBUG );	 /* Never get here */

}

static int

allocate_eventset_map( DynamicArray_t * map )

{

	/* Allocate and clear the Dynamic Array structure */

	if ( map->dataSlotArray != NULL )

		papi_free( map->dataSlotArray );

	memset( map, 0x00, sizeof ( DynamicArray_t ) );

	/* Allocate space for the EventSetInfo_t pointers */

	map->dataSlotArray =

		( EventSetInfo_t ** ) papi_malloc( PAPI_INIT_SLOTS *

										   sizeof ( EventSetInfo_t * ) );

	if ( map->dataSlotArray == NULL ) {

		return ( PAPI_ENOMEM );

	}

	memset( map->dataSlotArray, 0x00,

			PAPI_INIT_SLOTS * sizeof ( EventSetInfo_t * ) );

	map->totalSlots = PAPI_INIT_SLOTS;

	map->availSlots = PAPI_INIT_SLOTS;

	map->fullSlots = 0;

	return ( PAPI_OK );

}

static int

expand_dynamic_array( DynamicArray_t * DA )

{

	int number;

	EventSetInfo_t **n;

	/*realloc existing PAPI_EVENTSET_MAP.dataSlotArray */

	number = DA->totalSlots * 2;

	n = ( EventSetInfo_t ** ) papi_realloc( DA->dataSlotArray,

											( size_t ) number *

											sizeof ( EventSetInfo_t * ) );

	if ( n == NULL )

		return ( PAPI_ENOMEM );

	/* Need to assign this value, what if realloc moved it? */

	DA->dataSlotArray = n;

	memset( DA->dataSlotArray + DA->totalSlots, 0x00,

			( size_t ) DA->totalSlots * sizeof ( EventSetInfo_t * ) );

	DA->totalSlots = number;

	DA->availSlots = number - DA->fullSlots;

	return ( PAPI_OK );

}

static int

EventInfoArrayLength( const EventSetInfo_t * ESI )

{

   return ( _papi_hwd[ESI->CmpIdx]->cmp_info.num_mpx_cntrs );

}

/*========================================================================*/

/* This function allocates space for one EventSetInfo_t structure and for */

/* all of the pointers in this structure.  If any malloc in this function */

/* fails, all memory malloced to the point of failure is freed, and NULL  */

/* is returned.  Upon success, a pointer to the EventSetInfo_t data       */

/* structure is returned.                                                 */

/*========================================================================*/

static int

create_EventSet( EventSetInfo_t ** here )

{

   EventSetInfo_t *ESI;

   ESI = ( EventSetInfo_t * ) papi_calloc( 1, sizeof ( EventSetInfo_t ) );

   if ( ESI == NULL ) {

      return PAPI_ENOMEM;

   }

   *here = ESI;

   return PAPI_OK;

}

int

_papi_hwi_assign_eventset( EventSetInfo_t *ESI, int cidx )

{

   INTDBG("ENTER: ESI: %p (%d), cidx: %d\n", ESI, ESI->EventSetIndex, cidx);

   int retval;

   size_t max_counters;

   char *ptr;

   unsigned int i, j;

   /* If component doesn't exist... */

   if (_papi_hwi_invalid_cmp(cidx)) return PAPI_ECMP;

   /* Assigned at create time */

   ESI->domain.domain = _papi_hwd[cidx]->cmp_info.default_domain;

   ESI->granularity.granularity =

	                         _papi_hwd[cidx]->cmp_info.default_granularity;

   ESI->CmpIdx = cidx;

   /* ??? */

   max_counters = ( size_t ) _papi_hwd[cidx]->cmp_info.num_mpx_cntrs;

   ESI->ctl_state = (hwd_control_state_t *) papi_calloc( 1, (size_t) 

				   _papi_hwd[cidx]->size.control_state );

   ESI->sw_stop = (long long *) papi_calloc( ( size_t ) max_counters,

						      sizeof ( long long ) );

   ESI->hw_start = ( long long * ) papi_calloc( ( size_t ) max_counters,

                                                      sizeof ( long long ) );

   ESI->EventInfoArray = ( EventInfo_t * ) papi_calloc( (size_t) max_counters,

                                                      sizeof ( EventInfo_t ) );

   /* allocate room for the native events and for the component-private */

   /* register structures */

   /* ugh is there a cleaner way to allocate this?  vmw */

   ESI->NativeInfoArray = ( NativeInfo_t * ) 

     papi_calloc( ( size_t ) max_counters, sizeof ( NativeInfo_t ));

   ESI->NativeBits = papi_calloc(( size_t ) max_counters,

                                 ( size_t ) _papi_hwd[cidx]->size.reg_value );

   /* NOTE: the next two malloc allocate blocks of memory that are later */

   /* parcelled into overflow and profile arrays                         */

   ESI->overflow.deadline = ( long long * )

		papi_malloc( ( sizeof ( long long ) +

					   sizeof ( int ) * 3 ) * ( size_t ) max_counters );

   ESI->profile.prof = ( PAPI_sprofil_t ** )

		papi_malloc( ( sizeof ( PAPI_sprofil_t * ) * ( size_t ) max_counters +

					   ( size_t ) max_counters * sizeof ( int ) * 4 ) );

   /* If any of these allocations failed, free things up and fail */

   if ( ( ESI->ctl_state == NULL ) ||

	( ESI->sw_stop == NULL )   || 

        ( ESI->hw_start == NULL )  ||

	( ESI->NativeInfoArray == NULL ) || 

	( ESI->NativeBits == NULL ) || 

        ( ESI->EventInfoArray == NULL )  ||

	( ESI->profile.prof == NULL ) || 

        ( ESI->overflow.deadline == NULL ) ) {

      if ( ESI->sw_stop ) papi_free( ESI->sw_stop );

      if ( ESI->hw_start ) papi_free( ESI->hw_start );

      if ( ESI->EventInfoArray ) papi_free( ESI->EventInfoArray );

      if ( ESI->NativeInfoArray ) papi_free( ESI->NativeInfoArray );

      if ( ESI->NativeBits ) papi_free( ESI->NativeBits );

      if ( ESI->ctl_state ) papi_free( ESI->ctl_state );

      if ( ESI->overflow.deadline ) papi_free( ESI->overflow.deadline );

      if ( ESI->profile.prof ) papi_free( ESI->profile.prof );

      papi_free( ESI );

      return PAPI_ENOMEM;

   }

   /* Carve up the overflow block into separate arrays */

   ptr = ( char * ) ESI->overflow.deadline;

   ptr += sizeof ( long long ) * max_counters;

   ESI->overflow.threshold = ( int * ) ptr;

   ptr += sizeof ( int ) * max_counters;

   ESI->overflow.EventIndex = ( int * ) ptr;

   ptr += sizeof ( int ) * max_counters;

   ESI->overflow.EventCode = ( int * ) ptr;

   /* Carve up the profile block into separate arrays */

   ptr = ( char * ) ESI->profile.prof +

		( sizeof ( PAPI_sprofil_t * ) * max_counters );

   ESI->profile.count = ( int * ) ptr;

   ptr += sizeof ( int ) * max_counters;

   ESI->profile.threshold = ( int * ) ptr;

   ptr += sizeof ( int ) * max_counters;

   ESI->profile.EventIndex = ( int * ) ptr;

   ptr += sizeof ( int ) * max_counters;

   ESI->profile.EventCode = ( int * ) ptr;

   /* initialize_EventInfoArray */

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

       ESI->EventInfoArray[i].event_code=( unsigned int ) PAPI_NULL;

       ESI->EventInfoArray[i].ops = NULL;

       ESI->EventInfoArray[i].derived=NOT_DERIVED;

       for ( j = 0; j < PAPI_EVENTS_IN_DERIVED_EVENT; j++ ) {

	   ESI->EventInfoArray[i].pos[j] = PAPI_NULL;

       }

   }

   /* initialize_NativeInfoArray */

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

      ESI->NativeInfoArray[i].ni_event = -1;

      ESI->NativeInfoArray[i].ni_position = -1;

      ESI->NativeInfoArray[i].ni_papi_code = -1;

      ESI->NativeInfoArray[i].ni_owners = 0;

      ESI->NativeInfoArray[i].ni_bits = ((unsigned char*)ESI->NativeBits) + 

                                          (i*_papi_hwd[cidx]->size.reg_value);

   }

   ESI->NativeCount = 0;

   ESI->state = PAPI_STOPPED;

   /* these used to be init_config */

   retval = _papi_hwd[cidx]->init_control_state( ESI->ctl_state );	

   retval |= _papi_hwd[cidx]->set_domain( ESI->ctl_state, ESI->domain.domain);

   return retval;

}