void init_multiplex( void ) { int retval; const PAPI_hw_info_t *hw_info; const PAPI_component_info_t *cmpinfo; /* Initialize the library */ /* for now, assume multiplexing on CPU compnent only */ cmpinfo = PAPI_get_component_info( 0 ); if ( cmpinfo == NULL ) test_fail( __FILE__, __LINE__, "PAPI_get_component_info", 2 ); hw_info = PAPI_get_hardware_info( ); if ( hw_info == NULL ) test_fail( __FILE__, __LINE__, "PAPI_get_hardware_info", 2 ); if ( ( strstr( cmpinfo->name, "perfctr.c" ) ) && (hw_info !=NULL) && strcmp( hw_info->model_string, "POWER6" ) == 0 ) { retval = PAPI_set_domain( PAPI_DOM_ALL ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_set_domain", retval ); } retval = PAPI_multiplex_init( ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI multiplex init fail\n", retval ); }
int main( int argc, char **argv ) { int nthreads = 8, ret, i; PAPI_event_info_t info; pthread_t *threads; const PAPI_hw_info_t *hw_info; tests_quiet( argc, argv ); /* Set TESTS_QUIET variable */ if ( !TESTS_QUIET ) { if ( argc > 1 ) { int tmp = atoi( argv[1] ); if ( tmp >= 1 ) nthreads = tmp; } } ret = PAPI_library_init( PAPI_VER_CURRENT ); if ( ret != PAPI_VER_CURRENT ) { test_fail( __FILE__, __LINE__, "PAPI_library_init", ret ); } hw_info = PAPI_get_hardware_info( ); if ( hw_info == NULL ) test_fail( __FILE__, __LINE__, "PAPI_get_hardware_info", 2 ); if ( strcmp( hw_info->model_string, "POWER6" ) == 0 ) { ret = PAPI_set_domain( PAPI_DOM_ALL ); if ( ret != PAPI_OK ) { test_fail( __FILE__, __LINE__, "PAPI_set_domain", ret ); } } ret = PAPI_thread_init( ( unsigned long ( * )( void ) ) pthread_self ); if ( ret != PAPI_OK ) { test_fail( __FILE__, __LINE__, "PAPI_thread_init", ret ); } ret = PAPI_multiplex_init( ); if ( ret != PAPI_OK ) { test_fail( __FILE__, __LINE__, "PAPI_multiplex_init", ret ); } /* Fill up the event set with as many non-derived events as we can */ i = PAPI_PRESET_MASK; do { if ( PAPI_get_event_info( i, &info ) == PAPI_OK ) { if ( info.count == 1 ) { events[numevents++] = ( int ) info.event_code; printf( "Added %s\n", info.symbol ); } else { printf( "Skipping derived event %s\n", info.symbol ); } } } while ( ( PAPI_enum_event( &i, PAPI_PRESET_ENUM_AVAIL ) == PAPI_OK ) && ( numevents < PAPI_MPX_DEF_DEG ) ); printf( "Found %d events\n", numevents ); do_stuff( ); printf( "Creating %d threads:\n", nthreads ); threads = ( pthread_t * ) malloc( ( size_t ) nthreads * sizeof ( pthread_t ) ); if ( threads == NULL ) { test_fail( __FILE__, __LINE__, "malloc", PAPI_ENOMEM ); } /* Create the threads */ for ( i = 0; i < nthreads; i++ ) { ret = pthread_create( &threads[i], NULL, thread, NULL ); if ( ret != 0 ) { test_fail( __FILE__, __LINE__, "pthread_create", PAPI_ESYS ); } } /* Wait for thread completion */ for ( i = 0; i < nthreads; i++ ) { ret = pthread_join( threads[i], NULL ); if ( ret != 0 ) { test_fail( __FILE__, __LINE__, "pthread_join", PAPI_ESYS ); } } printf( "Done." ); test_pass( __FILE__, NULL, 0 ); pthread_exit( NULL ); exit( 0 ); }
int main(int argc, char **argv) { int retval,max_multiplex,i,EventSet=PAPI_NULL; PAPI_event_info_t info; int added=0; int events_tried=0; /* Set TESTS_QUIET variable */ tests_quiet( argc, argv ); /* Initialize the library */ retval = PAPI_library_init( PAPI_VER_CURRENT ); if ( retval != PAPI_VER_CURRENT ) { test_fail( __FILE__, __LINE__, "PAPI_library_init", retval ); } retval = PAPI_multiplex_init( ); if ( retval != PAPI_OK) { test_fail(__FILE__, __LINE__, "Multiplex not supported", 1); } max_multiplex=PAPI_get_opt( PAPI_MAX_MPX_CTRS, NULL ); if (!TESTS_QUIET) { printf("Maximum multiplexed counters=%d\n",max_multiplex); } if (!TESTS_QUIET) { printf("Trying to multiplex as many as possible:\n"); } 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_create_multiplex", retval ); } i = 0 | PAPI_PRESET_MASK; PAPI_enum_event( &i, PAPI_ENUM_FIRST ); do { retval = PAPI_get_event_info( i, &info ); if (retval==PAPI_OK) { if (!TESTS_QUIET) printf("Adding %s: ",info.symbol); } retval = PAPI_add_event( EventSet, info.event_code ); if (retval!=PAPI_OK) { if (!TESTS_QUIET) printf("Fail!\n"); } else { if (!TESTS_QUIET) printf("Success!\n"); added++; } events_tried++; } while (PAPI_enum_event( &i, PAPI_PRESET_ENUM_AVAIL ) == PAPI_OK ); PAPI_shutdown( ); if (!TESTS_QUIET) { printf("Added %d of theoretical max %d\n",added,max_multiplex); } if (events_tried<max_multiplex) { if (!TESTS_QUIET) { printf("Ran out of events before we ran out of room\n"); } } else if (added!=max_multiplex) { test_fail(__FILE__, __LINE__, "Couldn't max out multiplexed events", 1); } test_pass( __FILE__, NULL, 0 ); exit( 0 ); }
int main(int argc, char **argv) { PAPI_event_info_t info; int i, j, retval; int iters = 10000000; double x = 1.1, y; long long t1, t2; long long values[MAXEVENTS], refvalues[MAXEVENTS]; int sleep_time = SLEEPTIME; double valsqsum[MAXEVENTS]; double valsum[MAXEVENTS]; double spread[MAXEVENTS]; int nevents = MAXEVENTS; int eventset = PAPI_NULL; int events[MAXEVENTS]; events[0] = PAPI_BR_NTK; events[1] = PAPI_BR_PRC; events[2] = PAPI_BR_INS; events[3] = PAPI_BR_MSP; /* events[3]=PAPI_BR_CN; events[4]=PAPI_BR_UCN;*/ /*events[5]=PAPI_BR_TKN; */ for (i = 0; i < MAXEVENTS; i++) { values[i] = 0; valsqsum[i] = 0; valsum[i] = 0; } if (argc > 1) { if (!strcmp(argv[1], "TESTS_QUIET")) tests_quiet(argc, argv); else { sleep_time = atoi(argv[1]); if (sleep_time <= 0) sleep_time = SLEEPTIME; } } if (!TESTS_QUIET) { printf("\nAccuracy check of branch presets.\n"); printf("Comparing a measurement with separate measurements.\n\n"); } 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))) test_fail(__FILE__, __LINE__, "PAPI_create_eventset", retval); #ifdef MPX if ((retval = PAPI_multiplex_init())) test_fail(__FILE__, __LINE__, "PAPI_multiplex_init", retval); if ((retval = PAPI_set_multiplex(eventset))) test_fail(__FILE__, __LINE__, "PAPI_set_multiplex", retval); #endif nevents = 0; for (i = 0; i < MAXEVENTS; i++) { if (PAPI_query_event(events[i]) != PAPI_OK) continue; if (PAPI_add_event(eventset, events[i]) == PAPI_OK) { events[nevents] = events[i]; nevents++; } } if (nevents < 1) test_skip(__FILE__, __LINE__, "Not enough events left...", 0); /* Find a reasonable number of iterations (each * event active 20 times) during the measurement */ t2 = 10000 * 20 * nevents; /* Target: 10000 usec/multiplex, 20 repeats */ if (t2 > 30e6) test_skip(__FILE__, __LINE__, "This test takes too much time", retval); /* Measure one run */ t1 = PAPI_get_real_usec(); y = dummy3(x, iters); t1 = PAPI_get_real_usec() - t1; if (t2 > t1) /* Scale up execution time to match t2 */ iters = iters * (int)(t2 / t1); else if (t1 > 30e6) /* Make sure execution time is < 30s per repeated test */ test_skip(__FILE__, __LINE__, "This test takes too much time", retval); x = 1.0; if (!TESTS_QUIET) printf("\nFirst run: Together.\n"); 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, values))) test_fail(__FILE__, __LINE__, "PAPI_stop", retval); t2 = PAPI_get_real_usec(); if (!TESTS_QUIET) { printf("\tOperations= %.1f Mflop", y * 1e-6); printf("\t(%g Mflop/s)\n\n", ((float) y / (t2 - t1))); printf("PAPI grouped measurement:\n"); } for (j = 0; j < nevents; j++) { PAPI_get_event_info(events[j], &info); if (!TESTS_QUIET) { printf("%20s = ", info.short_descr); printf(LLDFMT, values[j]); printf("\n"); } } if (!TESTS_QUIET) printf("\n"); if ((retval = PAPI_remove_events(eventset, events, nevents))) test_fail(__FILE__, __LINE__, "PAPI_remove_events", retval); if ((retval = PAPI_destroy_eventset(&eventset))) test_fail(__FILE__, __LINE__, "PAPI_destroy_eventset", retval); eventset = PAPI_NULL; if ((retval = PAPI_create_eventset(&eventset))) test_fail(__FILE__, __LINE__, "PAPI_create_eventset", retval); for (i = 0; i < nevents; i++) { if ((retval = PAPI_cleanup_eventset(eventset))) test_fail(__FILE__, __LINE__, "PAPI_cleanup_eventset", retval); if ((retval = PAPI_add_event(eventset, events[i]))) test_fail(__FILE__, __LINE__, "PAPI_add_event", retval); x = 1.0; if (!TESTS_QUIET) printf("\nReference measurement %d (of %d):\n", i + 1, nevents); 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 (!TESTS_QUIET) { printf("\tOperations= %.1f Mflop", y * 1e-6); printf("\t(%g Mflop/s)\n\n", ((float) y / (t2 - t1))); } PAPI_get_event_info(events[i], &info); if (!TESTS_QUIET) { printf("PAPI results:\n%20s = ", info.short_descr); printf(LLDFMT, refvalues[i]); printf("\n"); } } if (!TESTS_QUIET) printf("\n"); if (!TESTS_QUIET) { printf("\n\nRelative accuracy:\n"); for (j = 0; j < nevents; j++) printf(" Event %.2d", j); printf("\n"); } for (j = 0; j < nevents; j++) { spread[j] = abs((int)(refvalues[j] - values[j])); if (values[j]) spread[j] /= (double) values[j]; if (!TESTS_QUIET) printf("%10.3g ", spread[j]); /* Make sure that NaN get counted as errors */ if (spread[j] < MPX_TOLERANCE) i--; else if (refvalues[j] < MINCOUNTS) /* Neglect inprecise results with low counts */ i--; } if (!TESTS_QUIET) printf("\n\n"); if (i) test_fail(__FILE__, __LINE__, "Values outside threshold", i); else test_pass(__FILE__, NULL, 0); return 0; }
int main() { double *a; double *b; double *c; int i = 0, j = 0, k = 0; int *events; // Array of events long long *values; // Array of values events int EventSet = PAPI_NULL; // Handle for a PAPI event set as created by PAPI_create_eventset (3) int retval; // Test fail function int num_event = 0; // Number of events int max_event; // Number of available events int EventCode = 0; // Event code PAPI_event_info_t pset; // PAPI_event_info_t Struct Reference char evname[PAPI_MAX_STR_LEN]; // Symbol event /* Memory asignament to matrixs*/ if((a = (double *)malloc(mrows * ncolumns * sizeof(double))) == NULL) printf("Error malloc matrix a[%d]\n",mrows * ncolumns); if((b = (double *)malloc(ncolumns * pcolumns * sizeof(double))) == NULL) printf("Error malloc matrix b[%d]\n",mrows * ncolumns); if((c = (double *)malloc(mrows * pcolumns * sizeof(double))) == NULL) printf("Error malloc matrix c[%d]\n",mrows * ncolumns); /* Initialize the Matrix arrays */ initmat(a, b, mrows, ncolumns, pcolumns); /* Initialize the PAPI library */ retval = PAPI_library_init(PAPI_VER_CURRENT); if (retval != PAPI_VER_CURRENT) test_fail( __FILE__, __LINE__, "PAPI_library_init", retval ); /* Enable and initialize multiplex support */ retval = PAPI_multiplex_init(); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_multiplex_init", retval ); /* Create an EventSet */ retval = PAPI_create_eventset(&EventSet); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_create_eventset", retval ); /* Assign it to the CPU component */ retval = PAPI_assign_eventset_component(EventSet, 0); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_assign_eventset_component", retval ); /* Convert the EventSet to a multiplexed event set */ retval = PAPI_set_multiplex(EventSet); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_set_multiplex", retval ); /* Obtaining the number of available events */ max_event = PAPI_get_opt( PAPI_MAX_MPX_CTRS, NULL ); printf("\nNumber of available events: %d", max_event ); /* Fill up the event set with as many non-derived events as we can */ EventCode = PAPI_PRESET_MASK; do { if ( PAPI_get_event_info( EventCode, &pset ) == PAPI_OK ) { if ( pset.count && ( strcmp( pset.derived, "NOT_DERIVED" ) == 0 ) ) { retval = PAPI_add_event( EventSet, ( int ) pset.event_code ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_add_event", retval ); else { //printf( "Added %s\n", pset.symbol ); num_event++; } } } } while ( ( PAPI_enum_event( &EventCode, PAPI_PRESET_ENUM_AVAIL ) == PAPI_OK ) && ( num_event < max_event ) ); /* Memory asignament to values and events*/ events = ( int * ) malloc( ( size_t ) num_event * sizeof ( int ) ); if ( events == NULL ) test_fail( __FILE__, __LINE__, "Error malloc events", 0 ); values = ( long long * ) malloc( ( size_t ) num_event * sizeof ( long long ) ); if ( values == NULL ) test_fail( __FILE__, __LINE__, "Erro malloc values", 0 ); /* Start counting events */ if ((retval=PAPI_start(EventSet)) != PAPI_OK) test_fail(__FILE__, __LINE__, "PAPI_start", retval); /* Matrix-Matrix multiply */ matmul(a, b, c, mrows, ncolumns, pcolumns); /* Read the counters */ if ((retval=PAPI_read( EventSet, values )) != PAPI_OK) test_fail(__FILE__, __LINE__, "PAPI_read_counters", retval); /* Stop counting events */ if ((retval=PAPI_stop( EventSet, values )) != PAPI_OK) test_fail(__FILE__, __LINE__, "PAPI_stop_counters", retval); /* List the events in the event set */ retval = PAPI_list_events( EventSet, events, &num_event ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_list_events", retval ); /* Print results */ printf("\nNumber of non-zero events: %d\n", num_event ); printf( "\nCounts of non-zero available events........................................................\n" ); printf("Name: \t\t\t Value: \t Description:\n"); for ( i = 0; i < num_event; i++ ) { PAPI_event_code_to_name( events[i], evname ); // Obtaining name of available events PAPI_get_event_info(events[i], &pset); if ( values[i] != 0 ) printf("%s \t %15lld \t %s\n", evname, values[i], pset.long_descr); } printf( "\nCounts of zero available events............................................................\n" ); printf("Name: \t\t\t Value: \t Description:\n"); for ( i = 0; i < num_event; i++ ) { PAPI_event_code_to_name( events[i], evname ); // Obtaining name of available events PAPI_get_event_info(events[i], &pset); if ( values[i] == 0 ) printf("%s \t %15lld \t %s\n", evname, values[i], pset.long_descr); } /* Check if counter pair(s) had identical values */ for ( i = 0; i < num_event; i++ ) { for ( i = j+1; j < num_event; j++ ) { if ( ( i != j ) && ( values[i] == values[j] ) ) k++; } } if ( k != 0 ) { printf( "\nCaution: %d counter pair(s) had identical values\n", k ); } printf("\n"); /* Free memory */ free( events ); free( values ); free( a ); free( b ); free( c ); /* Cleaning events */ retval = PAPI_cleanup_eventset( EventSet ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_cleanup_eventset", retval ); /* Destroying events */ retval = PAPI_destroy_eventset( &EventSet ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_destroy_eventset", retval ); return 0; }
int GPTLcreate_and_start_events (const int t) /* thread number */ { int ret; /* return code */ int n; /* loop index over events */ char eventname[PAPI_MAX_STR_LEN]; /* returned from PAPI_event_code_to_name */ /* Create the event set */ if ((ret = PAPI_create_eventset (&EventSet[t])) != PAPI_OK) return GPTLerror ("GPTLcreate_and_start_events: thread %d failure creating eventset: %s\n", t, PAPI_strerror (ret)); if (verbose) printf ("GPTLcreate_and_start_events: successfully created eventset for thread %d\n", t); /* Add requested events to the event set */ for (n = 0; n < npapievents; n++) { if ((ret = PAPI_add_event (EventSet[t], papieventlist[n])) != PAPI_OK) { if (verbose) { fprintf (stderr, "%s\n", PAPI_strerror (ret)); ret = PAPI_event_code_to_name (papieventlist[n], eventname); fprintf (stderr, "GPTLcreate_and_start_events: failure adding event:%s\n", eventname); } if (enable_multiplexing) { if (verbose) printf ("Trying multiplexing...\n"); is_multiplexed = true; break; } else return GPTLerror ("enable_multiplexing is false: giving up\n"); } } if (is_multiplexed) { /* Cleanup the eventset for multiplexing */ if ((ret = PAPI_cleanup_eventset (EventSet[t])) != PAPI_OK) return GPTLerror ("GPTLcreate_and_start_events: %s\n", PAPI_strerror (ret)); if ((ret = PAPI_destroy_eventset (&EventSet[t])) != PAPI_OK) return GPTLerror ("GPTLcreate_and_start_events: %s\n", PAPI_strerror (ret)); if ((ret = PAPI_create_eventset (&EventSet[t])) != PAPI_OK) return GPTLerror ("GPTLcreate_and_start_events: failure creating eventset: %s\n", PAPI_strerror (ret)); if ((ret = PAPI_multiplex_init ()) != PAPI_OK) return GPTLerror ("GPTLcreate_and_start_events: failure from PAPI_multiplex_init%s\n", PAPI_strerror (ret)); if ((ret = PAPI_set_multiplex (EventSet[t])) != PAPI_OK) return GPTLerror ("GPTLcreate_and_start_events: failure from PAPI_set_multiplex: %s\n", PAPI_strerror (ret)); for (n = 0; n < npapievents; n++) { if ((ret = PAPI_add_event (EventSet[t], papieventlist[n])) != PAPI_OK) { ret = PAPI_event_code_to_name (papieventlist[n], eventname); return GPTLerror ("GPTLcreate_and_start_events: failure adding event:%s\n" " Error was: %s\n", eventname, PAPI_strerror (ret)); } } } /* Start the event set. It will only be read from now on--never stopped */ if ((ret = PAPI_start (EventSet[t])) != PAPI_OK) return GPTLerror ("GPTLcreate_and_start_events: failed to start event set: %s\n", PAPI_strerror (ret)); return 0; }
/* ** GPTLcreate_and_start_events: Create and start the PAPI eventset. ** Threaded routine to create the "event set" (PAPI terminology) and start ** the counters. This is only done once, and is called from get_thread_num ** for the first time for the thread. ** ** Input args: ** t: thread number ** ** Return value: 0 (success) or GPTLerror (failure) */ int GPTLcreate_and_start_events (const int t) /* thread number */ { int ret; /* return code */ int n; /* loop index over events */ char eventname[PAPI_MAX_STR_LEN]; /* returned from PAPI_event_code_to_name */ static const char *thisfunc = "GPTLcreate_and_start_events"; /* ** Set the domain to count all contexts. Only needs to be set once for all threads */ if ((ret = PAPI_set_domain (PAPI_DOM_ALL)) != PAPI_OK) return GPTLerror ("%s: thread %d failure setting PAPI domain: %s\n", thisfunc, t, PAPI_strerror (ret)); /* Create the event set */ if ((ret = PAPI_create_eventset (&EventSet[t])) != PAPI_OK) return GPTLerror ("%s: thread %d failure creating eventset: %s\n", thisfunc, t, PAPI_strerror (ret)); if (verbose) printf ("%s: successfully created eventset for thread %d\n", thisfunc, t); /* Add requested events to the event set */ for (n = 0; n < npapievents; n++) { if ((ret = PAPI_add_event (EventSet[t], papieventlist[n])) != PAPI_OK) { if (verbose) { fprintf (stderr, "%s\n", PAPI_strerror (ret)); ret = PAPI_event_code_to_name (papieventlist[n], eventname); fprintf (stderr, "%s: failure adding event:%s\n", thisfunc, eventname); } if (enable_multiplexing) { if (verbose) printf ("Trying multiplexing...\n"); is_multiplexed = true; break; } else return GPTLerror ("enable_multiplexing is false: giving up\n"); } } if (is_multiplexed) { /* Cleanup the eventset for multiplexing */ if ((ret = PAPI_cleanup_eventset (EventSet[t])) != PAPI_OK) return GPTLerror ("%s: %s\n", thisfunc, PAPI_strerror (ret)); if ((ret = PAPI_destroy_eventset (&EventSet[t])) != PAPI_OK) return GPTLerror ("%s: %s\n", thisfunc, PAPI_strerror (ret)); if ((ret = PAPI_create_eventset (&EventSet[t])) != PAPI_OK) return GPTLerror ("%s: failure creating eventset: %s\n", thisfunc, PAPI_strerror (ret)); /* ** Assign EventSet to component 0 (cpu). This step is MANDATORY in recent PAPI releases ** in order to enable event multiplexing */ if ((ret = PAPI_assign_eventset_component (EventSet[t], 0)) != PAPI_OK) return GPTLerror ("%s: thread %d failure in PAPI_assign_eventset_component: %s\n", thisfunc, t, PAPI_strerror (ret)); if ((ret = PAPI_multiplex_init ()) != PAPI_OK) return GPTLerror ("%s: failure from PAPI_multiplex_init%s\n", thisfunc, PAPI_strerror (ret)); if ((ret = PAPI_set_multiplex (EventSet[t])) != PAPI_OK) return GPTLerror ("%s: failure from PAPI_set_multiplex: %s\n", thisfunc, PAPI_strerror (ret)); for (n = 0; n < npapievents; n++) { if ((ret = PAPI_add_event (EventSet[t], papieventlist[n])) != PAPI_OK) { ret = PAPI_event_code_to_name (papieventlist[n], eventname); return GPTLerror ("%s: failure adding event:%s Error was: %s\n", thisfunc, eventname, PAPI_strerror (ret)); } } } /* Start the event set. It will only be read from now on--never stopped */ if ((ret = PAPI_start (EventSet[t])) != PAPI_OK) return GPTLerror ("%s: failed to start event set: %s\n", thisfunc, PAPI_strerror (ret)); return 0; }
void *watch_process(void* _pid) { pid_t pid = *((pid_t*)_pid); printf("%d\n", pid); int retval, EventSet = PAPI_NULL; //char events_name[NB_EVENTS][PAPI_MAX_STR_LEN] = {"UNHALTED_CORE_CYCLES", "INSTRUCTION_RETIRED", "MEM_LOAD_RETIRED:L1D_HIT", "MEM_LOAD_RETIRED:L2_HIT", "LLC_REFERENCES"}; //char events_name[NB_EVENTS][PAPI_MAX_STR_LEN] = {"UNHALTED_CORE_CYCLES", "INSTRUCTION_RETIRED", "MEM_LOAD_RETIRED:L2_HIT", "L2_RQSTS:LOADS", "L2_DATA_RQSTS:ANY"}; //char events_name[NB_EVENTS][PAPI_MAX_STR_LEN] = {"UNHALTED_CORE_CYCLES", "INSTRUCTION_RETIRED", "L1I:READS", "L1D_CACHE_LD:MESI", "L1D_CACHE_ST:MESI"}; //char events_name[NB_EVENTS][PAPI_MAX_STR_LEN] = {"UNHALTED_CORE_CYCLES", "INSTRUCTION_RETIRED", "L1D_CACHE_LD:MESI", "L1D_CACHE_ST:MESI", "L2_DATA_RQSTS:ANY" }; char events_name[NB_EVENTS][PAPI_MAX_STR_LEN] = {"UNHALTED_CORE_CYCLES", "INSTRUCTION_RETIRED", "L1I:READS", "L1D_CACHE_LD:MESI", "L1D_CACHE_ST:MESI", "MEM_LOAD_RETIRED:L2_HIT", "L2_RQSTS:LOADS", "L2_DATA_RQSTS:ANY", "BR_INST_RETIRED:ALL_BRANCHES", "BR_INST_EXEC:ANY", "BR_MISP_EXEC:ANY" }; unsigned int native_events[NB_EVENTS]; long long values[NB_EVENTS]; int err; /* Initialize the library */ if ( (err = PAPI_library_init(PAPI_VER_CURRENT)) != PAPI_VER_CURRENT) { fprintf(stderr, "PAPI library init error! %d\n", err); exit(1); } if ( (err = PAPI_multiplex_init()) != PAPI_OK) { fprintf(stderr, "PAPI multiplex init error! %d\n", err); exit(1); } if (PAPI_thread_init(pthread_self) != PAPI_OK) { fprintf(stderr, "PAPI thread init error! %d\n", err); exit(1); } //sched_setaffinity(0, 0); //if ((retval = PAPI_set_granularity(PAPI_GRN_MAX)) != PAPI_OK) { // fprintf(stderr, "PAPI set granurality error! %d, %d, %d, %d, %d\n", retval, PAPI_EINVAL, PAPI_ENOEVST, PAPI_ENOCMP, PAPI_EISRUN); // exit(1); //} // Traduction des string en code name_to_code(events_name, NB_EVENTS, native_events); // Vérification des évènements check_events(native_events, NB_EVENTS); if (PAPI_create_eventset(&EventSet) != PAPI_OK) { fprintf(stderr, "PAPI EventSet init error!\n"); exit(1); } if ( (err = PAPI_assign_eventset_component( EventSet, 0 ) ) != PAPI_OK ) { fprintf(stderr, "PAPI assign component error!\n%s\n", PAPI_strerror(err)); exit(1); } if ( ( err = PAPI_set_multiplex(EventSet) ) != PAPI_OK) { fprintf(stderr, "PAPI set multiplex error!\n%s\n", PAPI_strerror(err)); exit(1); } if ( (retval = PAPI_add_events(EventSet, native_events, NB_EVENTS) ) != PAPI_OK) { fprintf(stderr, "PAPI add events error!\n%s\n", PAPI_strerror(retval) ); exit(1); } if (PAPI_attach(EventSet, pid) != PAPI_OK) exit(1); while(while_watch) { /* Start counting */ if (PAPI_start(EventSet) != PAPI_OK) { fprintf(stderr, "PAPI start error!\n"); exit(1); } usleep(1000000); if (PAPI_stop(EventSet, values) != PAPI_OK) { fprintf(stderr, "PAPI stop error!\n"); exit(1); } print_values(events_name, values, NB_EVENTS); } return 0; }
int main(int argc, char **argv) { #if defined(PARALLEL) || defined(PARTIALPAR) omp_set_num_threads(initParams::nprocs); size_t threadID; std::vector<size_t> neighbourThreadId; std::vector<size_t> workingThreadId; std::vector<cv::KeyPoint> globalKeypoints; cv::Mat globalDescriptors; std::vector<size_t> globalIdx(initParams::nprocs/2, 0); std::vector<size_t> levelThreadIdx; #endif cv::Mat frame; cv::VideoCapture cap; class initParams params; // Set motion field norm threshold. If intra-frame motion greater than this threshold carry out outlier classification, rotation compensation, FOE and TTC computations #if !defined(PARALLEL) const float OFThresh = 10.0f; #endif #ifdef USE_PAPI int events[NUM_EVENTS] = { PAPI_L1_DCM, PAPI_L2_DCA, PAPI_L2_DCM }; long long values[NUM_EVENTS+1]; long long start_time = PAPI_get_real_usec(); double total_time = 0.0f; #endif // Initialization of parameters params.set(); if (argc < 3) { std::cerr << "Run Configuration :\n\t./[program name] [input video file] [Total # of frames in video file, 798 for data set-1 and 977 for data set-2]\n"; exit(EXIT_FAILURE); } cap.open(argv[1]); if(!cap.isOpened()){ std::cerr << "Could not access video file: " << argv[1] << std::endl; exit(EXIT_FAILURE); } size_t frameTotal = (size_t) std::atoi(argv[2]); class agast objExtractor; class FindRobustFeatures rFeatures(&objExtractor, ¶ms); cv::Mat tmpDescriptors; std::vector<cv::KeyPoint> tmpKeypoints; #ifdef WRITEDATA analysis::TTCvector.resize((size_t)cap.get(CV_CAP_PROP_FRAME_COUNT), 0.0f); analysis::kpVector.resize((size_t)cap.get(CV_CAP_PROP_FRAME_COUNT), 0); analysis::outliersVector.resize((size_t)cap.get(CV_CAP_PROP_FRAME_COUNT), 0); analysis::matchOutliersVector.resize((size_t)cap.get(CV_CAP_PROP_FRAME_COUNT), 0); analysis::OFNorm.resize((size_t)cap.get(CV_CAP_PROP_FRAME_COUNT), 0); analysis::keypointsVector.resize((size_t)cap.get(CV_CAP_PROP_FRAME_COUNT), 0); #endif #if defined(PROF) || defined(WRITEDATA) time_t rawtime; char buffer[80]; time(&rawtime); struct tm * timeinfo = localtime(&rawtime); strftime(buffer,80, "%d-%m-%y_%H-%M-%S", timeinfo); analysis::timeStamp = std::string(buffer); #endif #ifdef PROF analysis::perfTime.resize((size_t)cap.get(CV_CAP_PROP_FRAME_COUNT), std::vector<float>(3, 0.0f)); #endif #ifdef USE_PAPI //********** PAPI Module initialization for performance analysis***********// // Setup PAPI library int ret = PAPI_library_init(PAPI_VER_CURRENT); if (ret != PAPI_VER_CURRENT) { printf("Problem while initializing PAPI library: %s\n", PAPI_strerror(ret)); exit(EXIT_FAILURE); } // Init multiplexer ret = PAPI_multiplex_init(); if (ret != PAPI_OK) { printf("Problem while initializing PAPI multiplexer: %s\n", PAPI_strerror(ret)); exit(1); } // Create event set for the events that we want to measure int eventset = PAPI_NULL; ret = PAPI_create_eventset(&eventset); if (ret != PAPI_OK) { printf("Problem while creating PAPI event set: %s\n", PAPI_strerror(ret)); exit(1); } ret = PAPI_add_event(eventset, PAPI_L1_DCA); if (ret != PAPI_OK) { printf("Problem while adding first PAPI event: %s\n", PAPI_strerror(ret)); exit(1); } // set multiplexer for event set ret = PAPI_set_multiplex(eventset); if (ret != PAPI_OK) { printf("Problem while setting PAPI multiplex: %s\n", PAPI_strerror(ret)); exit(1); } // Add events to event set ret = PAPI_add_events(eventset, events, NUM_EVENTS); if (ret != PAPI_OK) { printf("Problem while adding PAPI events: %s\n", PAPI_strerror(ret)); exit(1); } //********** END INITIALIZATION **********// // Start measuring computation runtime start_time = PAPI_get_real_usec(); // Start measuring events in event set ret = PAPI_start(eventset); if (ret != PAPI_OK) { printf("Problem while starting PAPI eventset: %s\n", PAPI_strerror(ret)); exit(1); } #endif try { while(( (size_t)cap.get(CV_CAP_PROP_POS_FRAMES) + initParams::frameDelay ) < frameTotal) { /****************************PARALLEL-REGION************************************/ #if defined(PARALLEL) || defined(PARTIALPAR) globalIdx.resize(initParams::nprocs/2, 0); analysis::refFrameCount = cap.get(CV_CAP_PROP_POS_FRAMES); analysis::frameCount = cap.get(CV_CAP_PROP_POS_FRAMES); for (size_t i = 0; i < initParams::nprocs; ++i) { if (i % 2 == 0) { workingThreadId.push_back(i); } else { neighbourThreadId.push_back(i); } } #pragma omp parallel num_threads(initParams::nprocs) private(threadID, frame) shared(globalIdx, params, neighbourThreadId, workingThreadId, objExtractor) { threadID = omp_get_thread_num(); // get index of the frame to be handled by a particular thread executed only once: size_t myFrameID = 0; #pragma omp for ordered schedule(static,1) for (size_t i = 0; i < initParams::nprocs; ++i) { #pragma omp ordered myFrameID = threadID + analysis::frameCount; analysis::frameCount++; } class agast objExtractorLoc; while(cap.get(CV_CAP_PROP_POS_FRAMES) != myFrameID) { std::this_thread::sleep_for(std::chrono::milliseconds(5)); } // get first frame and extract new features: cap >> objExtractorLoc.frame; objExtractorLoc.extractFeatures(); if (threadID == initParams::nprocs-1) { objExtractorLoc.frame.copyTo(objExtractor.frame); } #pragma omp master { // keep ref. of the first keypoints and their descriptors: objExtractor.descriptorsOld = objExtractorLoc.descriptors.clone(); objExtractor.keypointsOld = objExtractorLoc.keypoints; #ifdef VISUALIZE objExtractorLoc.frame.copyTo(objExtractor.frameOld); #endif } // follow keypoints over the next framedelay # of frames: objExtractorLoc.swap(); cap >> objExtractorLoc.frame; objExtractorLoc.extractFeatures(); objExtractorLoc.featureMatching(); #if ! defined(WRITEDATA) objExtractorLoc.homographyRANSAC(3.0f); #else objExtractorLoc.homographyRANSAC(3.0f, analysis::outliers, analysis::frameCount, analysis::outliersVector); #endif if((size_t)objExtractorLoc.goodMatches.size() > 5) objExtractorLoc.swapGM(); if (!globalIdx.empty()) { helperFunc::storeGlobal(globalKeypoints, globalDescriptors, objExtractorLoc, threadID, globalIdx, neighbourThreadId); #pragma omp barrier helperFunc::recomputeInterThreadGoodMatches(globalKeypoints, globalDescriptors, objExtractorLoc, workingThreadId, globalIdx, threadID, neighbourThreadId); } #pragma omp master { // re-swaping into global extractors' new points, due to swaping carried out at the end of inter thread matching: objExtractor.keypoints = objExtractorLoc.keypointsOld; objExtractor.descriptors = objExtractorLoc.descriptorsOld.clone(); objExtractor.featureMatching(); rFeatures.homographyRANSAC(3.0f, true); #ifdef VISUALIZE analysis::frameCount = cap.get(CV_CAP_PROP_POS_FRAMES) - 1; #endif } } //Compute velocity projection vectors: rFeatures.compute(); objExtractor.goodMatches.clear(); #ifdef VISUALIZE //Analyze and verify data if necessary: if((char)cv::waitKey(cap.get(CV_CAP_PROP_FPS))==27) break; cv::waitKey(10); #endif /****************************SERIAL-REGION**************************************/ #else //Get first frame and extract new features: analysis::refFrameCount = cap.get(CV_CAP_PROP_POS_FRAMES); #if defined(VISUALIZE) || defined(WRITEIMAGE) cv::Mat refFrame; #endif cap >> objExtractor.frame; #if defined(VISUALIZE) || defined(WRITEIMAGE) objExtractor.frame.copyTo(refFrame); #endif objExtractor.extractFeatures(); #ifdef PROF analysis::perfTime[analysis::frameCount][2] = objExtractor.elapsedTime.count(); #endif // Keep ref. of the first keypoints and their descriptors: objExtractor.descriptors.copyTo(tmpDescriptors); tmpKeypoints = objExtractor.keypoints; // Specify initial features as old features: objExtractor.swap(); // Follow keypoints over the next frames: while((size_t)cap.get(CV_CAP_PROP_POS_FRAMES) < frameTotal ) { analysis::frameCount = cap.get(CV_CAP_PROP_POS_FRAMES); analysis::outliers = 0; cap >> objExtractor.frame; objExtractor.extractFeatures(); #ifdef PROF analysis::perfTime[analysis::frameCount][2] = objExtractor.elapsedTime.count(); analysis::start = std::chrono::high_resolution_clock::now(); #endif // FLANN based matching of keypoints: objExtractor.featureMatching(); #ifdef PROF analysis::stop = std::chrono::high_resolution_clock::now(); analysis::elapsedTime = analysis::stop - analysis::start; analysis::perfTime[analysis::frameCount][0] = analysis::elapsedTime.count(); #endif #ifdef VISUALIZE analysis::visMatchingPts(objExtractor); cv::waitKey(5); #endif #ifdef WRITEDATA analysis::keypointsVector[analysis::frameCount] = std::min((size_t)objExtractor.keypoints.size(), (size_t)objExtractor.keypointsOld.size()); analysis::matchOutliersVector[analysis::frameCount] = analysis::keypointsVector[analysis::frameCount] - (size_t)objExtractor.goodMatches.size(); #endif #ifdef PROF analysis::start = std::chrono::high_resolution_clock::now(); #endif // RANSAC based outlier classification: rFeatures.homographyRANSAC(1.2f, true); #ifdef PROF analysis::stop = std::chrono::high_resolution_clock::now(); analysis::elapsedTime = analysis::stop - analysis::start; analysis::perfTime[analysis::frameCount][1] = analysis::elapsedTime.count(); #endif #ifdef VISUALIZE analysis::visMatchingPts(objExtractor); cv::waitKey(5); #endif float OF = 0.0f; // Calculation of motion field norm makes sense only if matching points are greater than 3 if ((size_t)objExtractor.goodMatches.size() > 3) { // Calculate intra-frame motion flow norm OF = helperFunc::calcMeanOFNorm(objExtractor.keypoints, objExtractor.keypointsOld, objExtractor.goodMatches); } #ifdef WRITEDATA analysis::OFNorm[analysis::frameCount] = helperFunc::calcMeanOFNorm(objExtractor.keypoints, objExtractor.keypointsOld, objExtractor.goodMatches); #endif // Different cases of computation: if ((size_t)objExtractor.goodMatches.size() < 5 || OF >= OFThresh) { // Case 1: Matching(refFrame(n) , refFrame(n+1)) lead to no good matches if (analysis::refFrameCount == (analysis::frameCount - 1) ) { // If large motion field norm was the case then compute ttc: if (OF >= OFThresh) { //Compute velocity projection vectors and ttc: rFeatures.compute(); } // Define latest frame as refFrame analysis::refFrameCount = analysis::frameCount; objExtractor.descriptors.copyTo(tmpDescriptors); tmpKeypoints = objExtractor.keypoints; #if defined(VISUALIZE) || defined(WRITEIMAGE) refFrame = objExtractor.frame.clone(); #endif // Move latest frame data to old objExtractor.swap(); } // Case 2: Matching(refFrame(n+i) , refFrame(n+i+1)) lead to no good matches else { // In case of motion flow greater than threshold compute ttc for the given intra-frame motion otherwise move consistent features and compute motion flow if (OF >= OFThresh) { // Compute velocity projection vectors: rFeatures.compute(); // Define latest frame as refFrame analysis::refFrameCount = analysis::frameCount; objExtractor.descriptors.copyTo(tmpDescriptors); tmpKeypoints = objExtractor.keypoints; #if defined(VISUALIZE) || defined(WRITEIMAGE) refFrame = objExtractor.frame.clone(); #endif // Move latest frame data to old objExtractor.swap(); } else { // Move consistent good matching features to new objExtractor.keypoints.swap(objExtractor.keypointsOld); objExtractor.keypointsOld.swap(tmpKeypoints); cv::Mat placeHolder(objExtractor.descriptors.size(), objExtractor.descriptors.type()); #ifdef OPTIMIZED objExtractor.descriptors.copyTo(placeHolder); #else placeHolder = objExtractor.descriptors.clone(); #endif objExtractor.descriptors.resize(0); objExtractor.descriptorsOld.copyTo(objExtractor.descriptors); tmpDescriptors.copyTo(objExtractor.descriptorsOld ); tmpDescriptors.resize(0); #ifdef OPTIMIZED placeHolder.copyTo(tmpDescriptors); #else tmpDescriptors = placeHolder.clone(); #endif placeHolder.release(); #if defined(VISUALIZE) || defined(WRITEIMAGE) cv::Mat tmpFrame; tmpFrame = objExtractor.frame.clone(); objExtractor.frame = objExtractor.frameOld.clone(); objExtractor.frameOld = refFrame.clone(); refFrame = tmpFrame.clone(); tmpFrame.release(); #endif // Match refFrame features with consistent good matching features uptil refFrame(n+i) objExtractor.featureMatching(); #ifdef VISUALIZE analysis::visMatchingPts(objExtractor, "Using Consistent Features"); cv::waitKey(10); #endif // Calculate Motion Flow norm OF = helperFunc::calcMeanOFNorm(objExtractor.keypoints, objExtractor.keypointsOld, objExtractor.goodMatches); if( OF > OFThresh ) { // Compute motion flow and ttc: rFeatures.compute(); } objExtractor.goodMatches.clear(); objExtractor.keypointsOld = tmpKeypoints; tmpDescriptors.copyTo(objExtractor.descriptorsOld); // Define latest frame as refFrame analysis::refFrameCount = analysis::frameCount; } } } else { objExtractor.swapGM(); } #ifdef VISUALIZE if((char)cv::waitKey(cap.get(CV_CAP_PROP_FPS))==27) break; cv::waitKey(10); #endif } #endif } } catch(cv::Exception) { std::cerr << "Exception @ frame : " << cap.get(CV_CAP_PROP_POS_FRAMES) << "\n"; } #ifdef USE_PAPI // Collect data from the event set if ( PAPI_stop(eventset, values) != PAPI_OK ) { printf("Problem while reading PAPI event set!\n"); exit(EXIT_FAILURE); } // Print results total_time = ((double)(PAPI_get_real_usec() - start_time))/1000000; printf("Computation execution time: %lf seconds\n", total_time); printf("L1 Cache miss rate = %lf \n",((double)values[1])/(values[0])); printf("L2 Cache miss rate = %lf \n",((double)values[3])/(values[2])); #endif /*************************WRITE DATA TO FILE BLOCK********************************/ /*<---------------------------- REGQUIRES SETTING OF PERSONAL PATH TO SAVING GENERATED DATA -------------------------->*/ #ifdef WRITEDATA std::ofstream file; std::string fileName; fileName = "/home/ragesam/gitThesis/testCase/poseFeatures/build/ttc_" + analysis::timeStamp + ".dat"; std::cout << "\nWRITING TTC DATA TO FILE \n"; file.open(fileName); if(!file.is_open()) { std::cout << "\nCan not write TTC to file\n"; std::exit(EXIT_FAILURE); } else { for (size_t i = 0; i < (size_t)analysis::TTCvector.size(); ++i) { file << i << "\t" << analysis::TTCvector[i] << "\t" << analysis::kpVector[i] <<"\n"; } } file.close(); fileName = "/home/ragesam/gitThesis/testCase/poseFeatures/build/outliers_" + analysis::timeStamp + ".dat"; std::cout << "\nWRITING OUTLIER DATA TO FILE \n"; file.open(fileName); if(!file.is_open()) { std::cout << "\nCan not write outliers to file\n"; std::exit(EXIT_FAILURE); } else { file << "Frame #\t# of Keypoints\tFLANN based outliers\tRANSAC based outliers\tIntra-fram projection vector norm\n"; for (size_t i = 0; i < (size_t)analysis::outliersVector.size(); ++i) { file << i << "\t" << analysis::keypointsVector[i] << "\t" << analysis::matchOutliersVector[i] << "\t" << analysis::outliersVector[i] << "\t" << analysis::OFNorm[i] <<"\n"; } } file.close(); #endif #ifdef PROF std::ofstream fileProf; std::string fileNameProf; fileNameProf = "/home/ragesam/gitThesis/testCase/poseFeatures/build/profile_" + analysis::timeStamp + ".dat"; std::cout << "\nWRITING PROFILING DATA TO FILE \n"; fileProf.open(fileNameProf); if(!fileProf.is_open()) { std::cout << "\nCan not write profiling data to file\n"; std::exit(EXIT_FAILURE); } else { fileProf << "Frame #\telapsedTime Matching\telapsedTime RANSAC\telapsedTimeDetection\n"; for (size_t i = 0; i < (size_t)analysis::perfTime.size(); ++i) { fileProf << i << "\t" << analysis::perfTime[i][0] << "\t" << analysis::perfTime[i][1] << "\t" << analysis::perfTime[i][2] << "\n"; } } fileProf.close(); #endif cap.release(); return 0; }
static int papi_internal_init(pmdaInterface *dp) { int ec; int sts; PAPI_event_info_t info; char entry[PAPI_HUGE_STR_LEN+12]; // the length papi uses for the symbol name unsigned int i = 0; pmID pmid; sts = sprintf(papi_version, "%d.%d.%d", PAPI_VERSION_MAJOR(PAPI_VERSION), PAPI_VERSION_MINOR(PAPI_VERSION), PAPI_VERSION_REVISION(PAPI_VERSION)); if (sts < 0) { __pmNotifyErr(LOG_ERR, "%s failed to create papi version metric.\n",pmProgname); return PM_ERR_GENERIC; } if ((sts = __pmNewPMNS(&papi_tree)) < 0) { __pmNotifyErr(LOG_ERR, "%s failed to create dynamic papi pmns: %s\n", pmProgname, pmErrStr(sts)); papi_tree = NULL; return PM_ERR_GENERIC; } number_of_counters = PAPI_num_counters(); if (number_of_counters < 0) { __pmNotifyErr(LOG_ERR, "hardware does not support performance counters\n"); return PM_ERR_APPVERSION; } else if (number_of_counters == 0) { __pmNotifyErr(LOG_WARNING, "no performance counters\n"); } sts = PAPI_library_init(PAPI_VER_CURRENT); if (sts != PAPI_VER_CURRENT) { __pmNotifyErr(LOG_ERR, "PAPI_library_init error (%d)\n", sts); return PM_ERR_GENERIC; } ec = PAPI_PRESET_MASK; PAPI_enum_event(&ec, PAPI_ENUM_FIRST); do { if (PAPI_get_event_info(ec, &info) == PAPI_OK) { if (info.count && PAPI_PRESET_ENUM_AVAIL) { expand_papi_info(i); memcpy(&papi_info[i].info, &info, sizeof(PAPI_event_info_t)); memcpy(&papi_info[i].papi_string_code, info.symbol + 5, strlen(info.symbol)-5); snprintf(entry, sizeof(entry),"papi.system.%s", papi_info[i].papi_string_code); pmid = pmid_build(dp->domain, CLUSTER_PAPI, i); papi_info[i].pmid = pmid; __pmAddPMNSNode(papi_tree, pmid, entry); memset(&entry[0], 0, sizeof(entry)); papi_info[i].position = -1; papi_info[i].metric_enabled = 0; expand_values(i); i++; } } } while(PAPI_enum_event(&ec, 0) == PAPI_OK); #if defined(HAVE_PAPI_DISABLED_COMP) char *tokenized_string; int number_of_components; int component_id; int native; number_of_components = PAPI_num_components(); native = 0 | PAPI_NATIVE_MASK; for (component_id = 0; component_id < number_of_components; component_id++) { const PAPI_component_info_t *component; component = PAPI_get_component_info(component_id); if (component->disabled || (strcmp("perf_event", component->name) && strcmp("perf_event_uncore", component->name))) continue; sts = PAPI_enum_cmp_event (&native, PAPI_ENUM_FIRST, component_id); if (sts == PAPI_OK) do { if (PAPI_get_event_info(native, &info) == PAPI_OK) { char local_native_metric_name[PAPI_HUGE_STR_LEN] = ""; int was_tokenized = 0; expand_papi_info(i); memcpy(&papi_info[i].info, &info, sizeof(PAPI_event_info_t)); tokenized_string = strtok(info.symbol, "::: -"); while (tokenized_string != NULL) { size_t remaining = sizeof(local_native_metric_name) - strlen(local_native_metric_name) - 1; if (remaining < 1) break; strncat(local_native_metric_name, tokenized_string, remaining); was_tokenized = 1; tokenized_string=strtok(NULL, "::: -"); if (tokenized_string) { remaining = sizeof(local_native_metric_name) - strlen(local_native_metric_name) - 1; if (remaining < 1) break; strncat(local_native_metric_name, ".", remaining); } } if (!was_tokenized) { strncpy(papi_info[i].papi_string_code, info.symbol, sizeof(papi_info[i].papi_string_code) - 1); } else { strncpy(papi_info[i].papi_string_code, local_native_metric_name, sizeof(papi_info[i].papi_string_code) - 1); } snprintf(entry, sizeof(entry),"papi.system.%s", papi_info[i].papi_string_code); pmid = pmid_build(dp->domain, CLUSTER_PAPI, i); papi_info[i].pmid = pmid; __pmAddPMNSNode(papi_tree, pmid, entry); memset(&entry[0], 0, sizeof(entry)); papi_info[i].position = -1; papi_info[i].metric_enabled = 0; expand_values(i); i++; } } while (PAPI_enum_cmp_event(&native, PAPI_ENUM_EVENTS, component_id) == PAPI_OK); } #endif pmdaTreeRebuildHash(papi_tree, number_of_events); /* Set one-time settings for all future EventSets. */ if ((sts = PAPI_set_domain(PAPI_DOM_ALL)) != PAPI_OK) { handle_papi_error(sts, 0); return PM_ERR_GENERIC; } if ((sts = PAPI_multiplex_init()) != PAPI_OK) { handle_papi_error(sts, 0); return PM_ERR_GENERIC; } sts = refresh_metrics(0); if (sts != PAPI_OK) return PM_ERR_GENERIC; return 0; }