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

/* 
* File:    ppc64_events.c
* Author:  Maynard Johnson
*          maynardj@us.ibm.com
* Mods:    <your name here>
*          <your email address>
*/

#include "papi_internal.h"
#include <string.h>
#include "libperfctr.h"

hwd_groups_t group_map[MAX_GROUPS] = { {0}
, {0}
, {0}
, {0}
, {0}
};
native_event_entry_t native_table[PAPI_MAX_NATIVE_EVENTS];

/* to initialize the native_table */
void
perfctr_initialize_native_table(  )
{
	int i, j;
	memset( native_table, 0,
			PAPI_MAX_NATIVE_EVENTS * sizeof ( native_event_entry_t ) );
	for ( i = 0; i < PAPI_MAX_NATIVE_EVENTS; i++ ) {
		for ( j = 0; j < MAX_COUNTERS; j++ )
			native_table[i].resources.counter_cmd[j] = -1;
	}
}


/* to setup native_table group value */
void
perfctr_ppc64_setup_gps( int total, ntv_event_group_info_t * group_info )
{
	int i, j, gnum;

	for ( i = 0; i < total; i++ ) {
		for ( j = 0; j < MAX_COUNTERS; j++ ) {
			if ( native_table[i].resources.selector & ( 1 << j ) ) {
				for ( gnum = 0; gnum < group_info->maxgroups; gnum++ ) {
					if ( native_table[i].resources.counter_cmd[j] ==
						 group_info->event_groups[gnum]->events[j] ) {
						native_table[i].resources.group[gnum / 32] |=
							1 << ( gnum % 32 );
					}
				}
			}
		}
	}

	for ( gnum = 0; gnum < group_info->maxgroups; gnum++ ) {
		group_map[gnum].mmcr0 = group_info->event_groups[gnum]->mmcr0;
		group_map[gnum].mmcr1L = group_info->event_groups[gnum]->mmcr1L;
		group_map[gnum].mmcr1U = group_info->event_groups[gnum]->mmcr1U;
		group_map[gnum].mmcra = group_info->event_groups[gnum]->mmcra;
		for ( i = 0; i < MAX_COUNTERS; i++ )
			group_map[gnum].counter_cmd[i] =
				group_info->event_groups[gnum]->events[i];
	}
}


/* to setup native_table values, and return number of entries */
int
perfctr_ppc64_setup_native_table(  )
{
	int pmc, ev, i, j, index;
	/* This is for initialisation-testing of consistency between
	   native_name_map and our events file */
	int itemCount = 0;
	index = 0;
	perfctr_initialize_native_table(  );
	ntv_event_info_t *info = perfctr_get_native_evt_info(  );
	if ( info == NULL ) {
		PAPIERROR( EVENT_INFO_FILE_ERROR );
		return PAPI_ECMP;
	}
	ntv_event_t *wevp;
	for ( pmc = 0; pmc < info->maxpmcs; pmc++ ) {
		wevp = info->wev[pmc];
		for ( ev = 0; ev < info->maxevents[pmc]; ev++, wevp++ ) {
			for ( i = 0; i < index; i++ ) {
				if ( strcmp( wevp->symbol, native_table[i].name ) == 0 ) {
					native_table[i].resources.selector |= 1 << pmc;
					native_table[i].resources.counter_cmd[pmc] =
						wevp->event_num;
					break;
				}
			}
			if ( i == index ) {
				//native_table[i].index=i; 
				native_table[i].resources.selector |= 1 << pmc;
				native_table[i].resources.counter_cmd[pmc] = wevp->event_num;
				native_table[i].name =
					( char * ) malloc( strlen( wevp->symbol ) + 1 );
				strcpy( native_table[i].name, wevp->symbol );
				native_table[i].description = wevp->description;
				index++;
				for ( j = 0; j < MAX_NATNAME_MAP_INDEX; j++ ) {
					/* It appears that here, if I'm right, that the events
					   file entry matches the event from native_name_map, */
					/* This here check is to ensure that native_name_map in fact
					   has MAX_NATNAME_MAP_INDEX elements, or rather that it never
					   tries to access one that has not been initialised. */
					if ( native_name_map[j].name == NULL ) {
						SUBDBG( "native_name_map has a NULL at position %i\n",
								j );
						PAPIERROR
							( "Inconsistency between events_map file and events header." );
						return PAPI_EBUG;
					}
					if ( strcmp( native_table[i].name, native_name_map[j].name )
						 == 0 ) {
						native_name_map[j].index = i;
						itemCount++;
						break;
					}
				}
				/* If we never set native_name_map[j], then there is an
				   inconsistency between native_name_map and native_table */
				if ( ( !( j < MAX_NATNAME_MAP_INDEX ) ) ||
					 native_name_map[j].index != i ) {
					SUBDBG
						( "No match found between native_name_map and native_table.  "
						  "Values was %s at position %i in native_table.\n",
						  native_table[i].name, i );
					PAPIERROR
						( "Inconsistency between native_name_map and events file." );
					return PAPI_EBUG;
				}
			}
		}
	}
	/* given the previous evidence that native_name_map is a superset of
	   native_table, ensuring this match in their cardinality shows them to
	   be equivalent. */
	if ( itemCount != MAX_NATNAME_MAP_INDEX ) {
		SUBDBG( "%i events found in native_table, but really should be %i\n",
				itemCount, MAX_NATNAME_MAP_INDEX );
		PAPIERROR
			( "Inconsistent cardinality between native_name_map and events file",
			  itemCount, MAX_NATNAME_MAP_INDEX );
		return PAPI_EBUG;
	}

	ntv_event_group_info_t *gp_info = perfctr_get_native_group_info(  );
	if ( gp_info == NULL ) {
		perfctr_initialize_native_table(  );
		PAPIERROR( EVENT_INFO_FILE_ERROR );
		return PAPI_ECMP;
	}

	perfctr_ppc64_setup_gps( index, gp_info );
	_papi_hwi_system_info.sub_info.num_native_events = index;

	return check_native_name(  );
}

