#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include "papi.h"

#include "papi_test.h"

#define TOLERANCE       .2

/*  Variable to hold reporting status

	if TRUE, output is suppressed

	if FALSE output is sent to stdout

	initialized to FALSE

	declared here so it can be available globally

*/

int TESTS_QUIET = 0;

static int TESTS_COLOR = 1;

static int TEST_WARN = 0;

void

validate_string( const char *name, char *s )

{

	if ( ( s == NULL ) || ( strlen( s ) == 0 ) ) {

		char s2[1024] = "";

		sprintf( s2, "%s was NULL or length 0", name );

		test_fail( __FILE__, __LINE__, s2, 0 );

	}

}

int

approx_equals( double a, double b )

{

	if ( ( a >= b * ( 1.0 - TOLERANCE ) ) && ( a <= b * ( 1.0 + TOLERANCE ) ) )

		return 1;

	else {

		printf( "Out of tolerance range %2.2f: %.0f vs %.0f [%.0f,%.0f]\n",

				TOLERANCE, a, b, b * ( 1.0 - TOLERANCE ),

				b * ( 1.0 + TOLERANCE ) );

		return 0;

	}

}

long long **

allocate_test_space( int num_tests, int num_events )

{

	long long **values;

	int i;

	values =

		( long long ** ) malloc( ( size_t ) num_tests *

								 sizeof ( long long * ) );

	if ( values == NULL )

		exit( 1 );

	memset( values, 0x0, ( size_t ) num_tests * sizeof ( long long * ) );

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

		values[i] =

			( long long * ) malloc( ( size_t ) num_events *

									sizeof ( long long ) );

		if ( values[i] == NULL )

			exit( 1 );

		memset( values[i], 0x00, ( size_t ) num_events * sizeof ( long long ) );

	}

	return ( values );

}

void

free_test_space( long long **values, int num_tests )

{

	int i;

	for ( i = 0; i < num_tests; i++ )

		free( values[i] );

	free( values );

}

int is_event_derived(unsigned int event) {

  PAPI_event_info_t info;

  if (event & PAPI_PRESET_MASK) {

     PAPI_get_event_info(event,&info;;

     if (strcmp(info.derived,"NOT_DERIVED")) {

       //       printf("%#x is derived\n",event);

        return 1;

     }

  }

  return 0;

}

int find_nonderived_event( void )

{

	/* query and set up the right event to monitor */

	PAPI_event_info_t info;

	int potential_evt_to_add[3] = { PAPI_FP_OPS, PAPI_FP_INS, PAPI_TOT_INS };

	int i;

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

		if ( PAPI_query_event( potential_evt_to_add[i] ) == PAPI_OK ) {

			if ( PAPI_get_event_info( potential_evt_to_add[i], &info ) ==

				 PAPI_OK ) {

				if ( ( info.count > 0 ) &&

					 !strcmp( info.derived, "NOT_DERIVED" ) )

					return ( potential_evt_to_add[i] );

			}

		}

	}

	return ( 0 );

}

/* Add events to an EventSet, as specified by a mask.

   Returns: number = number of events added

*/

//struct test_events_t {

//  unsigned int mask;

//  unsigned int event;

//};

struct test_events_t test_events[MAX_TEST_EVENTS] = {

  { MASK_TOT_CYC, PAPI_TOT_CYC },

  { MASK_TOT_INS, PAPI_TOT_INS },

  { MASK_FP_INS,  PAPI_FP_INS },

  { MASK_L1_TCM,  PAPI_L1_TCM },

  { MASK_L1_ICM,  PAPI_L1_ICM },

  { MASK_L1_DCM,  PAPI_L1_DCM },

  { MASK_L2_TCM,  PAPI_L2_TCM },

  { MASK_L2_TCA,  PAPI_L2_TCA },

  { MASK_L2_TCH,  PAPI_L2_TCH },

  { MASK_BR_CN,   PAPI_BR_CN  },

  { MASK_BR_MSP,  PAPI_BR_MSP },

  { MASK_BR_PRC,  PAPI_BR_PRC },

  { MASK_TOT_IIS, PAPI_TOT_IIS},

  { MASK_L1_DCR,  PAPI_L1_DCR},

