void counter_init( int *eventset, int *num_papi_events )
{
char error_str[PAPI_MAX_STR_LEN];
// int events[] = {PAPI_TOT_INS,PAPI_BR_INS,PAPI_SR_INS};
int events[] = {PAPI_TOT_CYC,PAPI_L3_TCM};
int stat;
int thread = omp_get_thread_num();
if( thread == 0 )
printf("Initializing PAPI counters...\n");
*num_papi_events = sizeof(events) / sizeof(int);
if ((stat = PAPI_thread_init((long unsigned int (*)(void)) omp_get_thread_num)) != PAPI_OK) {
PAPI_perror("PAPI_thread_init");
exit(1);
}
if ( (stat= PAPI_create_eventset(eventset)) != PAPI_OK) {
PAPI_perror("PAPI_create_eventset");
exit(1);
}
for( int i = 0; i < *num_papi_events; i++ ) {
if ((stat=PAPI_add_event(*eventset,events[i])) != PAPI_OK) {
PAPI_perror("PAPI_add_event");
exit(1);
}
}
if ((stat=PAPI_start(*eventset)) != PAPI_OK) {
PAPI_perror("PAPI_start");
exit(1);
}
}
static int
check_event( int event_code, char *name )
{
int retval;
char errstring[PAPI_MAX_STR_LEN];
long long values;
int EventSet = PAPI_NULL;
/* Is there an issue with older machines? */
/* Disable for now, add back once we can reproduce */
// if ( PENTIUM4 ) {
// if ( strcmp( name, "REPLAY_EVENT:BR_MSP" ) == 0 ) {
// return 1;
// }
// }
retval = PAPI_create_eventset( &EventSet );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_create_eventset", retval );
retval = PAPI_add_event( EventSet, event_code );
if ( retval != PAPI_OK ) {
printf( "Error adding %s\n", name );
return 0;
} else {
// printf( "Added %s successfully ", name );
}
retval = PAPI_start( EventSet );
if ( retval != PAPI_OK ) {
PAPI_perror( retval, errstring, PAPI_MAX_STR_LEN );
fprintf( stdout, "Error starting %s : %s\n", name, errstring );
} else {
retval = PAPI_stop( EventSet, &values );
if ( retval != PAPI_OK ) {
PAPI_perror( retval, errstring, PAPI_MAX_STR_LEN );
fprintf( stdout, "Error stopping %s: %s\n", name, errstring );
return 0;
} else {
printf( "Added and Stopped %s successfully.\n", name );
}
}
retval=PAPI_cleanup_eventset( EventSet );
if (retval != PAPI_OK ) {
test_warn( __FILE__, __LINE__, "PAPI_cleanup_eventset", retval);
}
retval=PAPI_destroy_eventset( &EventSet );
if (retval != PAPI_OK ) {
test_warn( __FILE__, __LINE__, "PAPI_destroy_eventset", retval);
}
return ( 1 );
}
static void metric_warning(int errcode, char *note)
{
char errstring[PAPI_MAX_STR_LEN];
#ifdef PAPIV
PAPI_perror(errstring);
#else
PAPI_perror(errcode, errstring, PAPI_MAX_STR_LEN);
#endif
if (errcode == PAPI_ESYS) {
strncat(errstring, ": ", PAPI_MAX_STR_LEN-strlen(errstring));
strncat(errstring, strerror(errno), PAPI_MAX_STR_LEN-strlen(errstring));
}
vt_warning("%s: %s (ignored)\n", note?note:"PAPI", errstring);
}
int handle_error(int code, char *outstring){
char errmesg[PAPI_MAX_STR_LEN];
printf("Error in PAPI function call %s\n", outstring);
PAPI_perror("PAPI Error");
exit(1);
}
static
void test_fail(char *file, int line, char *call, int retval)
{
char buf[128];
memset(buf, '\0', sizeof(buf));
if (retval != 0)
fprintf (stdout,"%-40s FAILED\nLine # %d\n", file, line);
else
{
fprintf (stdout,"%-40s SKIPPED\n", file);
fprintf (stdout,"Line # %d\n", 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)
fprintf (stdout,"Error: %s\n", call);
else
{
char errstring[PAPI_MAX_STR_LEN];
PAPI_perror (retval, errstring, PAPI_MAX_STR_LEN);
fprintf (stdout,"Error in %s: %s\n", call, errstring);
}
fprintf (stdout,"\n");
if (PAPI_is_initialized ())
PAPI_shutdown ();
exit (1);
}
void
test_skip( char *file, int line, char *call, int retval )
{
char buf[128];
memset( buf, '\0', sizeof ( buf ) );
fprintf( stdout, "%-40s SKIPPED\n", file );
if ( !TESTS_QUIET ) {
if ( retval == PAPI_ESYS ) {
fprintf( stdout, "Line # %d\n", line );
sprintf( buf, "System error in %s:", call );
perror( buf );
} else if ( retval == PAPI_EPERM ) {
fprintf( stdout, "Line # %d\n", line );
fprintf( stdout, "Invalid permissions for %s.", call );
} else if ( retval == PAPI_ESBSTR ) {
fprintf( stdout, "Line # %d\n", line );
fprintf( stdout, "%s.", call );
} else if ( retval >= 0 ) {
fprintf( stdout, "Line # %d\n", line );
fprintf( stdout, "Error calculating: %s\n", call );
} else if ( retval < 0 ) {
char errstring[PAPI_MAX_STR_LEN];
fprintf( stdout, "Line # %d\n", line );
PAPI_perror( retval, errstring, PAPI_MAX_STR_LEN );
fprintf( stdout, "Error in %s: %s\n", call, errstring );
}
fprintf( stdout, "\n" );
}
exit( 0 );
}
static void
test_continue( char *call, int retval )
{
char errstring[PAPI_MAX_STR_LEN];
PAPI_perror( retval, errstring, PAPI_MAX_STR_LEN );
printf( "Expected error in %s: %s\n", call, errstring );
}
static void metric_error(int errcode, char *note)
{
char errstring[PAPI_MAX_STR_LEN];
PAPI_perror(errcode, errstring, PAPI_MAX_STR_LEN);
if (errcode == PAPI_ESYS) {
strncat(errstring, ": ", PAPI_MAX_STR_LEN-strlen(errstring));
strncat(errstring, strerror(errno), PAPI_MAX_STR_LEN-strlen(errstring));
}
vt_error_msg("%s: %s (fatal)\n", note?note:"PAPI", errstring);
}
// initialize papi with one thread first
void papi_serial_init(void)
{
if ( PAPI_library_init(PAPI_VER_CURRENT) != PAPI_VER_CURRENT){
fprintf(stderr, "PAPI library init error!\n");
exit(1);
}
if (( PAPI_thread_init((long unsigned int (*)(void))
pthread_self )) != PAPI_OK){
PAPI_perror("PAPI_thread_init");
exit(1);
}
}
void ipm_hpm_stop() {
#ifndef HPM_DISABLED
int i,rv;
#ifdef HPM_PAPI
char errstring[PAPI_MAX_STR_LEN];
char event_name[PAPI_MAX_STR_LEN];
long long int papi_hpm[MAXSIZE_HPMCOUNTERS];
#endif
if(task.flags & IPM_HPM_CANCELED) {
return;
}
if(task.hpm_eventset < 0) {
return;
}
#ifdef HPM_PAPI
#ifdef CPU_PPC450D
/* then we are on a bluegene P*/
if (node_rank != 0 ) return;
#endif
rv = PAPI_stop(papi_eventset[0], papi_hpm);
if(rv != PAPI_OK) {
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
printf("IPM: %d papi_error hpm_stop %d %s\n",
task.mpi_rank,
rv,
errstring);
}
#endif
#ifdef HPM_PMAPI
pm_stop_mythread();
#endif
/* TAG_EXIT: exit from global is different than exit from non global */
if(task.flags & IPM_HPM_ACTIVE) {
if(task.region_current > 0) {
printf("IPM: %d exit from region=%d > 0 \n",
task.mpi_rank, task.region_current);
}
}
return;
#endif
}
/* Use a positive value of retval to simply print an error message */
void
test_fail( char *file, int line, char *call, int retval )
{
int line_pad;
char buf[128];
line_pad=(int)(50-strlen(file));
if (line_pad<0) line_pad=0;
memset( buf, '\0', sizeof ( buf ) );
if (TESTS_COLOR) {
fprintf( stdout, "%-*s %sFAILED%s\nLine # %d\n", line_pad, file,
RED,NORMAL,line );
}
else {
fprintf( stdout, "%-*s FAILED\nLine # %d\n", line_pad, file, 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 {
char errstring[PAPI_MAX_STR_LEN];
PAPI_perror( retval, errstring, PAPI_MAX_STR_LEN );
fprintf( stdout, "Error in %s: %s\n", call, errstring );
}
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.
*/
/* 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);
}
void ipm_pthread_hpm_stop(int tid)
{
#ifdef HPM_PAPI
int rv;
char errstring[PAPI_MAX_STR_LEN];
long long int papi_hpm[MAXSIZE_HPMCOUNTERS];
rv = PAPI_stop(papi_eventset[tid], papi_hpm);
if(rv!=PAPI_OK) {
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
printf("IPM: %d papi_error hpm_stop %d %s\n",
task.mpi_rank,
rv,
errstring);
}
#endif
}
static void test_fail(char *file, int line, char *call, int retval)
{
printf("%s\tFAILED\nLine # %d\n", file, line);
if ( retval == PAPI_ESYS ) {
char buf[128];
memset( buf, '\0', sizeof(buf) );
sprintf(buf, "System error in %s:", call );
perror(buf);
}
else if ( retval > 0 ) {
printf("Error calculating: %s\n", call );
}
else {
char errstring[PAPI_MAX_STR_LEN];
PAPI_perror(retval, errstring, PAPI_MAX_STR_LEN );
printf("Error in %s: %s\n", call, errstring );
}
printf("\n");
exit(1);
}
/* Use a positive value of retval to simply print an error message */
void
test_warn( char *file, int line, char *call, int retval )
{
int line_pad;
line_pad=(int)(50-strlen(file));
if (line_pad<0) line_pad=0;
char buf[128];
memset( buf, '\0', sizeof ( buf ) );
if (TESTS_COLOR) {
fprintf( stdout, "%-*s %sWARNING%s\nLine # %d\n", line_pad, file,
YELLOW, NORMAL, line );
}
else {
fprintf( stdout, "%-*s WARNING\nLine # %d\n", line_pad, file, 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 {
char errstring[PAPI_MAX_STR_LEN];
PAPI_perror( retval, errstring, PAPI_MAX_STR_LEN );
fprintf( stdout, "Warning in %s: %s\n", call, errstring );
}
fprintf( stdout, "\n" );
TEST_WARN++;
}
void ipm_hpm_start() {
int i,j,k,rv;
#ifndef HPM_DISABLED
#ifdef HPM_PAPI
char errstring[PAPI_MAX_STR_LEN];
char event_name[PAPI_MAX_STR_LEN];
#endif
if(task.hpm_eventset < 0) {
return;
}
for(i=0;i<MAXSIZE_REGION;i++) {
for(j=0;j<MAXSIZE_NEVENTSETS;j++) {
for(k=0;k<MAXSIZE_HPMCOUNTERS;k++) {
task.hpm_count[i][j][k] = 0;
}
}
}
#ifdef HPM_PAPI
/* Initialize the low level PAPI library */
rv = PAPI_library_init(PAPI_VER_CURRENT);
if(rv != PAPI_VER_CURRENT) {
printf("IPM: %d papi_error library_init in hpm_start rv=%d \"%s\"\n",
task.mpi_rank,
rv,
PAPI_strerror(rv));
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
perror("PAPI_library_init");
}
if(rv == PAPI_OK) {
if(task.flags & DEBUG && task.mpi_rank==0) {
printf("IPM: %d PAPI_library_init in hpm_start rv=%d \"%s\"\n",
task.mpi_rank,
rv,
PAPI_strerror(rv));
}
}
#ifdef CPU_PPC450D
/* then we are on a bluegene P*/
if (node_rank != 0 ) return;
#endif
rv = PAPI_num_counters();
if(rv < 0) {
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
printf("IPM: %d papi_error num_counters in hpm_start rv=%d \"%s\"\n",
task.mpi_rank,
rv,
PAPI_strerror(rv));
}
if ((hwinfo = PAPI_get_hardware_info()) == NULL) {
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
printf("IPM: %d papi_error PAPI_get_hardware_info in hpm_start rv=%d \"%s\"\n",
task.mpi_rank,
rv,
PAPI_strerror(rv));
} else {
/* do something clever wrt. formal machine description */
}
rv = PAPI_create_eventset(&papi_eventset[0]);
if(rv != PAPI_OK) {
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
printf("IPM: %d papi_error create_eventset in hpmstart rv=%d \"%s\"\n",
task.mpi_rank,
rv,
PAPI_strerror(rv));
}
if(0) {
printf("PAPI: JIE_DEBUG:: rank %d task.hpm_eventset is %d.\n",
task.mpi_rank, task.hpm_eventset);
fflush(stdout);
}
for(i=0;i<MAXSIZE_HPMCOUNTERS;i++) {
if (papi_event[task.hpm_eventset][i] != -1) {
rv = PAPI_query_event(papi_event[task.hpm_eventset][i]);
if (rv != PAPI_OK) {
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
PAPI_event_code_to_name(papi_event[task.hpm_eventset][i],event_name);
printf("IPM: %d papi_error query_event %s %d \"%s\"\n",
task.mpi_rank,
event_name,
rv,
PAPI_strerror(rv));
}
rv = PAPI_add_event(papi_eventset[0], papi_event[task.hpm_eventset][i]);
if(rv != PAPI_OK) {
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
PAPI_event_code_to_name(papi_event[task.hpm_eventset][i],event_name);
printf("IPM: %d papi_error add_event %s %d \"%s\"\n",
task.mpi_rank,
event_name,
rv,
PAPI_strerror(rv));
}
if(0) {
PAPI_event_code_to_name(papi_event[task.hpm_eventset][i],event_name);
printf("PAPI: JIE_DEBUG:: rank %d add event %s.\n",
task.mpi_rank, event_name);
fflush(stdout);
}
}
}
rv = PAPI_start(papi_eventset[0]);
if (rv != PAPI_OK) {
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
printf("IPM: %d papi_error: start in hpm_start rv=%d \"%s\"\n",
task.mpi_rank,
rv,
PAPI_strerror(rv));
task.flags &= ~IPM_HPM_ACTIVE;
}
#endif
#ifdef HPM_PMAPI
#ifdef AIX51
rv = pm_init(PM_VERIFIED|PM_UNVERIFIED|PM_CAVEAT|PM_GET_GROUPS, &pmapi_info, &pmapi_groups_info);
#else
rv = pm_initialize(PM_VERIFIED|PM_UNVERIFIED|PM_CAVEAT|PM_GET_GROUPS, &pmapi_info, &pmapi_groups_info,PM_CURRENT);
#endif
if(rv) {
printf("IPM: %d pmapi_error: pm_initialize \n",
task.mpi_rank);
pm_error("IPM: pmapi : pm_initialize",rv);
}
for(i=0;i<pmapi_info.maxpmcs;i++)
pmapi_prog.events[i]=COUNT_NOTHING;
pmapi_prog.mode.w = 0;
pmapi_prog.mode.b.user = 1;
pmapi_prog.mode.b.proctree = 1;
#ifndef POWER3
#ifdef CPU_POWER4
pmapi_prog.mode.b.is_group = 1;
if(task.hpm_eventset == 0) { pmapi_prog.events[0] = 60; }
if(task.hpm_eventset == 1) { pmapi_prog.events[0] = 59; }
if(task.hpm_eventset == 2) { pmapi_prog.events[0] = 5; }
if(task.hpm_eventset == 3) { pmapi_prog.events[0] = 58; }
if(task.hpm_eventset == 4) { pmapi_prog.events[0] = 53; }
#endif
#ifdef CPU_POWER5
pmapi_prog.mode.b.is_group = 1;
if(task.hpm_eventset == 0) { pmapi_prog.events[0] = 137; }
#endif
#ifdef CPU_POWER6
pmapi_prog.mode.b.is_group = 1;
/* use all the pm_hpm* groups 186 - 195 */
pmapi_prog.events[0] = 186 + task.hpm_eventset;
#endif
#else
for(i=0;i<MAXSIZE_HPMCOUNTERS;i++) {
pmapi_prog.events[i] = pmapi_event[task.hpm_eventset][i];
}
#endif
rv = pm_set_program_mythread(&pmapi_prog);
if(rv) {
printf("IPM: %d pmapi_error: pm_set_program_mythread\n",
task.mpi_rank);
pm_error("IPM: pmapi : pm_set_program_mythread",rv);
}
rv = pm_start_mythread();
if(rv) {
printf("IPM: %d pmapi_error: pm_start_mythread\n",
task.mpi_rank);
pm_error("IPM: pmapi : pm_start_mythread",rv);
task.flags &= ~IPM_HPM_ACTIVE;
}
rv = pm_reset_data_mythread();
if(rv) {
printf("IPM: %d pmapi_error: pm_reset_data_mythread\n",
task.mpi_rank);
}
#endif
#endif
return;
}
void ipm_pthread_hpm_init()
{
int i,j,k,rv;
#ifdef HPM_PAPI
char errstring[PAPI_MAX_STR_LEN];
char event_name[PAPI_MAX_STR_LEN];
#endif
//task.flags |= DEBUG;
if(task.hpm_eventset < 0) {
return;
}
for(i=0;i<MAXSIZE_REGION;i++) {
for(j=0;j<MAXSIZE_NEVENTSETS;j++) {
for(k=0;k<MAXSIZE_HPMCOUNTERS;k++) {
task.hpm_count[i][j][k] = 0;
}
}
}
#ifdef HPM_PAPI
for( i=0; i<MAXSIZE_NTHREADS; i++ )
{
papi_eventset[i]=PAPI_NULL;
}
/* Initialize the low level PAPI library */
rv = PAPI_library_init(PAPI_VER_CURRENT);
if(rv != PAPI_VER_CURRENT) {
printf("IPM: %d papi_error library_init in hpm_start rv=%d \"%s\"\n",
task.mpi_rank,
rv,
PAPI_strerror(rv));
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
perror("PAPI_library_init");
}
rv = PAPI_thread_init(pthread_self);
if( rv != PAPI_OK )
if(task.flags & DEBUG && task.mpi_rank==0) {
printf("IPM: %d PAPI_thread_init in hpm_start rv=%d \"%s\"\n",
task.mpi_rank,
rv,
PAPI_strerror(rv));
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
perror("PAPI_thread_init");
}
rv = PAPI_num_counters();
if(rv < 0) {
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
printf("IPM: %d papi_error num_counters in hpm_start rv=%d \"%s\"\n",
task.mpi_rank,
rv,
PAPI_strerror(rv));
}
if ((hwinfo = PAPI_get_hardware_info()) == NULL) {
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
printf("IPM: %d papi_error PAPI_get_hardware_info in hpm_start rv=%d \"%s\"\n",
task.mpi_rank,
rv,
PAPI_strerror(rv));
} else {
/* do something clever wrt. formal machine description */
}
return;
}
int main(){
int retval,i;
int EventSet=PAPI_NULL;
int event_code=PAPI_TOT_INS; /* By default monitor total instructions */
char errstring[PAPI_MAX_STR_LEN];
char event_name[PAPI_MAX_STR_LEN];
float a[1000],b[1000],c[1000];
long long values;
/* This initializes the library and checks the version number of the
* header file, to the version of the library, if these don't match
* then it is likely that PAPI won't work correctly.
*/
if ((retval = PAPI_library_init(PAPI_VER_CURRENT)) != PAPI_VER_CURRENT ){
/* This call loads up what the error means into errstring
* if retval == PAPI_ESYS then it might be beneficial
* to call perror as well to see what system call failed
*/
PAPI_perror("PAPI_library_init");
exit(-1);
}
/* Create space for the EventSet */
if ( (retval=PAPI_create_eventset( &EventSet ))!=PAPI_OK){
PAPI_perror(retval, errstring, PAPI_MAX_STR_LEN);
exit(-1);
}
/* After this call if the environment variable PAPI_EVENT is set,
* event_code may contain something different than total instructions.
*/
if ( (retval=PAPI_add_env_event(&EventSet, &event_code, "PAPI_EVENT"))!=PAPI_OK){
PAPI_perror("PAPI_add_env_event");
exit(-1);
}
/* Now lets start counting */
if ( (retval = PAPI_start(EventSet)) != PAPI_OK ){
PAPI_perror("PAPI_start");
exit(-1);
}
/* Some work to take up some time, the PAPI_start/PAPI_stop (and/or
* PAPI_read) should surround what you want to monitor.
*/
for ( i=0;i<1000;i++){
a[i] = b[i]-c[i];
c[i] = a[i]*1.2;
}
if ( (retval = PAPI_stop(EventSet, &values) ) != PAPI_OK ){
PAPI_perror("PAPI_stop");
exit(-1);
}
if ( (retval=PAPI_event_code_to_name( event_code, event_name))!=PAPI_OK){
PAPI_perror("PAPI_event_code_to_name");
exit(-1);
}
printf("Ending values for %s: %lld\n", event_name,values);
/* Remove PAPI instrumentation, this is necessary on platforms
* that need to release shared memory segments and is always
* good practice.
*/
PAPI_shutdown();
exit(0);
}
int
main( int argc, char **argv )
{
int retval, i;
int EventSet = PAPI_NULL, count = 0, err_count = 0;
long long values;
PAPI_event_info_t info;
char errstring[PAPI_MAX_STR_LEN];
tests_quiet( argc, argv ); /* Set TESTS_QUIET variable */
retval = PAPI_library_init( PAPI_VER_CURRENT );
if ( retval != PAPI_VER_CURRENT )
test_fail( __FILE__, __LINE__, "PAPI_library_init", retval );
retval = PAPI_create_eventset( &EventSet );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_create_eventset", retval );
for ( i = 0; i < PAPI_MAX_PRESET_EVENTS; i++ ) {
if ( PAPI_get_event_info( PAPI_PRESET_MASK | i, &info ) != PAPI_OK )
continue;
if ( !( info.count ) )
continue;
printf( "Adding %-14s", info.symbol );
retval = PAPI_add_event( EventSet, ( int ) info.event_code );
if ( retval != PAPI_OK ) {
PAPI_perror( retval, errstring, PAPI_MAX_STR_LEN );
fprintf( stdout, "Error: %s\n", errstring );
err_count++;
} else {
retval = PAPI_start( EventSet );
if ( retval != PAPI_OK ) {
PAPI_perror( retval, errstring, PAPI_MAX_STR_LEN );
fprintf( stdout, "Error Starting: %s\n", errstring );
err_count++;
} else {
retval = PAPI_stop( EventSet, &values );
if ( retval != PAPI_OK ) {
PAPI_perror( retval, errstring, PAPI_MAX_STR_LEN );
fprintf( stdout, "Error Stopping: %s\n", errstring );
err_count++;
} else {
printf( "successful\n" );
count++;
}
}
retval = PAPI_remove_event( EventSet, ( int ) info.event_code );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_remove_event", retval );
}
}
retval = PAPI_destroy_eventset( &EventSet );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_destroy_eventset", retval );
printf( "Successfully added, started and stopped %d events.\n", count );
if ( err_count )
printf( "Failed to add, start or stop %d events.\n", err_count );
if ( count > 0 )
test_pass( __FILE__, NULL, 0 );
else
test_fail( __FILE__, __LINE__, "No events added", 1 );
exit( 1 );
}
void ipm_pthread_hpm_start(int tid)
{
#ifdef HPM_PAPI
int rv, i;
char errstring[PAPI_MAX_STR_LEN];
char event_name[PAPI_MAX_STR_LEN];
#endif
rv = PAPI_create_eventset(&papi_eventset[tid]);
if(rv != PAPI_OK) {
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
printf("IPM: %d papi_error create_eventset in hpmstart rv=%d \"%s\"\n",
task.mpi_rank,
rv,
PAPI_strerror(rv));
}
for(i=0;i<MAXSIZE_HPMCOUNTERS;i++)
{
if (papi_event[task.hpm_eventset][i] != -1) {
rv = PAPI_query_event(papi_event[task.hpm_eventset][i]);
if (rv != PAPI_OK) {
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
PAPI_event_code_to_name(papi_event[task.hpm_eventset][i],event_name);
printf("IPM: %d papi_error query_event %s %d \"%s\"\n",
task.mpi_rank,
event_name,
rv,
PAPI_strerror(rv));
}
rv = PAPI_add_event(papi_eventset[tid], papi_event[task.hpm_eventset][i]);
if(rv != PAPI_OK) {
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
PAPI_event_code_to_name(papi_event[task.hpm_eventset][i],event_name);
printf("IPM: %d papi_error add_event %s %d \"%s\"\n",
task.mpi_rank,
event_name,
rv,
PAPI_strerror(rv));
}
// PAPI_event_code_to_name(papi_event[task.hpm_eventset][i],event_name);
// fprintf(stderr, "tid=%d added event %d '%s'\n",
//tid, papi_event[task.hpm_eventset][i], event_name);
}
}
rv = PAPI_start(papi_eventset[tid]);
if (rv != PAPI_OK) {
PAPI_perror(rv, errstring, PAPI_MAX_STR_LEN);
printf("IPM: %d papi_error: start in hpm_start rv=%d \"%s\"\n",
task.mpi_rank,
rv,
PAPI_strerror(rv));
// task.flags &= ~IPM_HPM_ACTIVE;
}
}
void counter_init( int *eventset, int *num_papi_events )
{
char error_str[PAPI_MAX_STR_LEN];
int stat;
/////////////////////////////////////////////////////////////////////////
// PAPI EVENT SELECTION
/////////////////////////////////////////////////////////////////////////
// User can comment/uncomment blocks as they see fit within this seciton
// Some Standard Events
//int events[] = {PAPI_TOT_INS,PAPI_LD_INS,PAPI_FP_INS};
// Bandwidth Used
// ((PAPI_Lx_TCM * Lx_linesize) / PAPI_TOT_CYC) * Clock(MHz)
int events[] = {PAPI_L3_TCM, PAPI_TOT_CYC};
// L3 Total Cache Miss Ratio
// PAPI_L3_TCM / PAPI_L3_TCA
// (On Xeon dual octo - 65%, not dependent on # of threads)
//int events[] = {PAPI_L3_TCM, PAPI_L3_TCA};
// % Cycles with no instruction use
// PAPI_STL_ICY / PAPI_TOT_CYC
//int events[] = { PAPI_STL_ICY, PAPI_TOT_CYC };
// % Branch instructions Mispredicted
// PAPI_BR_MSP / PAPI_BR_CN
//int events[] = { PAPI_BR_MSP, PAPI_BR_CN, PAPI_BR_PRC };
// TLB Misses
//int events[] = { PAPI_TLB_DM };
// MFlops
// (PAPI_FP_INS/PAPI_TOT_CYC) * Clock(MHz)
//int events[] = { PAPI_FP_INS, PAPI_TOT_CYC };
// MFlops (Alternate?)
// (PAPI_FP_INS/PAPI_TOT_CYC) * Clock(MHz)
//int events[] = { PAPI_DP_OPS, PAPI_TOT_CYC };
// TLB misses (Using native counters)
/*
int events[2];
int EventCode;
char * event1 = "perf::DTLB-LOADS";
char * event2 = "perf::DTLB-LOAD-MISSES";
PAPI_event_name_to_code( event1, &EventCode );
events[0] = EventCode;
PAPI_event_name_to_code( event2, &EventCode );
events[1] = EventCode;
*/
/*
// Stalled Cycles, front v back (Using native counters)
int events[3];
int EventCode;
char * event1 = "perf::STALLED-CYCLES-FRONTEND";
char * event2 = "perf::STALLED-CYCLES-BACKEND";
char * event3 = "perf::PERF_COUNT_HW_CPU_CYCLES";
PAPI_event_name_to_code( event1, &EventCode );
events[0] = EventCode;
PAPI_event_name_to_code( event2, &EventCode );
events[1] = EventCode;
PAPI_event_name_to_code( event3, &EventCode );
events[2] = EventCode;
*/
/*
// LLC Cache Misses (Using native counters)
int events[2];
int EventCode;
char * event1 = "ix86arch::LLC_REFERENCES";
char * event2 = "ix86arch::LLC_MISSES";
PAPI_event_name_to_code( event1, &EventCode );
events[0] = EventCode;
PAPI_event_name_to_code( event2, &EventCode );
events[1] = EventCode;
*/
/*
// Node Prefetch Misses (Using native counters)
int events[1];
int EventCode;
//char * event1 = "perf::NODE-PREFETCHES";
//char * event2 = "perf::NODE-PREFETCH-MISSES";
char * event1 = "perf::NODE-PREFETCHES";
char * event2 = "perf::NODE-LOAD-MISSES:COUNT";
//PAPI_event_name_to_code( event1, &EventCode );
//events[0] = EventCode;
PAPI_event_name_to_code( event2, &EventCode );
events[0] = EventCode;
*/
/*
// CPU Stalls Due to lack of Load Buffers (Using native counters)
int events[2];
int EventCode;
char * event1 = "RESOURCE_STALLS:LB";
char * event2 = "perf::PERF_COUNT_HW_CPU_CYCLES";
PAPI_event_name_to_code( event1, &EventCode );
events[0] = EventCode;
PAPI_event_name_to_code( event2, &EventCode );
events[1] = EventCode;
*/
/*
// CPU Stalls Due to ANY Resource (Using native counters)
int events[2];
int EventCode;
char * event1 = "RESOURCE_STALLS:ANY";
char * event2 = "PAPI_TOT_CYC";
PAPI_event_name_to_code( event1, &EventCode );
events[0] = EventCode;
PAPI_event_name_to_code( event2, &EventCode );
events[1] = EventCode;
*/
/*
// CPU Stalls at Reservation Station (Using native counters)
int events[2];
int EventCode;
char * event1 = "RESOURCE_STALLS:RS";
char * event2 = "perf::PERF_COUNT_HW_CPU_CYCLES";
PAPI_event_name_to_code( event1, &EventCode );
events[0] = EventCode;
PAPI_event_name_to_code( event2, &EventCode );
events[1] = EventCode;
*/
/*
// CPU Stall Reason Breakdown (Using native counters)
int events[4];
int EventCode;
char * event1 = "RESOURCE_STALLS:ANY";
char * event2 = "RESOURCE_STALLS:LB";
char * event3 = "RESOURCE_STALLS:RS";
char * event4 = "RESOURCE_STALLS:SB";
// Set 1
// Set 2
char * event1 = "RESOURCE_STALLS:ANY";
char * event2 = "RESOURCE_STALLS:ROB";
char * event3 = "RESOURCE_STALLS:MEM_RS";
char * event4 = "RESOURCE_STALLS2:ALL_FL_EMPTY";
// Set 2
// Set 3
char * event1 = "RESOURCE_STALLS:ANY";
char * event2 = "RESOURCE_STALLS2:ALL_PRF_CONTROL";
char * event3 = "RESOURCE_STALLS2:ANY_PRF_CONTROL"; // duplicate
char * event4 = "RESOURCE_STALLS2:OOO_RSRC";
// Set 3
// Events that don't need to be counted
// Don't bother measuring these
//char * event1 = "RESOURCE_STALLS:FCSW"; // Always 0, don't measure
//char * event1 = "RESOURCE_STALLS:MXCSR"; // Always 0, don't measure
//char * event3 = "RESOURCE_STALLS2:BOB_FULL"; // Always trivial
//char * event3 = "RESOURCE_STALLS2:ANY_PRF_CONTROL"; // duplicate
PAPI_event_name_to_code( event1, &EventCode );
events[0] = EventCode;
PAPI_event_name_to_code( event2, &EventCode );
events[1] = EventCode;
PAPI_event_name_to_code( event3, &EventCode );
events[2] = EventCode;
PAPI_event_name_to_code( event4, &EventCode );
events[3] = EventCode;
*/
/////////////////////////////////////////////////////////////////////////
// PAPI EVENT LOADING
/////////////////////////////////////////////////////////////////////////
// Users should not need to alter anything within this section
int thread = omp_get_thread_num();
if( thread == 0 )
printf("Initializing PAPI counters...\n");
*num_papi_events = sizeof(events) / sizeof(int);
if ((stat = PAPI_thread_init((long unsigned int (*)(void)) omp_get_thread_num)) != PAPI_OK){
PAPI_perror("PAPI_thread_init");
exit(1);
}
if ( (stat= PAPI_create_eventset(eventset)) != PAPI_OK){
PAPI_perror("PAPI_create_eventset");
exit(1);
}
for( int i = 0; i < *num_papi_events; i++ ){
if ((stat=PAPI_add_event(*eventset,events[i])) != PAPI_OK){
PAPI_perror("PAPI_add_event");
exit(1);
}
}
if ((stat=PAPI_start(*eventset)) != PAPI_OK){
PAPI_perror("PAPI_start");
exit(1);
}
}