int
check_native_name(  )
{
	enum native_name foo;
	int itemCount = 0;
	int i;

	/* This should ensure that the cardinality of native_name is the same
	   as that of native_name_map which may be true iff native_name 
	   expresses the same data as native_name_map and there is a 1:1 
	   mapping from one onto the other, though there is no guarantee of 
	   order. */
	if ( ( NATNAME_GUARD - PAPI_NATIVE_MASK ) != MAX_NATNAME_MAP_INDEX ) {
		SUBDBG( "%i is the number of elements apparently in native_name, "
				"but really should be %i, according to native_name_map.\n",
				( NATNAME_GUARD - PAPI_NATIVE_MASK ), MAX_NATNAME_MAP_INDEX );
		PAPIERROR
			( "Inconsistent cardinality between native_name and native_name_map "
			  "detected in preliminary check\n" );
		return PAPI_EBUG;
	}

	/* The following is sanity checking only.  It attempts to verify some level
	   of consistency between native_name and native_name_map and native_table.
	   This should imply that native_name is a subset of native_name_map. */
	for ( foo = PAPI_NATIVE_MASK; foo < NATNAME_GUARD; foo++ ) {
		for ( i = 0; i < MAX_NATNAME_MAP_INDEX; i++ ) {
			/* Now, if the event we are on is the native event we seek... */
			if ( ( native_name_map[i].index | PAPI_NATIVE_MASK ) == foo ) {
				itemCount++;
				break;
			}
		}
	}
	if ( itemCount != MAX_NATNAME_MAP_INDEX ) {
		SUBDBG( "Inconsistency between native_name_map and native_name.  "
				"%i events matched, but really should be %i\n", itemCount,
				MAX_NATNAME_MAP_INDEX );
		PAPIERROR
			( "Inconsistent cardinality between native_name and native_name_map\n" );
		return PAPI_EBUG;
	}

	return PAPI_OK;
}