  { MASK_L1_DCW,  PAPI_L1_DCW},

  { MASK_L1_DCA,  PAPI_L1_DCA},

  { MASK_FP_OPS,  PAPI_FP_OPS},

};

int

add_test_events( int *number, int *mask, int allow_derived )

{

	int retval,i;

	int EventSet = PAPI_NULL;

	char name_string[BUFSIZ];

	*number = 0;

	/* create the eventset */

	retval = PAPI_create_eventset( &EventSet );

	if ( retval != PAPI_OK ) {

		test_fail(__FILE__,__LINE__,"Trouble creating eventset",retval);

	}

	/* check all the masks */

	for(i=0;i

		if ( *mask & test_events[i].mask ) {

			/* remove any derived events if told to */

			if ((is_event_derived(test_events[i].event)) &&

				(!allow_derived)) {

				*mask = *mask ^ test_events[i].mask;

				continue;

			}

			retval = PAPI_add_event( EventSet,

				test_events[i].event );

			if ( retval == PAPI_OK ) {

				( *number )++;

			}

			else {

				if ( !TESTS_QUIET ) {

				PAPI_event_code_to_name(test_events[i].event,

							name_string);

				fprintf( stdout, "%#x %s is not available.\n",

					test_events[i].event,name_string);

				}

				*mask = *mask ^ test_events[i].mask;

			}

		}

	}

	return EventSet;

}

int

remove_test_events( int *EventSet, int mask )

{

	int retval = PAPI_OK;

	if ( mask & MASK_L1_DCA ) {

		retval = PAPI_remove_event( *EventSet, PAPI_L1_DCA );

		if ( retval < PAPI_OK )

			return ( retval );

	}

	if ( mask & MASK_L1_DCW ) {

		retval = PAPI_remove_event( *EventSet, PAPI_L1_DCW );

		if ( retval < PAPI_OK )

			return ( retval );

	}

	if ( mask & MASK_L1_DCR ) {

		retval = PAPI_remove_event( *EventSet, PAPI_L1_DCR );

		if ( retval < PAPI_OK )

			return ( retval );

	}

	if ( mask & MASK_L2_TCH ) {

		retval = PAPI_remove_event( *EventSet, PAPI_L2_TCH );

		if ( retval < PAPI_OK )

			return ( retval );

	}

	if ( mask & MASK_L2_TCA ) {

		retval = PAPI_remove_event( *EventSet, PAPI_L2_TCA );

		if ( retval < PAPI_OK )

			return ( retval );

	}

	if ( mask & MASK_L2_TCM ) {

		retval = PAPI_remove_event( *EventSet, PAPI_L2_TCM );

		if ( retval < PAPI_OK )

			return ( retval );

	}

	if ( mask & MASK_L1_DCM ) {

		retval = PAPI_remove_event( *EventSet, PAPI_L1_DCM );

		if ( retval < PAPI_OK )

			return ( retval );

	}

	if ( mask & MASK_L1_ICM ) {

		retval = PAPI_remove_event( *EventSet, PAPI_L1_ICM );

		if ( retval < PAPI_OK )

			return ( retval );

	}

	if ( mask & MASK_L1_TCM ) {

		retval = PAPI_remove_event( *EventSet, PAPI_L1_TCM );

		if ( retval < PAPI_OK )

			return ( retval );

	}

	if ( mask & MASK_FP_OPS ) {

		retval = PAPI_remove_event( *EventSet, PAPI_FP_OPS );

		if ( retval < PAPI_OK )

			return ( retval );

	}

	if ( mask & MASK_FP_INS ) {

		retval = PAPI_remove_event( *EventSet, PAPI_FP_INS );

		if ( retval < PAPI_OK )

			return ( retval );

	}

	if ( mask & MASK_TOT_INS ) {

		retval = PAPI_remove_event( *EventSet, PAPI_TOT_INS );

		if ( retval < PAPI_OK )

			return ( retval );

	}

	if ( mask & MASK_TOT_IIS ) {

		retval = PAPI_remove_event( *EventSet, PAPI_TOT_IIS );

		if ( retval < PAPI_OK )

			return ( retval );

	}

	if ( mask & MASK_TOT_CYC ) {

		retval = PAPI_remove_event( *EventSet, PAPI_TOT_CYC );

		if ( retval < PAPI_OK )

			return ( retval );

	}

	return ( PAPI_destroy_eventset( EventSet ) );

}

