/*

* File:    profile.c

* Author:  Philip Mucci

*          mucci@cs.utk.edu

* Mods:    Dan Terpstra

*          terpstra@cs.utk.edu

* Mods:    Maynard Johnson

*          maynardj@us.ibm.com

*/

/* This file performs the following test:

	profiling and program info option call

   - This tests the SVR4 profiling interface of PAPI. These are counted

   in the default counting domain and default granularity, depending on

   the platform. Usually this is the user domain (PAPI_DOM_USER) and

   thread context (PAPI_GRN_THR).

     The Eventset contains:

     + PAPI_FP_INS (to profile)

     + PAPI_TOT_CYC

   - Set up profile

   - Start eventset 1

   - Do both (flops and reads)

   - Stop eventset 1

*/

#include <stdio.h>

#include <stdlib.h>

#include "papi.h"

#include "papi_test.h"

#include "prof_utils.h"

#include "do_loops.h"

#define PROFILE_ALL

static int

do_profile( caddr_t start, unsigned long plength, unsigned scale, int thresh,

			int bucket )

{

	int i, retval;

	unsigned long blength;

	int num_buckets;

	const char *profstr[5] = { "PAPI_PROFIL_POSIX",

		"PAPI_PROFIL_RANDOM",

		"PAPI_PROFIL_WEIGHTED",

		"PAPI_PROFIL_COMPRESS",

		"PAPI_PROFIL_<all>"

	};

	int profflags[5] = { PAPI_PROFIL_POSIX,

		PAPI_PROFIL_POSIX | PAPI_PROFIL_RANDOM,

		PAPI_PROFIL_POSIX | PAPI_PROFIL_WEIGHTED,

		PAPI_PROFIL_POSIX | PAPI_PROFIL_COMPRESS,

		PAPI_PROFIL_POSIX | PAPI_PROFIL_WEIGHTED |

			PAPI_PROFIL_RANDOM | PAPI_PROFIL_COMPRESS

	};

	do_no_profile( TESTS_QUIET );

	blength = prof_size( plength, scale, bucket, &num_buckets );

	prof_alloc( 5, blength );

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

		if ( !TESTS_QUIET ) {

			printf( "Test type   : \t%s\n", profstr[i] );

		}

#ifndef SWPROFILE

		if ( ( retval =

			   PAPI_profil( profbuf[i], ( unsigned int ) blength, start, scale,

							EventSet, PAPI_event, thresh,

							profflags[i] | bucket ) ) != PAPI_OK ) {

		   if (retval==PAPI_ENOSUPP) {

		      char warning[BUFSIZ];

		      sprintf(warning,"PAPI_profil %s not supported",

			      profstr[i]);

		      test_warn( __FILE__, __LINE__, warning, 1 );

		   }

		   else {

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

		   }

		}

#else

		if ( ( retval =

			   PAPI_profil( profbuf[i], ( unsigned int ) blength, start, scale,

							EventSet, PAPI_event, thresh,

							profflags[i] | bucket | PAPI_PROFIL_FORCE_SW ) ) !=

			 PAPI_OK ) {

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

		}

#endif

		if ( retval != PAPI_OK )

			break;

		if ( ( retval = PAPI_start( EventSet ) ) != PAPI_OK )

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

		do_flops( getenv( "NUM_FLOPS" ) ? atoi( getenv( "NUM_FLOPS" ) ) :

				  NUM_FLOPS );

		if ( ( retval = PAPI_stop( EventSet, values[1] ) ) != PAPI_OK )

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

		if ( !TESTS_QUIET ) {

			printf( TAB1, event_name, ( values[1] )[0] );

			printf( TAB1, "PAPI_TOT_CYC", ( values[1] )[1] );

		}

		retval = PAPI_profil( profbuf[i], ( unsigned int ) blength, start, scale,

							EventSet, PAPI_event, 0,

							profflags[i] );

		if (retval != PAPI_OK ) {

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

		}

	}

	if ( retval == PAPI_OK ) {

		if (!TESTS_QUIET) prof_head( blength, bucket, num_buckets,

				   "address\t\t\tflat\trandom\tweight\tcomprs\tall\n" );

		if (!TESTS_QUIET) prof_out( start, 5, bucket, num_buckets, scale );

		retval = prof_check( 5, bucket, num_buckets );

	}

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

		free( profbuf[i] );

	}

	return retval;

}

int

main( int argc, char **argv )

{

	int num_tests = 6;

	long length;

	int mask;

	int retval;

	int mythreshold = THRESHOLD;

	const PAPI_exe_info_t *prginfo;

	caddr_t start, end;

	int quiet;

	/* Set TESTS_QUIET variable */

	quiet = tests_quiet( argc, argv );

	retval = PAPI_library_init( PAPI_VER_CURRENT );

	if (retval != PAPI_VER_CURRENT ) {

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

	}

        if ( ( prginfo = PAPI_get_executable_info(  ) ) == NULL ) {

		test_fail( __FILE__, __LINE__, "PAPI_get_executable_info", 1 );

	}

	retval = PAPI_query_event(PAPI_TOT_CYC);

	if (retval!=PAPI_OK) {

		if (!quiet) printf("No events found\n");

		test_skip(__FILE__, __LINE__,"No events found",1);

	}

	mask = prof_events( num_tests );

#ifdef PROFILE_ALL

/* use these lines to profile entire code address space */

	start = prginfo->address_info.text_start;

	end = prginfo->address_info.text_end;

#else

/* use these lines to profile only do_flops address space */

	start = ( caddr_t ) do_flops;

	end = ( caddr_t ) fdo_flops;

/* Itanium and ppc64 processors return function descriptors instead of function addresses.

   You must dereference the descriptor to get the address.

*/

#if defined(ITANIUM1) || defined(ITANIUM2) || defined(__powerpc64__)

	start = ( caddr_t ) ( ( ( struct fdesc * ) start )->ip );

	end = ( caddr_t ) ( ( ( struct fdesc * ) end )->ip );

#endif

#endif

#if defined(linux)

	{

		char *tmp = getenv( "THRESHOLD" );

		if ( tmp )

			mythreshold = atoi( tmp );

	}

#endif

	length = end - start;

	if ( length < 0 ) {

		test_fail( __FILE__, __LINE__, "Profile length < 0!", ( int ) length );

	}

	if (!quiet) {

		prof_print_address( "Test case profile: "

			"POSIX compatible profiling with hardware counters.\n",

			prginfo );

		prof_print_prof_info( start, end, mythreshold, event_name );

	}

	retval = do_profile( start, ( unsigned long ) length, FULL_SCALE,

				mythreshold, PAPI_PROFIL_BUCKET_16 );

	if ( retval == PAPI_OK ) {

		retval = do_profile( start, ( unsigned long ) length,

						FULL_SCALE, mythreshold,

						PAPI_PROFIL_BUCKET_32 );

	}

	if ( retval == PAPI_OK ) {

		retval = do_profile( start, ( unsigned long ) length,

						FULL_SCALE, mythreshold,

						PAPI_PROFIL_BUCKET_64 );

	}

	remove_test_events( &EventSet, mask );

	test_pass( __FILE__ );

	return 0;

}