static FILE *
open_file( const char *fname )
{
	char *cpu;
	char *dot = ".";
	char *dot_dot = "..";
#ifdef _POWER5p
	cpu = "power5+";
#elif defined(_POWER5)
	cpu = "power5";
#elif defined(_PPC970)
	cpu = "ppc970";
#else
	cpu = "";
#endif
	char *dir = ( char * ) getenv( "PAPI_EVENTFILE_PATH" );
#ifdef PAPI_DATADIR
	if ( dir == NULL ) {
		dir = PAPI_DATADIR;
	}
#endif
	/* If dir is still NULL, assume current dir holds event_data dir */
	if ( dir == NULL )
		dir = dot;

	char *relative_pathname = ( char * ) malloc( strlen( "/" ) +
												 strlen( "event_data" ) +
												 strlen( "/" ) + strlen( cpu ) +
												 strlen( "/" ) +
												 strlen( fname ) + 1 );
	strcpy( relative_pathname, "/" );
	strcat( relative_pathname, "event_data" );
	strcat( relative_pathname, "/" );
	strcat( relative_pathname, cpu );
	strcat( relative_pathname, "/" );
	strcat( relative_pathname, fname );
	/* Add a little extra space to the malloc for the case where dir = "." since
	 * we may be trying dir = ".." later on. */
	char *pathname =
		( char * ) malloc( strlen( dir ) + strlen( relative_pathname ) + 4 );
	int keep_trying;
	if ( strcmp( dir, dot ) == 0 )
		keep_trying = 2;
	else
		keep_trying = 3;
	FILE *file = NULL;
	while ( file == NULL && keep_trying-- ) {
		strcpy( pathname, dir );
		strcat( pathname, relative_pathname );
		file = fopen( pathname, "r" );
		if ( strcmp( dir, dot ) == 0 ) {
			dir = dot_dot;
		} else {
			dir = dot;
		}
		SUBDBG( "Attempt to open event data file %s %s successful.\n", pathname,
				( file == NULL ) ? "was not" : "was" );
		memset( pathname, '\0', sizeof ( pathname ) );
	}

	free( pathname );
	free( relative_pathname );
	return ( file );
}

static ntv_event_t *
copy_buffer( ntv_event_t events[], int maxevents )
{
	ntv_event_t *cur_wev, *start_wev;
	start_wev = ( ntv_event_t * ) malloc( sizeof ( ntv_event_t ) * maxevents );
	cur_wev = start_wev;

	int cnt;
	for ( cnt = 0; cnt < maxevents; cnt++, cur_wev++ ) {
		cur_wev->event_num = events[cnt].event_num;
		strcpy( cur_wev->symbol, events[cnt].symbol );
		cur_wev->short_description =
			( char * ) malloc( strlen( events[cnt].short_description ) );
		strcpy( cur_wev->short_description, events[cnt].short_description );
		cur_wev->description =
			( char * ) malloc( strlen( events[cnt].description ) );
		strcpy( cur_wev->description, events[cnt].description );
	}
	return start_wev;
}

static ntv_event_info_t *
parse_eventfile( FILE * evfile )
{
	int counter = 0, num_events = 0;
	int i, len, cc;
	int event;
	int line_counter_flag = 0;
	char line_data[1024];
	ntv_event_t events[PAPI_MAX_NATIVE_EVENTS];
	ntv_event_info_t *ntv_evt_info =
		( ntv_event_info_t * ) malloc( sizeof ( ntv_event_info_t ) );
	ntv_evt_info->maxpmcs = 0;
	char data[1024];
	while ( fgets( data, 1022, evfile ) ) {
		if ( feof( evfile ) )
			continue;
		if ( strlen( data ) < 2 )
			continue;

		if ( strncmp( data, "$$$$", 4 ) == 0 ) {
			line_counter_flag = 0;
			ntv_evt_info->maxevents[counter - 1] = num_events;
			ntv_evt_info->wev[counter - 1] = copy_buffer( events, num_events );
			ntv_event_t *temp = ntv_evt_info->wev[counter - 1];
			temp++;
		}
		switch ( line_counter_flag ) {
		case 0:
			if ( sscanf( data, "{ counter %u", &counter ) == 1 ) {
				line_counter_flag = 1;
				num_events = 0;
				ntv_evt_info->maxpmcs++;
			}
			break;
		case 1:
			if ( sscanf( data, "#%u", &event ) != 1 ) {
				fprintf( stderr, "EVS file format error 1 (%s)\n", data );
				return NULL;
			}
			if ( event >= PAPI_MAX_NATIVE_EVENTS ) {
				fprintf( stderr, "EVS file format error 1 (%s)\n", data );
				return NULL;
			}
			events[num_events].event_num = event;
			len = strlen( data );
			int symb_found = 0;
			for ( i = cc = 0; i < len; i++ ) {
				if ( data[i] == ',' )
					cc++;
				if ( cc == 5 && !symb_found ) {
					strcpy( line_data, &data[i + 1] );
					int j = 0;
					while ( line_data[j] != ',' )
						j++;
					strncpy( events[num_events].symbol, line_data, j );
					events[num_events].symbol[j] = 0;
					symb_found = 1;
					i += j;
				} else if ( cc == 6 ) {
					len = strlen( &data[i + 1] );
					events[num_events].short_description =
						( char * ) malloc( len );
					strcpy( events[num_events].short_description,
							&data[i + 1] );
					events[num_events].short_description[len - 1] = 0;
					break;
				}
			}
			line_counter_flag = 2;
			break;
		case 2:
			line_counter_flag = 3;
			break;
		case 3:
			len = strlen( data );
			events[num_events].description = ( char * ) malloc( len );
			strcpy( events[num_events].description, data );
			events[num_events].description[len - 1] = 0;
			line_counter_flag = 1;
			num_events++;
			break;
		}
	}
	if ( counter == 0 ) {
		free( ntv_evt_info );
		ntv_evt_info = NULL;
	}
	if ( counter == MAX_COUNTERS ) {
		ntv_evt_info->maxevents[counter - 1] = num_events;
		ntv_evt_info->wev[counter - 1] = copy_buffer( events, num_events );
	}
	fclose( evfile );
	return ntv_evt_info;
}