char *

stringify_all_domains( int domains )

{

	static char buf[PAPI_HUGE_STR_LEN];

	int i, did = 0;

	buf[0] = '\0';

	for ( i = PAPI_DOM_MIN; i <= PAPI_DOM_MAX; i = i << 1 )

		if ( domains & i ) {

			if ( did )

				strcpy( buf + strlen( buf ), "|" );

			strcpy( buf + strlen( buf ), stringify_domain( domains & i ) );

			did++;

		}

	if ( did == 0 )

		test_fail( __FILE__, __LINE__, "Unrecognized domains!", 0 );

	return ( buf );

}

char *

stringify_domain( int domain )

{

	switch ( domain ) {

	case PAPI_DOM_SUPERVISOR:

		return ( "PAPI_DOM_SUPERVISOR" );

	case PAPI_DOM_USER:

		return ( "PAPI_DOM_USER" );

	case PAPI_DOM_KERNEL:

		return ( "PAPI_DOM_KERNEL" );

	case PAPI_DOM_OTHER:

		return ( "PAPI_DOM_OTHER" );

	case PAPI_DOM_ALL:

		return ( "PAPI_DOM_ALL" );

	default:

		test_fail( __FILE__, __LINE__, "Unrecognized domains!", 0 );

	}

	return ( NULL );

}

char *

stringify_all_granularities( int granularities )

{

	static char buf[PAPI_HUGE_STR_LEN];

	int i, did = 0;

	buf[0] = '\0';

	for ( i = PAPI_GRN_MIN; i <= PAPI_GRN_MAX; i = i << 1 )

		if ( granularities & i ) {

			if ( did )

				strcpy( buf + strlen( buf ), "|" );

			strcpy( buf + strlen( buf ),

					stringify_granularity( granularities & i ) );

			did++;

		}

	if ( did == 0 )

		test_fail( __FILE__, __LINE__, "Unrecognized granularity!", 0 );

	return ( buf );

}

char *

stringify_granularity( int granularity )

{

	switch ( granularity ) {

	case PAPI_GRN_THR:

		return ( "PAPI_GRN_THR" );

	case PAPI_GRN_PROC:

		return ( "PAPI_GRN_PROC" );

	case PAPI_GRN_PROCG:

		return ( "PAPI_GRN_PROCG" );

	case PAPI_GRN_SYS_CPU:

		return ( "PAPI_GRN_SYS_CPU" );

	case PAPI_GRN_SYS:

		return ( "PAPI_GRN_SYS" );

	default:

		test_fail( __FILE__, __LINE__, "Unrecognized granularity!", 0 );

	}

	return ( NULL );

}

/* Checks for TESTS_QUIET or -q command line variable	*/

/* Sets the TESTS_QUIET global variable			*/

/* Also returns the value.				*/

int

tests_quiet( int argc, char **argv )

{

	char *value;

	int retval;

	if ( ( argc > 1 )

		 && ( ( strcasecmp( argv[1], "TESTS_QUIET" ) == 0 )

			  || ( strcasecmp( argv[1], "-q" ) == 0 ) ) ) {

		TESTS_QUIET = 1;

	}

	/* Always report PAPI errors when testing */

	/* Even in quiet mode */

	retval = PAPI_set_debug( PAPI_VERB_ECONT );

	if ( retval != PAPI_OK ) {

		test_fail( __FILE__, __LINE__, "PAPI_set_debug", retval );

	}

	value=getenv("TESTS_COLOR");

	if (value!=NULL) {

		if (value[0]=='y') {

			TESTS_COLOR=1;

		}

		else {

			TESTS_COLOR=0;

		}

	}

	/* Disable colors if sending to a file */

	if (!isatty(fileno(stdout))) {

		TESTS_COLOR=0;

	}

	return TESTS_QUIET;

}

#define RED    "\033[1;31m"

#define YELLOW "\033[1;33m"

#define GREEN  "\033[1;32m"

#define NORMAL "\033[0m"

static void print_spaces(int count) {

	int i;

	for(i=0;i

		fprintf(stdout, " ");

	}

}

