void papi_start(){ if (papi_supported) { if ((papi_err = PAPI_start(eventSet)) != PAPI_OK) { fprintf(stderr, "Could not start counters: %s\n", PAPI_strerror(papi_err)); } } }
void event_start(int *eventSet, int threadID){ int retval; retval = PAPI_start( *eventSet ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_start",retval ); }
void Thread( int t, int n ) { int retval, num_tests = 1; int EventSet1 = PAPI_NULL; int PAPI_event, mask1; int num_events1; long long **values; long long elapsed_us, elapsed_cyc; char event_name[PAPI_MAX_STR_LEN]; /* add PAPI_TOT_CYC and one of the events in PAPI_FP_INS, PAPI_FP_OPS or PAPI_TOT_INS, depending on the availability of the event on the platform */ EventSet1 = add_two_events( &num_events1, &PAPI_event, &mask1 ); retval = PAPI_event_code_to_name( PAPI_event, event_name ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_event_code_to_name", retval ); values = allocate_test_space( num_tests, num_events1 ); retval = PAPI_start( EventSet1 ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_start", retval ); elapsed_us = PAPI_get_real_usec( ); elapsed_cyc = PAPI_get_real_cyc( ); do_flops( n ); elapsed_us = PAPI_get_real_usec( ) - elapsed_us; elapsed_cyc = PAPI_get_real_cyc( ) - elapsed_cyc; retval = PAPI_stop( EventSet1, values[0] ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_stop", retval ); remove_test_events( &EventSet1, mask1 ); if ( !TESTS_QUIET ) { printf( "Thread %#x %-12s : \t%lld\n", t, event_name, values[0][1] ); printf( "Thread %#x PAPI_TOT_CYC : \t%lld\n", t, values[0][0] ); } free_test_space( values, num_tests ); if ( !TESTS_QUIET ) { printf( "Thread %#x Real usec : \t%lld\n", t, elapsed_us ); printf( "Thread %#x Real cycles : \t%lld\n", t, elapsed_cyc ); } PAPI_unregister_thread( ); }
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 ); }
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 Thread( int n ){ int retval, num_tests = 1; int EventSet1 = PAPI_NULL; int PAPI_event, mask1; int num_events1; long long **values; long long elapsed_us, elapsed_cyc, L1_DCM; char event_name[PAPI_MAX_STR_LEN]; printf( "Thread %#x started\n", omp_get_thread_num( ) ); num_events1 = 2; EventSet1 = add_two_events( &num_events1, &PAPI_event, &mask1 ); retval = PAPI_event_code_to_name( PAPI_event, event_name ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_event_code_to_name", retval ); values = allocate_test_space( num_tests, num_events1 ); elapsed_us = PAPI_get_real_usec( ); elapsed_cyc = PAPI_get_real_cyc( ); retval = PAPI_start( EventSet1 ); do_flops( n ); retval = PAPI_stop( EventSet1, values[0] ); elapsed_us = PAPI_get_real_usec( ) - elapsed_us; elapsed_cyc = PAPI_get_real_cyc( ) - elapsed_cyc; remove_test_events( &EventSet1, mask1 ); if ( !TESTS_QUIET ) { printf( "Thread %#x %-12s : \t%lld\n", omp_get_thread_num( ), event_name, values[0][1] ); printf( "Thread %#x PAPI_TOT_CYC: \t%lld\n", omp_get_thread_num( ), values[0][0] ); printf( "Thread %#x Real usec : \t%lld\n", omp_get_thread_num( ), elapsed_us ); printf( "Thread %#x Real cycles : \t%lld\n", omp_get_thread_num( ), elapsed_cyc ); } free_test_space( values, num_tests ); PAPI_unregister_thread( ); printf( "Thread %#x finished\n", omp_get_thread_num( ) ); }
static void reset_flops( char *title, int EventSet ) { int retval; char err_str[PAPI_MAX_STR_LEN]; retval = PAPI_start( EventSet ); if ( retval != PAPI_OK ) { sprintf( err_str, "%s: PAPI_start", title ); test_fail( __FILE__, __LINE__, err_str, retval ); } }
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); }
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; }
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 }
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 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 Thread( int n ) { int retval, num_tests = 1, tmp; int EventSet1 = PAPI_NULL; int mask1 = 0x5; int num_events1; long long **values; long long elapsed_us, elapsed_cyc; EventSet1 = add_test_events( &num_events1, &mask1 ); /* num_events1 is greater than num_events2 so don't worry. */ values = allocate_test_space( num_tests, num_events1 ); elapsed_us = PAPI_get_real_usec( ); elapsed_cyc = PAPI_get_real_cyc( ); retval = PAPI_start( EventSet1 ); if ( retval >= PAPI_OK ) exit( 1 ); do_flops( n ); retval = PAPI_stop( EventSet1, values[0] ); if ( retval >= PAPI_OK ) exit( 1 ); elapsed_us = PAPI_get_real_usec( ) - elapsed_us; elapsed_cyc = PAPI_get_real_cyc( ) - elapsed_cyc; remove_test_events( &EventSet1, mask1 ); printf( "Thread %#x PAPI_FP_INS : \t%lld\n", pthread_self( ), ( values[0] )[0] ); printf( "Thread %#x PAPI_TOT_CYC: \t%lld\n", pthread_self( ), ( values[0] )[1] ); printf( "Thread %#x Real usec : \t%lld\n", pthread_self( ), elapsed_us ); printf( "Thread %#x Real cycles : \t%lld\n", pthread_self( ), elapsed_cyc ); free_test_space( values, num_tests ); }
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 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 }
void ref_measurements(int iters, int *eventset, int *events, int nevents, long long *refvalues) { PAPI_event_info_t info; int i, retval; double x = 1.1, y; long long t1, t2; printf("PAPI reference measurements:\n"); if ((retval = PAPI_create_eventset(eventset))) test_fail(__FILE__, __LINE__, "PAPI_create_eventset", retval); for (i = 0; i < nevents; i++) { if ((retval = PAPI_add_event(*eventset, events[i]))) test_fail(__FILE__, __LINE__, "PAPI_add_event", retval); x = 1.0; t1 = PAPI_get_real_usec(); if ((retval = PAPI_start(*eventset))) test_fail(__FILE__, __LINE__, "PAPI_start", retval); y = dummy3(x, iters); if ((retval = PAPI_stop(*eventset, &refvalues[i]))) test_fail(__FILE__, __LINE__, "PAPI_stop", retval); t2 = PAPI_get_real_usec(); #if 0 printf("\tOperations= %.1f Mflop", y * 1e-6); printf("\t(%g Mflop/s)\n\n", ((float) y / (t2 - t1))); #endif PAPI_get_event_info(events[i], &info); printf("%20s = ", info.short_descr); printf(LLDFMT, refvalues[i]); printf("\n"); if ((retval = PAPI_cleanup_eventset(*eventset))) test_fail(__FILE__, __LINE__, "PAPI_cleanup_eventset", retval); } if ((retval = PAPI_destroy_eventset(eventset))) test_fail(__FILE__, __LINE__, "PAPI_destroy_eventset", retval); *eventset = PAPI_NULL; }
void pwr_start_energy_count(pwr_ctx_t *ctx) { if (ctx == NULL) { ctx->error = PWR_INIT_ERR; return; } if (!pwr_is_initialized(ctx, PWR_MODULE_ENERGY)) { ctx->error = PWR_UNINITIALIZED; return; } ctx->error = PWR_OK; if (ctx->emeas_running) { pwr_stop_energy_count(ctx); } PAPI_reset(ctx->event_set); ctx->emeas->duration = PAPI_get_real_nsec(); ctx->emeas_running = true; PAPI_start(ctx->event_set); }
static void papiBegin() { int rv; // Init library if (!isInit) { rv = PAPI_library_init(PAPI_VER_CURRENT); if (rv != PAPI_VER_CURRENT && rv < 0) { std::cout << "PAPI library version mismatch!\n"; abort(); } if (rv < 0) handle_error(rv); isInit = true; } //setup counters /* Create the Event Set */ if ((rv = PAPI_create_eventset(&papiEventSet)) != PAPI_OK) handle_error(rv); if ((rv = PAPI_add_events(papiEventSet, papiEvents, 2)) != PAPI_OK) handle_error(rv); /* Start counting events in the Event Set */ if ((rv = PAPI_start(papiEventSet)) != PAPI_OK) handle_error(rv); }
void test_papi_initialize(struct test_statistics_t *test_stat) { int test_counter_types[] = { PAPI_FP_OPS, PAPI_L1_DCM }; test_stat->num_counters = sizeof(test_counter_types) / sizeof(int); test_stat->counters = (long long *) malloc(sizeof(long long) * test_stat->num_counters); test_stat->event_set = PAPI_NULL; int retval; if ((retval = PAPI_create_eventset((&test_stat->event_set))) != PAPI_OK ) test_fail(__FILE__, __LINE__, "PAPI_creat_eventset", retval); if ((retval = PAPI_add_events(test_stat->event_set, test_counter_types, test_stat->num_counters)) != PAPI_OK) test_fail(__FILE__, __LINE__, "PAPI_add_events", retval); if ((retval = PAPI_start(test_stat->event_set)) != PAPI_OK) test_fail(__FILE__, __LINE__, "PAPI_start", retval); }
void * thread( void *arg ) { ( void ) arg; /*unused */ int eventset = PAPI_NULL; long long values[PAPI_MPX_DEF_DEG]; int ret = PAPI_register_thread( ); if ( ret != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_register_thread", ret ); ret = PAPI_create_eventset( &eventset ); if ( ret != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_create_eventset", ret ); printf( "Event set %d created\n", eventset ); /* In Component PAPI, EventSets must be assigned a component index before you can fiddle with their internals. 0 is always the cpu component */ ret = PAPI_assign_eventset_component( eventset, 0 ); if ( ret != PAPI_OK ) { test_fail( __FILE__, __LINE__, "PAPI_assign_eventset_component", ret ); } ret = PAPI_set_multiplex( eventset ); if ( ret == PAPI_ENOSUPP) { test_skip( __FILE__, __LINE__, "Multiplexing not supported", 1 ); } else if ( ret != PAPI_OK ) { test_fail( __FILE__, __LINE__, "PAPI_set_multiplex", ret ); } ret = PAPI_add_events( eventset, events, numevents ); if ( ret < PAPI_OK ) { test_fail( __FILE__, __LINE__, "PAPI_add_events", ret ); } ret = PAPI_start( eventset ); if ( ret != PAPI_OK ) { test_fail( __FILE__, __LINE__, "PAPI_start", ret ); } do_stuff( ); ret = PAPI_stop( eventset, values ); if ( ret != PAPI_OK ) { test_fail( __FILE__, __LINE__, "PAPI_stop", ret ); } ret = PAPI_cleanup_eventset( eventset ); if ( ret != PAPI_OK ) { test_fail( __FILE__, __LINE__, "PAPI_cleanup_eventset", ret ); } ret = PAPI_destroy_eventset( &eventset ); if ( ret != PAPI_OK ) { test_fail( __FILE__, __LINE__, "PAPI_destroy_eventset", ret ); } ret = PAPI_unregister_thread( ); if ( ret != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_unregister_thread", ret ); return ( NULL ); }
int main( int argc, char **argv ) { int EventSet = PAPI_NULL; long long values0[2],values1[2],values2[2]; int num_flops = 3000000, retval; int mythreshold = 1000000; char event_name1[PAPI_MAX_STR_LEN]; int PAPI_event; int cid,numcmp,rapl_cid; const PAPI_component_info_t *cmpinfo = NULL; /* Set TESTS_QUIET variable */ tests_quiet( argc, argv ); quiet=TESTS_QUIET; /* Init PAPI */ retval = PAPI_library_init( PAPI_VER_CURRENT ); if ( retval != PAPI_VER_CURRENT ) { test_fail(__FILE__, __LINE__,"PAPI_library_init",retval); } numcmp = PAPI_num_components(); for(cid=0; cid<numcmp; cid++) { if ( (cmpinfo = PAPI_get_component_info(cid)) == NULL) { test_fail(__FILE__, __LINE__,"PAPI_get_component_info failed\n", 0); } if (strstr(cmpinfo->name,"linux-rapl")) { rapl_cid=cid; if (!TESTS_QUIET) printf("Found rapl component at cid %d\n", rapl_cid); if (cmpinfo->num_native_events==0) { test_skip(__FILE__,__LINE__,"No rapl events found",0); } break; } } /* Component not found */ if (cid==numcmp) { test_skip(__FILE__,__LINE__,"No rapl component found\n",0); } /* add PAPI_TOT_CYC and PAPI_TOT_INS */ retval=PAPI_create_eventset(&EventSet); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_create_eventset",retval); } retval=PAPI_add_event(EventSet,PAPI_TOT_CYC); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_add_event",retval); } retval=PAPI_add_event(EventSet,PAPI_TOT_INS); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_add_event",retval); } /* Add some RAPL events */ retval=PAPI_create_eventset(&EventSet2); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_create_eventset",retval); } retval=PAPI_add_named_event(EventSet2,"PACKAGE_ENERGY:PACKAGE0"); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_add_event",retval); } retval=PAPI_add_named_event(EventSet2,"PACKAGE_ENERGY:PACKAGE1"); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_add_event",retval); } PAPI_event=PAPI_TOT_CYC; /* arbitrary */ mythreshold = 2000000; if (!TESTS_QUIET) { printf("Using %x for the overflow event, threshold %d\n", PAPI_event,mythreshold); } /* Start the run calibration run */ retval = PAPI_start( EventSet ); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_start",retval); } do_ints(num_flops,TESTS_QUIET); do_flops( 3000000 ); /* stop the calibration run */ retval = PAPI_stop( EventSet, values0 ); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_stop",retval); } /* set up overflow handler */ retval = PAPI_overflow( EventSet,PAPI_event,mythreshold, 0, handler ); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_overflow",retval); } /* Start overflow run */ retval = PAPI_start( EventSet ); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_start",retval); } retval = PAPI_start( EventSet2 ); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_start",retval); } do_ints(num_flops,TESTS_QUIET); do_flops( num_flops ); /* stop overflow run */ retval = PAPI_stop( EventSet, values1 ); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_stop",retval); } retval = PAPI_stop( EventSet2, values2 ); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_stop",retval); } retval = PAPI_overflow( EventSet, PAPI_event, 0, 0, handler ); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_overflow",retval); } retval = PAPI_event_code_to_name( PAPI_event, event_name1 ); if (retval != PAPI_OK) { test_fail(__FILE__, __LINE__,"PAPI_event_code_to_name\n", retval); } if (!TESTS_QUIET) { printf("%s: %lld %lld\n",event_name1,values0[0],values1[0]); } retval = PAPI_event_code_to_name( PAPI_TOT_INS, event_name1 ); if (retval != PAPI_OK) { test_fail(__FILE__, __LINE__,"PAPI_event_code_to_name\n",retval); } if (!TESTS_QUIET) { printf("%s: %lld %lld\n",event_name1,values0[1],values1[1]); } retval = PAPI_cleanup_eventset( EventSet ); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_cleanup_eventset",retval); } retval = PAPI_destroy_eventset( &EventSet ); if ( retval != PAPI_OK ) { test_fail(__FILE__, __LINE__,"PAPI_destroy_eventset",retval); } if (rapl_backward) { test_fail(__FILE__, __LINE__,"RAPL counts went backward!",0); } test_pass( __FILE__, NULL, 0 ); return 0; }
struct vt_metv* vt_metric_create() { struct vt_metv* metv; int retval, i,j; int component; if ( nmetrics == 0 ) return NULL; metv = (struct vt_metv*)malloc(sizeof(struct vt_metv)); if ( metv == NULL ) vt_error(); /* create event set */ for (i=0; i<VT_METRIC_MAXNUM; i++) metv->EventSet[i] = NULL; for (i=0; i < nmetrics; i++) { struct eventmap_t *eventset; #ifdef PAPIC component = PAPI_COMPONENT_INDEX(metricv[i]->papi_code); #else component = 0; #endif /* search for the eventset that matches the counter */ j=0; while (metv->EventSet[j]!=NULL && j < VT_METRIC_MAXNUM && metv->EventSet[j]->ComponentId!=component){ j++; } if (metv->EventSet[j]==NULL) /* no event of this component yet! */ { metv->EventSet[j] = (struct eventmap_t*)malloc(sizeof(eventmap_t)); metv->EventSet[j]->EventId=PAPI_NULL; metv->EventSet[j]->nEvents = 0; retval = PAPI_create_eventset(&(metv->EventSet[j]->EventId)); if ( retval != PAPI_OK) metric_error(retval, "PAPI_create_eventset"); metv->EventSet[j]->ComponentId=component; } eventset = metv->EventSet[j]; /* add event to event set */ retval = PAPI_add_event(eventset->EventId, metricv[i]->papi_code); if ( retval != PAPI_OK ) metric_error(retval, "PAPI_add_event"); /* for demux the values from eventset -> returnvector */ metv->Values[i] = &(eventset->Values[eventset->nEvents]); eventset->nEvents++; } /* foreach used eventset */ for (i=0; i < VT_METRIC_MAXNUM && metv->EventSet[i]!=NULL; i++) { retval = PAPI_start(metv->EventSet[i]->EventId); if ( retval != PAPI_OK ) metric_error(retval, "PAPI_start"); } return metv; }
int main (int argc, char **argv) { int retval,cid,rapl_cid=-1,numcmp; int EventSet = PAPI_NULL; long long *values; int num_events=0; int code; char event_names[MAX_RAPL_EVENTS][PAPI_MAX_STR_LEN]; char units[MAX_RAPL_EVENTS][PAPI_MIN_STR_LEN]; int r,i; const PAPI_component_info_t *cmpinfo = NULL; PAPI_event_info_t evinfo; long long before_time,after_time; double elapsed_time; /* Set TESTS_QUIET variable */ tests_quiet( argc, argv ); /* PAPI Initialization */ retval = PAPI_library_init( PAPI_VER_CURRENT ); if ( retval != PAPI_VER_CURRENT ) { test_fail(__FILE__, __LINE__,"PAPI_library_init failed\n",retval); } if (!TESTS_QUIET) { printf("Trying all RAPL events\n"); } numcmp = PAPI_num_components(); for(cid=0; cid<numcmp; cid++) { if ( (cmpinfo = PAPI_get_component_info(cid)) == NULL) { test_fail(__FILE__, __LINE__,"PAPI_get_component_info failed\n", 0); } if (strstr(cmpinfo->name,"rapl")) { rapl_cid=cid; if (!TESTS_QUIET) { printf("Found rapl component at cid %d\n",rapl_cid); } if (cmpinfo->disabled) { if (!TESTS_QUIET) { printf("RAPL component disabled: %s\n", cmpinfo->disabled_reason); } test_skip(__FILE__,__LINE__,"RAPL component disabled",0); } break; } } /* Component not found */ if (cid==numcmp) { test_skip(__FILE__,__LINE__,"No rapl component found\n",0); } /* Create EventSet */ retval = PAPI_create_eventset( &EventSet ); if (retval != PAPI_OK) { test_fail(__FILE__, __LINE__, "PAPI_create_eventset()",retval); } /* Add all events */ code = PAPI_NATIVE_MASK; r = PAPI_enum_cmp_event( &code, PAPI_ENUM_FIRST, rapl_cid ); while ( r == PAPI_OK ) { retval = PAPI_event_code_to_name( code, event_names[num_events] ); if ( retval != PAPI_OK ) { printf("Error translating %#x\n",code); test_fail( __FILE__, __LINE__, "PAPI_event_code_to_name", retval ); } retval = PAPI_get_event_info(code,&evinfo); if (retval != PAPI_OK) { test_fail( __FILE__, __LINE__, "Error getting event info\n",retval); } strncpy(units[num_events],evinfo.units,PAPI_MIN_STR_LEN); retval = PAPI_add_event( EventSet, code ); if (retval != PAPI_OK) { break; /* We've hit an event limit */ } num_events++; r = PAPI_enum_cmp_event( &code, PAPI_ENUM_EVENTS, rapl_cid ); } values=calloc(num_events,sizeof(long long)); if (values==NULL) { test_fail(__FILE__, __LINE__, "No memory",retval); } if (!TESTS_QUIET) { printf("\nStarting measurements...\n\n"); } /* Start Counting */ before_time=PAPI_get_real_nsec(); retval = PAPI_start( EventSet); if (retval != PAPI_OK) { test_fail(__FILE__, __LINE__, "PAPI_start()",retval); } /* Run test */ run_test(TESTS_QUIET); /* Stop Counting */ after_time=PAPI_get_real_nsec(); retval = PAPI_stop( EventSet, values); if (retval != PAPI_OK) { test_fail(__FILE__, __LINE__, "PAPI_start()",retval); } elapsed_time=((double)(after_time-before_time))/1.0e9; if (!TESTS_QUIET) { printf("\nStopping measurements, took %.3fs, gathering results...\n\n", elapsed_time); printf("Energy measurements:\n"); for(i=0;i<num_events;i++) { if (strstr(units[i],"nJ")) { printf("%s\t%.6fJ\t(Average Power %.1fW)\n", event_names[i], (double)values[i]/1.0e9, ((double)values[i]/1.0e9)/elapsed_time); } } printf("\n"); printf("Fixed values:\n"); for(i=0;i<num_events;i++) { if (!strstr(units[i],"nJ")) { union { long long ll; double fp; } result; result.ll=values[i]; printf("%s\t%0.3f%s\n", event_names[i], result.fp, units[i]); } } } /* Done, clean up */ retval = PAPI_cleanup_eventset( EventSet ); if (retval != PAPI_OK) { test_fail(__FILE__, __LINE__, "PAPI_cleanup_eventset()",retval); } retval = PAPI_destroy_eventset( &EventSet ); if (retval != PAPI_OK) { test_fail(__FILE__, __LINE__, "PAPI_destroy_eventset()",retval); } test_pass( __FILE__, NULL, 0 ); return 0; }
int HWCBE_PAPI_Start_Set (UINT64 countglops, UINT64 time, int numset, int threadid) { #if defined(PAPI_SAMPLING_SUPPORT) int i; #endif int rc; /* The given set is a valid one? */ if (numset < 0 || numset >= HWC_num_sets) return FALSE; HWC_current_changeat = HWC_sets[numset].change_at; HWC_current_changetype = HWC_sets[numset].change_type; HWC_current_timebegin[threadid] = time; HWC_current_glopsbegin[threadid] = countglops; /* Mark this counter set as the current set */ HWCEVTSET(threadid) = HWC_sets[numset].eventsets[threadid]; #if defined(PAPI_SAMPLING_SUPPORT) for (i = 0; i < HWC_sets[numset].NumOverflows; i++) { if (HWC_sets[numset].OverflowCounter[i] != NO_COUNTER) { rc = PAPI_overflow (HWCEVTSET(threadid), HWC_sets[numset].OverflowCounter[i], HWC_sets[numset].OverflowValue[i], 0, PAPI_sampling_handler); if (rc < 0) { setSamplingEnabled (FALSE); fprintf (stderr, PACKAGE_NAME": PAPI_overflow failed for thread %d - counter %x!\n", threadid, HWC_sets[numset].OverflowCounter[i]); } else setSamplingEnabled (TRUE); } } #endif rc = PAPI_start (HWCEVTSET(threadid)); if (rc == PAPI_OK) { TRACE_EVENT (time, HWC_CHANGE_EV, numset); #if defined(PAPI_SAMPLING_SUPPORT) if (HWC_sets[numset].NumOverflows > 0) { long long overflow_values[MAX_HWC]; HARDWARE_COUNTERS_OVERFLOW(HWC_sets[numset].num_counters, HWC_sets[numset].counters, HWC_sets[numset].NumOverflows, HWC_sets[numset].OverflowCounter, overflow_values); TRACE_EVENT_AND_GIVEN_COUNTERS (time, HWC_SET_OVERFLOW_EV, 0, MAX_HWC, overflow_values); } #endif } else { fprintf (stderr, PACKAGE_NAME": PAPI_start failed to start eventset %d on thread %d! (error = %d)\n", numset+1, threadid, rc); if (rc == PAPI_ESYS) { perror ("PAPI_start"); fprintf (stderr, PACKAGE_NAME": errno = %d\n", errno); } } return rc == PAPI_OK; }
int _hl_rate_calls( float *real_time, float *proc_time, int *events, long long *values, long long *ins, float *rate, int mode ) { long long rt, pt; // current elapsed real and process times in usec int num_events = 2; int retval = 0; HighLevelInfo *state = NULL; if ( ( retval = _internal_check_state( &state ) ) != PAPI_OK ) { return ( retval ); } if ( state->running != HL_STOP && state->running != mode ) { return PAPI_EINVAL; } if ( state->running == HL_STOP ) { switch (mode) { case HL_FLOP: case HL_FLIP: num_events = 1; break; case HL_IPC: break; case HL_EPC: if ( events[2] != 0 ) num_events = 3; break; default: return PAPI_EINVAL; } if (( retval = PAPI_add_events( state->EventSet, events, num_events )) != PAPI_OK ) { _internal_cleanup_hl_info( state ); PAPI_cleanup_eventset( state->EventSet ); return retval; } state->total_ins = 0; state->initial_real_time = state->last_real_time = PAPI_get_real_usec( ); state->initial_proc_time = state->last_proc_time = PAPI_get_virt_usec( ); if ( ( retval = PAPI_start( state->EventSet ) ) != PAPI_OK ) { return retval; } /* Initialize the interface */ state->running = mode; *real_time = 0.0; *proc_time = 0.0; *rate = 0.0; } else { if ( ( retval = PAPI_stop( state->EventSet, values ) ) != PAPI_OK ) { state->running = HL_STOP; return retval; } /* Read elapsed real and process times */ rt = PAPI_get_real_usec(); pt = PAPI_get_virt_usec(); /* Convert to seconds with multiplication because it is much faster */ *real_time = ((float)( rt - state->initial_real_time )) * .000001; *proc_time = ((float)( pt - state->initial_proc_time )) * .000001; state->total_ins += values[0]; switch (mode) { case HL_FLOP: case HL_FLIP: /* Calculate MFLOP and MFLIP rates */ if ( pt > 0 ) { *rate = (float)values[0] / (pt - state->last_proc_time); } else *rate = 0; break; case HL_IPC: case HL_EPC: /* Calculate IPC */ if (values[1]!=0) { *rate = (float) ((float)values[0] / (float) ( values[1])); } break; default: return PAPI_EINVAL; } state->last_real_time = rt; state->last_proc_time = pt; if ( ( retval = PAPI_start( state->EventSet ) ) != PAPI_OK ) { state->running = HL_STOP; return retval; } } *ins = state->total_ins; return PAPI_OK; }
/** @internal * Make sure to allocate space for values */ int _internal_start_hl_counters( HighLevelInfo * state ) { return ( PAPI_start( state->EventSet ) ); }