static int
any_counter_invalid( int event_id[], int size )
{
	int j;
	for ( j = 0; j < size; j++ ) {
		if ( event_id[j] >= PAPI_MAX_NATIVE_EVENTS )
			return 1;
	}
	return 0;
}

static ntv_event_group_info_t *
parse_groupfile( FILE * grp_file )
{
	char data[1024];
	unsigned int mmcr0, mmcr1H, mmcr1L, mmcra;
	int g, state = 0;
	ntv_event_group_info_t *group_info =
		( ntv_event_group_info_t * )
		malloc( sizeof ( ntv_event_group_info_t ) );
	group_info->maxgroups = 0;
	int event_num[MAX_COUNTERS];
	while ( fgets( data, 1022, grp_file ) ) {
		if ( feof( grp_file ) || ( strlen( data ) < 2 ) )
			continue;

		switch ( state ) {
		case 0:
#if defined(_POWER5) || defined(_POWER5p)
			if ( sscanf
				 ( data, "#%u,%u,%u,%u,%u,%u,%u", &g, &event_num[0],
				   &event_num[1], &event_num[2], &event_num[3], &event_num[4],
				   &event_num[5] ) == 7 ) {
				state = 1;
				if ( any_counter_invalid( event_num, 6 ) ) {
					fprintf( stderr, "ERROR: Maximum events exceeded\n" );
					return NULL;
				}
			}
#else
			if ( sscanf
				 ( data, "#%u,%u,%u,%u,%u,%u,%u,%u,%u", &g, &event_num[0],
				   &event_num[1], &event_num[2], &event_num[3], &event_num[4],
				   &event_num[5], &event_num[6], &event_num[7] ) == 9 ) {
				state = 1;
				if ( any_counter_invalid( event_num, 8 ) ) {
					fprintf( stderr, "ERROR: Maximum events exceeded\n" );
					return NULL;
				}
			}
#endif
			if ( state == 1 ) {
				group_info->event_groups[group_info->maxgroups] =
					( event_group_t * ) malloc( sizeof ( event_group_t ) );
				group_info->event_groups[group_info->maxgroups]->group_id = g;
				int j = 0;
				for ( ; j < MAX_COUNTERS; j++ )
					group_info->event_groups[group_info->maxgroups]->events[j] =
						event_num[j];
			}
			break;
		case 1:
			// unused hex event codes
			state = 2;
			break;
		case 2:
			/* get mmcr values */
			if ( sscanf( data, "%#x,%#x,%#x,%#x", &mmcr0, &mmcr1H, &mmcr1L, &mmcra )
				 != 4 ) {
				fprintf( stderr, "GPS file format error 1 (%s)\n", data );
				return NULL;
			}
			state = 3;
			group_info->event_groups[group_info->maxgroups]->mmcr0 = mmcr0;
			group_info->event_groups[group_info->maxgroups]->mmcr1L = mmcr1L;
			group_info->event_groups[group_info->maxgroups]->mmcr1U = mmcr1H;
			group_info->event_groups[group_info->maxgroups]->mmcra = mmcra;
			group_info->maxgroups++;
			break;
		case 3:
			// unused group name
			state = 0;
		}
	}
	fclose( grp_file );
	return group_info;
}

ntv_event_info_t *
perfctr_get_native_evt_info( void )
{
	ntv_event_info_t *evt_info = NULL;
	FILE *evt_file = open_file( "events" );
	if ( evt_file != NULL ) {
		evt_info = parse_eventfile( evt_file );
	}
	return evt_info;

}

ntv_event_group_info_t *
perfctr_get_native_group_info( void )
{
	ntv_event_group_info_t *groups = NULL;
	FILE *grp_file = NULL;
	if ( ( grp_file = open_file( "groups" ) ) != NULL ) {
		groups = parse_groupfile( grp_file );
	}
	return groups;
}