/* Ugh, all these "fprintf(stdout)" are due to the */

/* TESTS_QUIET #define printf hack		*/

/* FIXME! Revert to printf once we are done converting */

void

test_pass( const char *filename )

{

	(void)filename;

//	int line_pad;

//	line_pad=60-strlen(filename);

//	if (line_pad<0) line_pad=0;

//	fprintf(stdout,"%s",filename);

//	print_spaces(line_pad);

	if ( TEST_WARN ) {

		print_spaces(59);

		if (TESTS_COLOR) fprintf( stdout, "%s", YELLOW);

		fprintf( stdout, "PASSED with WARNING");

		if (TESTS_COLOR) fprintf( stdout, "%s", NORMAL);

		fprintf( stdout, "\n");

	}

	else {

		if (TESTS_COLOR) fprintf( stdout, "%s",GREEN);

		fprintf( stdout, "PASSED");

		if (TESTS_COLOR) fprintf( stdout, "%s",NORMAL);

		fprintf( stdout, "\n");

	}

	if ( PAPI_is_initialized(  ) ) {

		PAPI_shutdown(  );

	}

	exit( 0 );

}

/* Use a positive value of retval to simply print an error message */

void

test_fail( const char *file, int line, const char *call, int retval )

{

//	int line_pad;

	char buf[128];

	(void)file;

//	line_pad=(60-strlen(file));

//	if (line_pad<0) line_pad=0;

//	fprintf(stdout,"%s",file);

//	print_spaces(line_pad);

	memset( buf, '\0', sizeof ( buf ) );

	if (TESTS_COLOR) fprintf(stdout,"%s",RED);

	fprintf( stdout, "FAILED!!!");

	if (TESTS_COLOR) fprintf(stdout,"%s",NORMAL);

	fprintf( stdout, "\nLine # %d ", line );

	if ( retval == PAPI_ESYS ) {

		sprintf( buf, "System error in %s", call );

		perror( buf );

	} else if ( retval > 0 ) {

		fprintf( stdout, "Error: %s\n", call );

	} else if ( retval == 0 ) {

#if defined(sgi)

		fprintf( stdout, "SGI requires root permissions for this test\n" );

#else

		fprintf( stdout, "Error: %s\n", call );

#endif

	} else {

		fprintf( stdout, "Error in %s: %s\n", call, PAPI_strerror( retval ) );

	}

//	fprintf( stdout, "\n" );

	/* NOTE: Because test_fail is called from thread functions,

	   calling PAPI_shutdown here could prevent some threads

	   from being able to free memory they have allocated.

	 */

	if ( PAPI_is_initialized(  ) ) {

		PAPI_shutdown(  );

	}

	/* This is stupid.  Threads are the rare case */

	/* and in any case an exit() should clear everything out */

	/* adding back the exit() call */

	exit(1);

}

/* Use a positive value of retval to simply print an error message */

void

test_warn( const char *file, int line, const char *call, int retval )

{

	(void)file;

//	int line_pad;

//	line_pad=60-strlen(file);

//	if (line_pad<0) line_pad=0;

	char buf[128];

	memset( buf, '\0', sizeof ( buf ) );

//	fprintf(stdout,"%s",file);

//	print_spaces(line_pad);

	if (TEST_WARN==0) fprintf(stdout,"\n");

	if (TESTS_COLOR) fprintf( stdout, "%s", YELLOW);

	fprintf( stdout, "WARNING ");

	if (TESTS_COLOR) fprintf( stdout, "%s", NORMAL);

	fprintf( stdout, "Line # %d ", line );

	if ( retval == PAPI_ESYS ) {

		sprintf( buf, "System warning in %s", call );

		perror( buf );

	} else if ( retval > 0 ) {

		fprintf( stdout, "Warning: %s\n", call );

	} else if ( retval == 0 ) {

		fprintf( stdout, "Warning: %s\n", call );

	} else {

		fprintf( stdout, "Warning in %s: %s\n", call, PAPI_strerror( retval ));

	}

	TEST_WARN++;

}

void

test_skip( const char *file, int line, const char *call, int retval )

