struct vt_metv* vt_metric_create() { struct vt_metv* metv; int retval, i; if ( nmetrics == 0 ) return NULL; metv = (struct vt_metv*)malloc(sizeof(struct vt_metv)); if ( metv == NULL ) vt_error(); /* create event set */ metv->EventSet = PAPI_NULL; retval = PAPI_create_eventset(&metv->EventSet); if ( retval != PAPI_OK) vt_metric_error(retval, "PAPI_create_eventset"); for ( i = 0; i < nmetrics; i++ ) { /* add event to event set */ retval = PAPI_add_event(metv->EventSet, metricv[i]->papi_code); if ( retval != PAPI_OK ) vt_metric_error(retval, "PAPI_add_event"); } retval = PAPI_start(metv->EventSet); if ( retval != PAPI_OK ) vt_metric_error(retval, "PAPI_start"); /*vt_cntl_msg("Counters started");*/ return metv; }
void papi_init( int argc, char **argv ) { const PAPI_hw_info_t *hwinfo = NULL; tests_quiet( argc, argv ); /* Set TESTS_QUIET variable */ /*for(i=0;i<argc;i++) */ retval = PAPI_library_init( PAPI_VER_CURRENT ); if ( retval != PAPI_VER_CURRENT ) test_fail( __FILE__, __LINE__, "PAPI_library_init", retval ); retval = PAPI_set_debug( PAPI_VERB_ECONT ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_set_debug", retval ); retval = papi_print_header ( "Event Chooser: Available events which can be added with given events.\n", 0, &hwinfo ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_get_hardware_info", 2 ); retval = PAPI_create_eventset( &EventSet ); if ( retval != PAPI_OK ) { fprintf( stderr, "PAPI_create_eventset error\n" ); exit( 1 ); } }
void initialize_papi (int eventCode) { /* Initialize the PAPI library */ retval = PAPI_library_init(PAPI_VER_CURRENT); if (retval != PAPI_VER_CURRENT) { fprintf(stderr, "PAPI library init error! %d\n",PAPI_EINVAL); handle_error(1); } if (EventSet==PAPI_NULL) { if (PAPI_create_eventset(&EventSet) != PAPI_OK) { printf("PAPI create eventset error\n"); handle_error(1); } } else { if (PAPI_cleanup_eventset(EventSet) != PAPI_OK) { printf("PAPI cleanup error\n"); handle_error(1); } } if (PAPI_add_event(EventSet, eventCode) != PAPI_OK) { printf("PAPI add event error: %x\n", eventCode); handle_error(1); } }
int check_papi_counter(char * counter_name) { PAPI_event_info_t * info; int EventSet = PAPI_NULL; unsigned int event_code = 0x0; int err; if ((err=PAPI_create_eventset (&EventSet)) != PAPI_OK){ fprintf(stderr,"Failed to create a PAPI eventset\n"); exit(1); } if((err = PAPI_event_name_to_code(counter_name,&event_code)) != PAPI_OK){ return err; } if((err = PAPI_add_event (EventSet, event_code)) != PAPI_OK) { return err; } PAPI_remove_named_event (EventSet, counter_name); if ( PAPI_destroy_eventset( &EventSet ) != PAPI_OK ){ printf("********** Call to destroy eventset failed when trying to validate event '%s' **********\n", counter_name); } return err; }
JNIEXPORT jint JNICALL Java_papi_Wrapper_eventSetCreate (JNIEnv *env, jclass UNUSED_ARG(self), jlongArray eventsetidoutarr) { if (eventsetidoutarr == NULL) { return PAPI_EINVAL; } if ((*env)->GetArrayLength(env, eventsetidoutarr) != 1) { return PAPI_EINVAL; } int eventset = PAPI_NULL; int rc = PAPI_create_eventset(&eventset); if (rc != PAPI_OK) { return rc; } jlong *eventsetidoutj = (*env)->GetLongArrayElements(env, eventsetidoutarr, NULL); long long *eventsetidout = (long long *) eventsetidoutj; eventsetidout[0] = eventset; (*env)->ReleaseLongArrayElements(env, eventsetidoutarr, eventsetidoutj, JNI_COMMIT); DEBUG_PRINT("new eventset is %d", eventset); return PAPI_OK; }
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); } }
void papi_init(int eventNumber){ if (PAPI_library_init(PAPI_VER_CURRENT) != PAPI_VER_CURRENT) { fprintf(stderr, "PAPI is unsupported.\n"); papi_supported = false; } if (PAPI_num_counters() < 5) { fprintf(stderr, "PAPI is unsupported.\n"); papi_supported = false; } if ((papi_err = PAPI_create_eventset(&eventSet)) != PAPI_OK) { fprintf(stderr, "Could not create event set: %s\n", PAPI_strerror(papi_err)); } /* force program to run on a single CPU */ cpu_set_t my_set; /* Define your cpu_set bit mask. */ CPU_ZERO(&my_set); /* Initialize it all to 0, i.e. no CPUs selected. */ CPU_SET(0, &my_set); if (sched_setaffinity(0, sizeof(cpu_set_t), &my_set) != 0) { perror("sched_setaffinity error"); } if ((papi_err = PAPI_add_event(eventSet, events[eventNumber])) != PAPI_OK ) { fprintf(stderr, "Could not add event: %s\n", PAPI_strerror(papi_err)); } }
void my_papi_start( int myrank ) { #ifdef PAPI_MONITOR int retval, index ; char EventCodeStr[PAPI_MAX_STR_LEN]; if(myrank == 0) DO_TEST = 1; retval = PAPI_library_init(PAPI_VER_CURRENT); if (retval != PAPI_VER_CURRENT) { fprintf(stderr, "PAPI library init error! %d\n", retval); exit(1); } fprintf(stderr,"PAPI Library start ...\n"); if (PAPI_create_eventset(&PAPI_EventSet) != PAPI_OK) exit(1); for (index = 0 ; index < NEVENTS ; index ++) { PAPI_event_code_to_name(PAPI_events[index], EventCodeStr); /*fprintf(stderr,"Adding event %s ... ",EventCodeStr); */ if (PAPI_add_event(PAPI_EventSet,PAPI_events[index]) != PAPI_OK) exit(1); /*fprintf(stderr," DONE !\n"); */ } /*fprintf(stderr,"\n"); */ if (PAPI_start(PAPI_EventSet) != PAPI_OK) exit(1); #endif /*PAPI_MONITOR */ }
static void vt_metric_test(void) { int i; int retval; int EventSet = PAPI_NULL; /* create event set */ retval = PAPI_create_eventset(&EventSet); if ( retval != PAPI_OK) vt_metric_error(retval, "PAPI_create_eventset"); for ( i = 0; i < nmetrics; i++ ) { /* add event to event set */ retval = PAPI_add_event(EventSet, metricv[i]->papi_code); if ( retval != PAPI_OK ) { char errstring[PAPI_MAX_STR_LEN]; sprintf(errstring, "PAPI_add_event(%d:\"%s\")", i, metricv[i]->name); vt_metric_error(retval, errstring); } vt_cntl_msg("Event %s added to event set", metricv[i]->name); } retval = PAPI_cleanup_eventset(EventSet); if ( retval != PAPI_OK ) vt_metric_error(retval, "PAPI_cleanup_eventset"); retval = PAPI_destroy_eventset(&EventSet); if ( retval != PAPI_OK ) vt_metric_error(retval, "PAPI_destroy_eventset"); vt_cntl_msg("Event set tested OK"); }
void start_papi() { values = calloc(en, sizeof(long long)); if (PAPI_library_init(PAPI_VER_CURRENT) != PAPI_VER_CURRENT) { fprintf(stderr, "PAPI is unsupported.\n"); papi_supported = 0; } if (PAPI_num_counters() < en) { fprintf(stderr, "PAPI is unsupported.\n"); papi_supported = 0; } if ((papi_err = PAPI_create_eventset(&eventSet)) != PAPI_OK) { fprintf(stderr, "Could not create event set: %s\n", PAPI_strerror(papi_err)); } for (int i=0; i<en; ++i) { if ((papi_err = PAPI_add_event(eventSet, events[i])) != PAPI_OK ) { fprintf(stderr, "Could not add event: %s %s\n", event_names[i], PAPI_strerror(papi_err)); } } /* start counters */ if (papi_supported) { if ((papi_err = PAPI_start(eventSet)) != PAPI_OK) { fprintf(stderr, "Could not start counters: %s\n", PAPI_strerror(papi_err)); } } }
MeasureTimePAPI::MeasureTimePAPI(unsigned long int (*threadHandle)()) : MeasureTime(), threadHandle(threadHandle) { _events = new int[NUM_PAPI_EVENTS]; #ifdef USE_PAPI _events[0] = PAPI_TOT_CYC; _events[1] = PAPI_L2_TCM; _events[2] = PAPI_TOT_INS; _eventSet = PAPI_NULL; int initRetVal = PAPI_library_init(PAPI_VER_CURRENT); if (initRetVal != PAPI_VER_CURRENT && initRetVal > 0) { std::cerr << "PAPI library init failed!" << std::endl; exit(1); } if (PAPI_thread_init(threadHandle) != PAPI_OK) { std::cerr << "PAPI thread init failed!" << std::endl; exit(1); } if (PAPI_create_eventset(&_eventSet) != PAPI_OK) { std::cerr << "PAPI create eventset failed!" << " Error: " << PAPI_create_eventset(&_eventSet) << std::endl; exit(1); } if (PAPI_add_events(_eventSet, _events, NUM_PAPI_EVENTS) != PAPI_OK) { std::cerr << "PAPI add events failed!" << std::endl; exit(1); } if (PAPI_start(_eventSet) != PAPI_OK) { std::cerr << "PAPI_start_counters - FAILED" << std::endl; throw ModelicaSimulationError(UTILITY,"PAPI_start_counters - FAILED"); } #else _eventSet = 0; throw ModelicaSimulationError(UTILITY,"Papi not supported!"); #endif }
void compute() { #if PAPI int EventCode, retval; int EventSet = PAPI_NULL; long long PAPI_Counters[MAX_COUNTERS]; /* Initialize the library */ retval = PAPI_library_init(PAPI_VER_CURRENT); if (retval != PAPI_VER_CURRENT) { fprintf(stderr, "PAPI library init error!\n"); exit(1); } /* PAPI create event */ if (PAPI_create_eventset(&EventSet) != PAPI_OK) { fprintf(stderr, "create event set: %s", PAPI_strerror(retval)); } for (int i = 0; i < NUMCOUNTERS; i++) { if ( (retval = PAPI_add_named_event(EventSet, events[i])) != PAPI_OK) { fprintf(stderr, "add named event: %s", PAPI_strerror(retval)); } } retval = PAPI_start(EventSet); #endif float matice1[rozmer][rozmer]; float matice2[rozmer][rozmer]; float matice3[rozmer][rozmer]; //Main multiply code int j,k,m; for(j = 0; j < rozmer; j++) { for (k = 0; k < rozmer; k++) { float temp = 0; for (m = 0; m < rozmer; m++) { temp = temp + matice1[j][m] * matice2[m][k]; } matice3[j][k] = temp; } } #if PAPI retval = PAPI_stop(EventSet, PAPI_Counters); if (retval != PAPI_OK) exit(1); for (int j = 0; j < NUMCOUNTERS; j++) { printf("%20lld %s\n", PAPI_Counters[j], events[j]); // fprintf(stderr, "%lld\n ", PAPI_Counters[j]); } #endif }
int main( int argc, char **argv ) { double c, a = 0.999, b = 1.001; int n = 1000; int EventSet = PAPI_NULL; int retval; int i, j = 0; long long g1[2]; tests_quiet( argc, argv ); /* Set TESTS_QUIET variable */ if ( ( retval = PAPI_library_init( PAPI_VER_CURRENT ) ) != PAPI_VER_CURRENT ) test_fail( __FILE__, __LINE__, "PAPI_library_init", retval ); if ( ( retval = PAPI_create_eventset( &EventSet ) ) != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_create_eventset", retval ); if ( PAPI_query_event( PAPI_L2_TCM ) == PAPI_OK ) j++; if ( j == 1 && ( retval = PAPI_add_event( EventSet, PAPI_L2_TCM ) ) != PAPI_OK ) { if ( retval != PAPI_ECNFLCT ) test_fail( __FILE__, __LINE__, "PAPI_add_event", retval ); j--; /* The event was not added */ } i = j; if ( PAPI_query_event( PAPI_L2_DCM ) == PAPI_OK ) j++; if ( j == ( i + 1 ) && ( retval = PAPI_add_event( EventSet, PAPI_L2_DCM ) ) != PAPI_OK ) { if ( retval != PAPI_ECNFLCT ) test_fail( __FILE__, __LINE__, "PAPI_add_event", retval ); j--; /* The event was not added */ } if ( j ) { if ( ( retval = PAPI_start( EventSet ) ) != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_start", retval ); for ( i = 0; i < n; i++ ) { c = a * b; } if (!TESTS_QUIET) fprintf(stdout,"c=%lf\n",c); if ( ( retval = PAPI_stop( EventSet, g1 ) ) != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_stop", retval ); } test_pass( __FILE__, NULL, 0 ); 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 ); }
/* Test whether requested event combination valid */ static void metric_test(void) { int i, j; int retval; int component; struct eventmap_t * EventSet[VT_METRIC_MAXNUM]; for (i=0; i<VT_METRIC_MAXNUM; i++) EventSet[i] = NULL; for (i=0; i < nmetrics; i++) { #ifdef PAPIC /* Preset-counter belong to Component 0! */ component = PAPI_COMPONENT_INDEX(metricv[i]->papi_code); #else component = 0; #endif /* search for the eventset that matches the counter */ j=0; while (EventSet[j]!=NULL && j < VT_METRIC_MAXNUM && EventSet[j]->ComponentId!=component){ j++; } if (EventSet[j]==NULL) /* create eventset, if no matching found */ { EventSet[j] = malloc(sizeof(eventmap_t)); EventSet[j]->EventId=PAPI_NULL; retval = PAPI_create_eventset(&(EventSet[j]->EventId)); if ( retval != PAPI_OK) metric_error(retval, "PAPI_create_eventset"); EventSet[j]->ComponentId=component; } /* add event to event set */ retval = PAPI_add_event(EventSet[j]->EventId, metricv[i]->papi_code); if ( retval != PAPI_OK ) { char errstring[PAPI_MAX_STR_LEN]; sprintf(errstring, "PAPI_add_event(%d:\"%s\")", i, metricv[i]->name); metric_error(retval, errstring); } vt_cntl_msg(2, "Event %s added to event set", metricv[i]->name); } /* foreach used eventset */ for (i=0; i < VT_METRIC_MAXNUM && EventSet[i]!=NULL; i++) { retval = PAPI_cleanup_eventset(EventSet[i]->EventId); if ( retval != PAPI_OK ) metric_error(retval, "PAPI_cleanup_eventset"); retval = PAPI_destroy_eventset(&(EventSet[i]->EventId)); if ( retval != PAPI_OK ) metric_error(retval, "PAPI_destroy_eventset"); free(EventSet[i]); } vt_cntl_msg(2, "Event set tested OK"); }
void * my_thread( void *v ) { long num = ( long ) v; int n; int EventSet = PAPI_NULL; long long value; int retval = PAPI_register_thread( ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_register_thread", retval ); pthread_setspecific( key, v ); count[num] = 0; iter[num] = 0; last[num] = start; if ( PAPI_create_eventset( &EventSet ) != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_create_eventset failed", 1 ); if ( PAPI_add_event( EventSet, EVENT ) != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_add_event failed", 1 ); if ( PAPI_overflow( EventSet, EVENT, threshold, 0, my_handler ) != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_overflow failed", 1 ); if ( PAPI_start( EventSet ) != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_start failed", 1 ); printf( "launched timer in thread %ld\n", num ); for ( n = 1; n <= program_time; n++ ) { do_cycles( num, 1 ); print_rate( num ); } PAPI_stop( EventSet, &value ); retval = PAPI_overflow( EventSet, EVENT, 0, 0, my_handler); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_overflow failed to reset the overflow handler", retval ); if ( PAPI_remove_event( EventSet, EVENT ) != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_remove_event", 1 ); if ( PAPI_destroy_eventset( &EventSet ) != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_destroy_eventset", 1 ); if ( PAPI_unregister_thread( ) != PAPI_OK != retval ) test_fail( __FILE__, __LINE__, "PAPI_unregister_thread", 1 ); return ( NULL ); }
void compute(int *sequence) { #if PAPI int EventCode, retval; int EventSet = PAPI_NULL; long long PAPI_Counters[MAX_COUNTERS]; /* Initialize the library */ retval = PAPI_library_init(PAPI_VER_CURRENT); if (retval != PAPI_VER_CURRENT) { fprintf(stderr, "PAPI library init error!\n"); exit(1); } /* PAPI create event */ if (PAPI_create_eventset(&EventSet) != PAPI_OK) { fprintf(stderr, "create event set: %s", PAPI_strerror(retval)); } int i; for (i = 0; i < NUMCOUNTERS; i++) { if ( (retval = PAPI_add_named_event(EventSet, events[i])) != PAPI_OK) { fprintf(stderr, "add named event: %s", PAPI_strerror(retval)); } } retval = PAPI_start(EventSet); #endif float matice1[SEQUENCE_CNT]; float matice2[SEQUENCE_CNT]; int j, idx; for(j = 0; j < SEQUENCE_CNT; j++) { idx = sequence[j]; matice2[idx] = 13 % (idx + 1); matice1[idx] = matice2[idx] * 231; // printf("%d\t", idx); } //printf("\n"); #if PAPI retval = PAPI_stop(EventSet, PAPI_Counters); if (retval != PAPI_OK) exit(1); int k; for (k = 0; k < NUMCOUNTERS; k++) { printf("%20lld %s\n", PAPI_Counters[k], events[k]); // fprintf(stderr, "%lld\n ", PAPI_Counters[k]); } #endif }
void start_EVENTPAPI(int ind, int EventCode) { /* Create the Event Set */ if (PAPI_create_eventset(&oscrData_timerPAPIEventSet[ind]) != PAPI_OK) OSCR_error("PAPI create eventset error!\n", -1); /* Add Total Instructions Executed to our EventSet */ if (PAPI_add_event(&oscrData_timerPAPIEventSet[ind], EventCode) != PAPI_OK) OSCR_error("PAPI add events error!\n", -1); if (PAPI_start(oscrData_timerPAPIEventSet[ind]) != PAPI_OK) OSCR_error("PAPI start init error!\n", -1); }
/* CheckInOrder Check if we can add all the counters in the order given. This will just iterate through all counters trying to add them in the eventset. */ void CheckInOrder (int ncounters, unsigned *counters) { int rc; int i; int naddedcounters; int EventSet = PAPI_NULL; char EventName[PAPI_MAX_STR_LEN]; #if 0 fprintf (stdout, "\n** Checking in order the following counters: "); for (i = 0; i < ncounters; i++) { rc = PAPI_event_code_to_name (counters[i], EventName); if (rc == PAPI_OK) fprintf (stdout, "%s%s", i>0?",":"", EventName); else fprintf (stdout, "%s%08x", i>0?",":"", counters[i]); } fprintf (stdout, "\n"); #endif if (PAPI_create_eventset(&EventSet) != PAPI_OK) { fprintf (stderr, "Error! Failed to create the eventset!\n"); return; } fprintf (stdout, "Suggested compatible counters preserving the given priority:\n"); for (naddedcounters = 0, i = 0; i < ncounters; i++) { if (PAPI_add_event (EventSet, counters[i]) == PAPI_OK) { rc = PAPI_event_code_to_name (counters[i], EventName); if (rc == PAPI_OK) fprintf (stdout, "%s%s", i>0?",":"", EventName); else fprintf (stdout, "%s%08x", i>0?",":"", counters[i]); naddedcounters++; } } if (naddedcounters > 0) fprintf (stdout, " (set of %d counters)\n\n", naddedcounters); else fprintf (stdout, "NONE!\n\n"); if (PAPI_cleanup_eventset(EventSet) != PAPI_OK) fprintf (stderr, "Error! Failed to cleanup the eventset\n"); if (PAPI_destroy_eventset (&EventSet) != PAPI_OK) fprintf (stderr, "Error! Failed to destroy the eventset\n"); }
void Timing::setPapiEvents(std::vector<std::string> names){ #ifdef KRIPKE_USE_PAPI static bool papi_initialized = false; if(!papi_initialized){ //printf("PAPI INIT\n"); int retval = PAPI_library_init(PAPI_VER_CURRENT); papi_initialized = true; if(retval != PAPI_VER_CURRENT){ fprintf(stderr, "ERROR INITIALIZING PAPI\n"); exit(1); } } //printf("PAPI VERSION=%x\n", // PAPI_VERSION); papi_set = PAPI_NULL; PAPI_create_eventset(&papi_set); for(int i = 0;i < names.size();++ i){ // Convert text string to PAPI id int event_code; PAPI_event_name_to_code( const_cast<char*>(names[i].c_str()), &event_code); // TODO: error checking? // Add to our list of PAPI events papi_names.push_back(names[i]); papi_event.push_back(event_code); int retval = PAPI_add_event(papi_set, event_code); if(retval != PAPI_OK){ fprintf(stderr, "ERROR ADDING %s, retval=%d, ID=0x%-10x\n", names[i].c_str(), retval, event_code); } //printf("EVT=%s, ID=0x%-10x\n", names[i].c_str(), event_code); } PAPI_start(papi_set); #else if(names.size() > 0){ fprintf(stderr, "WARNING: PAPI NOT ENABLED, IGNORING PAPI EVENTS\n"); } #endif }
int MBStartPAPI(void) { system("rm -f *.mbo"); #ifdef EXETIME gettimeofday(&MB_Start, NULL); #else MB_EventSet = PAPI_NULL; PAPI_library_init(PAPI_VER_CURRENT); PAPI_create_eventset(&MB_EventSet); PAPI_add_event(MB_EventSet, PAPI_TOT_CYC); PAPI_start(MB_EventSet); #endif return 0; }
perf_t* perf_init() { int retval; int EventSet = PAPI_NULL; retval = PAPI_create_eventset(&EventSet); assert(retval == PAPI_OK); retval = PAPI_assign_eventset_component(EventSet, 0); assert(retval == PAPI_OK); /* By default, the counter is inherited. */ PAPI_option_t opt; memset(&opt, 0x0, sizeof(PAPI_option_t)); opt.inherit.inherit = PAPI_INHERIT_ALL; opt.inherit.eventset = EventSet; retval = PAPI_set_opt(PAPI_INHERIT, &opt); assert(retval == PAPI_OK); /* Add events by names */ for (int i = 0; i < NUM_EVENTS; i++) { int EventCode; if ((retval = PAPI_event_name_to_code(PERF_EVENT_NAMES[i], &EventCode)) != PAPI_OK) { fprintf(stderr, "Event name %s not found, skipped.\n", PERF_EVENT_NAMES[i]); continue; } if ((retval = PAPI_query_event(EventCode)) != PAPI_OK) { fprintf(stderr, "Event %s not supported on this hardware, skipped.\n", PERF_EVENT_NAMES[i]); continue; } if ((retval = PAPI_add_event(EventSet, EventCode)) != PAPI_OK) { assert(retval == PAPI_ECNFLCT); fprintf(stderr, "%s conflicts, skipped.\n", PERF_EVENT_NAMES[i]); } } perf_t *perf = (perf_t*)malloc(sizeof(perf_t)); perf->EventSet = EventSet; /* perf->values = (counter_t*)malloc(sizeof(counter_t) * NUM_EVENTS); */ /* memset(perf->values, 0x0, sizeof(counter_t) * NUM_EVENTS); */ return perf; }
struct esd_metv* esd_metric_create() { struct esd_metv* metv; int retval, i, /* KF */ comp; if ( nmetrics == 0 ) return NULL; metv = malloc(sizeof(struct esd_metv)); if ( metv == NULL ) elg_error(); /* create event set */ /* KF: create one per component */ for( i=0; i<ELG_PAPIC_MAX_COMP; i++ ) { metv->EventSet[i] = PAPI_NULL; metv->NumEvents[i] = 0; retval = PAPI_create_eventset(&metv->EventSet[i]); if ( retval != PAPI_OK) esd_metric_error(retval, "PAPI_create_eventset"); } for ( i = 0; i < nmetrics; i++ ) { /* add event to event set */ /* KF: figure out the right component and track mapping*/ comp = PAPI_COMPONENT_INDEX( metricv[i]->papi_code ); metv->Comp2Metr[comp][metv->NumEvents[comp]]=i; retval = PAPI_add_event(metv->EventSet[comp], metricv[i]->papi_code); if ( retval != PAPI_OK ) esd_metric_error(retval, "PAPI_add_event"); else /* KF: success */ metv->NumEvents[comp]++; } /* KF: start only those event sets with events added */ for( i=0; i<ELG_PAPIC_MAX_COMP; i++ ) { if( metv->NumEvents[i]>0 ) { retval = PAPI_start(metv->EventSet[i]); if ( retval != PAPI_OK ) esd_metric_error(retval, "PAPI_start"); } } elg_cntl_msg("Counters started"); return metv; }
void papi_init_eventset(pid_t pid, int *EventSet) { int retval; if ( (retval = PAPI_create_eventset(EventSet) ) != PAPI_OK) { fprintf(stderr, "PAPI EventSet init error!\n%s\n", PAPI_strerror(retval)); } if ( (retval = PAPI_add_events(*EventSet, global_config.native_events, global_config.nb_papi_events) ) != PAPI_OK) { fprintf(stderr, "PAPI add events error!\n%s\n", PAPI_strerror(retval)); } if ( (retval = PAPI_attach(*EventSet, pid) ) != PAPI_OK) { fprintf(stderr, "PAPI attach error!\n%s\n", PAPI_strerror(retval)); } }
void start_record_cache_access() { int retVal = PAPI_library_init(PAPI_VER_CURRENT); assert(retVal == PAPI_VER_CURRENT); EventSet = PAPI_NULL; retVal = PAPI_create_eventset(&g_event_set); assert(retVal == PAPI_OK); retVal = PAPI_add_event(g_event_set, PAPI_L1_TCM); assert(retVal == PAPI_OK); retVal = PAPI_start(g_event_set); assert(retVal == PAPI_OK); retVal = PAPI_read(g_event_set, startRecords); assert(retVal == PAPI_OK); }
void initialize() { int ret; ret = PAPI_library_init(PAPI_VER_CURRENT); if (ret != PAPI_VER_CURRENT) { fprintf(stderr, "PAPI API 'PAPU_library_init' error !\n"); exit(1); } fprintf(stdout, "PAPI_VERSION: %d.%d.%d\n", PAPI_VERSION_MAJOR( PAPI_VERSION ), PAPI_VERSION_MINOR( PAPI_VERSION ), PAPI_VERSION_REVISION( PAPI_VERSION ) ); ret = PAPI_create_eventset(&eventSet); CHECK_PAPI_ERROR(ret, "PAPI_create_eventset"); }
void event_create_eventList(int *eventSet, int eventCodeSetSize, int *eventCodeSet, int threadID) { int retval, i, maxNumberHwCounters, eventCodeSetMaxSize; PAPI_event_info_t info; maxNumberHwCounters = PAPI_get_opt( PAPI_MAX_HWCTRS, NULL ); printf("Max number of hardware counters = %d \n", maxNumberHwCounters); eventCodeSetMaxSize = PAPI_get_opt( PAPI_MAX_MPX_CTRS, NULL ); printf("Max number of multiplexed counters = %d \n", eventCodeSetMaxSize); if ( eventCodeSetMaxSize < eventCodeSetSize) test_fail( __FILE__, __LINE__, "eventCodeSetMaxSize < eventCodeSetSize, too many performance events defined! ", retval ); retval = PAPI_register_thread(); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_register_thread", retval ); retval = PAPI_create_eventset( eventSet ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_create_eventset", retval ); retval = PAPI_assign_eventset_component( *eventSet, 0 ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_assign_eventset_component", retval ); retval = PAPI_set_multiplex( *eventSet ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_set_multiplex", retval ); for (i = 0; i < eventCodeSetSize; i++) { retval = PAPI_get_event_info(eventCodeSet[i], &info); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_get_event_info", retval ); retval = PAPI_add_event( *eventSet, info.event_code); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_add_event", retval ); else printf("Adding %s \n", info.symbol); } printf("event_create_eventList done \n"); }
void inline papi_init() { int papi_version = PAPI_library_init(PAPI_VER_CURRENT); check(papi_version != PAPI_VER_CURRENT && papi_version > 0, ERR_PAPI_INIT); check(papi_version < 0, ERR_PAPI_INIT2); event_set = PAPI_NULL; papi_safe(PAPI_create_eventset(&event_set), ERR_PAPI_EVENT_SET); //PAPI_event_info_t inf; papi_safe(PAPI_get_event_info(papi_events[current_event], &inf),ERR_PAPI_GET_EVENT_INFO); papi_safe(PAPI_add_event(event_set, papi_events[current_event]), ERR_PAPI_ADD_EVENT); start_time = PAPI_get_virt_usec(); }
void flops_init() { #ifdef HAVE_PAPI int err = PAPI_library_init( PAPI_VER_CURRENT ); if ( err != PAPI_VER_CURRENT ) { fprintf( stderr, "Error: PAPI couldn't initialize: %s (%d)\n", PAPI_strerror(err), err ); } // read flops err = PAPI_create_eventset( &gPAPI_flops_set ); if ( err != PAPI_OK ) { fprintf( stderr, "Error: PAPI_create_eventset failed\n" ); } err = PAPI_assign_eventset_component( gPAPI_flops_set, 0 ); if ( err != PAPI_OK ) { fprintf( stderr, "Error: PAPI_assign_eventset_component failed: %s (%d)\n", PAPI_strerror(err), err ); } PAPI_option_t opt; memset( &opt, 0, sizeof(PAPI_option_t) ); opt.inherit.inherit = PAPI_INHERIT_ALL; opt.inherit.eventset = gPAPI_flops_set; err = PAPI_set_opt( PAPI_INHERIT, &opt ); if ( err != PAPI_OK ) { fprintf( stderr, "Error: PAPI_set_opt failed: %s (%d)\n", PAPI_strerror(err), err ); } err = PAPI_add_event( gPAPI_flops_set, PAPI_FP_OPS ); if ( err != PAPI_OK ) { fprintf( stderr, "Error: PAPI_add_event failed: %s (%d)\n", PAPI_strerror(err), err ); } err = PAPI_start( gPAPI_flops_set ); if ( err != PAPI_OK ) { fprintf( stderr, "Error: PAPI_start failed: %s (%d)\n", PAPI_strerror(err), err ); } #endif // HAVE_PAPI }
int main() { /*@ prologue @*/ long long orio_total_cycles = 0; long long orio_avg_cycles; int orio_i; for (orio_i=0; orio_i<REPS; orio_i++) { int err, EventSet = PAPI_NULL; long long CtrValues[1]; err = PAPI_library_init(PAPI_VER_CURRENT); if (err != PAPI_VER_CURRENT) { printf("PAPI library initialization error!\n"); exit(1); } if (PAPI_create_eventset(&EventSet) != PAPI_OK) { printf("Failed to create PAPI Event Set\n"); exit(1); } if (PAPI_query_event(PAPI_TOT_CYC) == PAPI_OK) err = PAPI_add_event(EventSet, PAPI_TOT_CYC); if (err != PAPI_OK) { printf("Failed to add PAPI event\n"); exit(1); } PAPI_start(EventSet); /*@ tested code @*/ PAPI_stop(EventSet, &CtrValues[0]); orio_total_cycles += CtrValues[0]; } orio_avg_cycles = orio_total_cycles / REPS; printf("%ld\n", orio_avg_cycles); printf("{'/*@ coordinate @*/' : %ld}", orio_avg_cycles); /*@ epilogue @*/ return y[0]; // to avoid the dead code elimination }