{

//	int line_pad;

	(void)file;

	(void)line;

	(void)call;

	(void)retval;

//	line_pad=(60-strlen(file));

//	fprintf(stdout,"%s",file);

//	print_spaces(line_pad);

	fprintf( stdout, "SKIPPED\n");

	exit( 0 );

}

void

test_print_event_header( const char *call, int evset )

{

        int *ev_ids;

	int i, nev;

	int retval;

	char evname[PAPI_MAX_STR_LEN];

	if ( *call )

		fprintf( stdout, "%s", call );

	if ((nev = PAPI_get_cmp_opt(PAPI_MAX_MPX_CTRS,NULL,0)) <= 0) {

		fprintf( stdout, "Can not list event names.\n" );

		return;

	}

	if ((ev_ids = calloc(nev,sizeof(int))) == NULL) {

		fprintf( stdout, "Can not list event names.\n" );

		return;

	}

	retval = PAPI_list_events( evset, ev_ids, &nev );

	if ( retval == PAPI_OK ) {

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

			PAPI_event_code_to_name( ev_ids[i], evname );

			printf( ONEHDR, evname );

		}

	} else {

		fprintf( stdout, "Can not list event names." );

	}

	fprintf( stdout, "\n" );

	free(ev_ids);

}

int

add_two_events( int *num_events, int *papi_event, int *mask ) {

	int retval;

	int EventSet = PAPI_NULL;

	*num_events=2;

	*papi_event=PAPI_TOT_INS;

	(void)mask;

	/* create the eventset */

	retval = PAPI_create_eventset( &EventSet );

	if ( retval != PAPI_OK ) {

		test_fail( __FILE__, __LINE__, "PAPI_create_eventset", retval );

	}

	retval = PAPI_add_named_event( EventSet, "PAPI_TOT_CYC");

	if ( retval != PAPI_OK ) {

		if (!TESTS_QUIET) printf("Couldn't add PAPI_TOT_CYC\n");

		test_skip(__FILE__,__LINE__,"Couldn't add PAPI_TOT_CYC",0);

	}

	retval = PAPI_add_named_event( EventSet, "PAPI_TOT_INS");

	if ( retval != PAPI_OK ) {

		if (!TESTS_QUIET) printf("Couldn't add PAPI_TOT_CYC\n");

		test_skip(__FILE__,__LINE__,"Couldn't add PAPI_TOT_CYC",0);

	}

	return EventSet;

}

int

add_two_nonderived_events( int *num_events, int *papi_event, int *mask ) {

	/* query and set up the right event to monitor */

	int EventSet = PAPI_NULL;

	int retval;

	*num_events=0;

#define POTENTIAL_EVENTS 3

	unsigned int potential_evt_to_add[POTENTIAL_EVENTS][2] =

		{ {( unsigned int ) PAPI_FP_INS, MASK_FP_INS},

		  {( unsigned int ) PAPI_FP_OPS, MASK_FP_OPS},

		  {( unsigned int ) PAPI_TOT_INS, MASK_TOT_INS}

		};

	int i;

	*mask = 0;

	/* could leak up to two event sets. */

	for(i=0;i

		retval = PAPI_query_event( ( int ) potential_evt_to_add[i][0] );

		if (retval  == PAPI_OK ) {

			if ( !is_event_derived(potential_evt_to_add[i][0])) {

		 		*papi_event = ( int ) potential_evt_to_add[i][0];

		 		*mask = ( int ) potential_evt_to_add[i][1] | MASK_TOT_CYC;

		 		EventSet = add_test_events( num_events, mask, 0 );

		 		if ( *num_events == 2 ) break;

			}

		}

	}

	return EventSet;

}

/* add native events to use all counters */

int

enum_add_native_events( int *num_events, int **evtcodes,

			int need_interrupt, int no_software_events,

			int cidx)

{

	/* query and set up the right event to monitor */

	int EventSet = PAPI_NULL;

	int i = 0, k, event_code, retval;

	int counters, event_found = 0;

	PAPI_event_info_t info;

	const PAPI_component_info_t *s = NULL;

	const PAPI_hw_info_t *hw_info = NULL;

	*num_events=0;

	s = PAPI_get_component_info( cidx );

	if ( s == NULL ) {

		test_fail( __FILE__, __LINE__,

				"PAPI_get_component_info", PAPI_ECMP );

	}

	hw_info = PAPI_get_hardware_info(  );

	if ( hw_info == NULL ) {

		test_fail( __FILE__, __LINE__, "PAPI_get_hardware_info", 2 );

	}

	counters = PAPI_num_hwctrs(  );

	if (counters<1) {

		if (!TESTS_QUIET) printf("No counters available\n");

		return EventSet;

	}

	if (!TESTS_QUIET) {

		printf("Trying to fill %d hardware counters...\n", counters);

	}

	if (need_interrupt) {

		if ( (!strcmp(hw_info->model_string,"POWER6")) ||

			(!strcmp(hw_info->model_string,"POWER5")) ) {

			test_warn(__FILE__, __LINE__,

					"Limiting num_counters because of "

					"LIMITED_PMC on Power5 and Power6",1);

			counters=4;

		}

	}

	( *evtcodes ) = ( int * ) calloc( counters, sizeof ( int ) );

	retval = PAPI_create_eventset( &EventSet );

	if ( retval != PAPI_OK ) {

		test_fail( __FILE__, __LINE__, "PAPI_create_eventset", retval );

	}

	/* For platform independence, always ASK FOR the first event */

	/* Don't just assume it'll be the first numeric value */

	i = 0 | PAPI_NATIVE_MASK;

	retval = PAPI_enum_cmp_event( &i, PAPI_ENUM_FIRST, cidx );

	if ( retval != PAPI_OK ) {

		test_fail( __FILE__, __LINE__, "PAPI_enum_cmp_event", retval );

	}

     do {

        retval = PAPI_get_event_info( i, &info );

	/* HACK! FIXME */

        if (no_software_events && ( strstr(info.symbol,"PERF_COUNT_SW") || strstr(info.long_descr, "PERF_COUNT_SW") ) ) {

	   if (!TESTS_QUIET) {

	      printf("Blocking event %s as a SW event\n", info.symbol);

	   }

	   continue;

	}

	if ( s->cntr_umasks ) {

	   k = i;

	   if ( PAPI_enum_cmp_event( &k, PAPI_NTV_ENUM_UMASKS, cidx ) == PAPI_OK ) {

	      do {

	         retval = PAPI_get_event_info( k, &info );

		 event_code = ( int ) info.event_code;

		 retval = PAPI_add_event( EventSet, event_code );

		 if ( retval == PAPI_OK ) {

		    ( *evtcodes )[event_found] = event_code;

		    if ( !TESTS_QUIET ) {

		       printf( "event_code[%d] = %#x (%s)\n",

			       event_found, event_code, info.symbol );

		    }

		    event_found++;

		 } else {

		    if ( !TESTS_QUIET ) {

		       printf( "%#x (%s) can't be added to the EventSet.\n",

			       event_code, info.symbol );

		    }

		 }

	      } while ( PAPI_enum_cmp_event( &k, PAPI_NTV_ENUM_UMASKS, cidx ) == PAPI_OK

						&& event_found < counters );

	   } else {

	      event_code = ( int ) info.event_code;

	      retval = PAPI_add_event( EventSet, event_code );

	      if ( retval == PAPI_OK ) {

		  ( *evtcodes )[event_found] = event_code;

		  if ( !TESTS_QUIET ) {

		     printf( "event_code[%d] = %#x (%s)\n",

			       event_found, event_code, info.symbol );

		  }

		  event_found++;

	      }

	   }

	   if ( !TESTS_QUIET && retval == PAPI_OK ) {

	     /* */

	   }

	} else {

			event_code = ( int ) info.event_code;

			retval = PAPI_add_event( EventSet, event_code );

			if ( retval == PAPI_OK ) {

				( *evtcodes )[event_found] = event_code;

				event_found++;

			} else {

				if ( !TESTS_QUIET )

					fprintf( stdout, "%#x is not available.\n", event_code );

			}

		}

	}

     while ( PAPI_enum_cmp_event( &i, PAPI_ENUM_EVENTS, cidx ) == PAPI_OK &&

			event_found < counters );

	*num_events = ( int ) event_found;

	if (!TESTS_QUIET) printf("Tried to fill %d counters with events, "

				 "found %d\n",counters,event_found);

	return EventSet;

}