void
test_print_event_header( char *call, int evset )
{
int *ev_ids;
int i, nev;
int retval;
char evname[PAPI_MAX_STR_LEN];
if ( *call )
fprintf( stdout, "%s", call );
if ((nev = PAPI_get_cmp_opt(PAPI_MAX_MPX_CTRS,NULL,0)) <= 0) {
fprintf( stdout, "Can not list event names.\n" );
return;
}
if ((ev_ids = calloc(nev,sizeof(int))) == NULL) {
fprintf( stdout, "Can not list event names.\n" );
return;
}
retval = PAPI_list_events( evset, ev_ids, &nev );
if ( retval == PAPI_OK ) {
for ( i = 0; i < nev; i++ ) {
PAPI_event_code_to_name( ev_ids[i], evname );
printf( ONEHDR, evname );
}
} else {
fprintf( stdout, "Can not list event names." );
}
fprintf( stdout, "\n" );
free(ev_ids);
}
// Stops the papi counters and prints results
void counter_stop( int * eventset, int num_papi_events )
{
int * events = malloc(num_papi_events * sizeof(int));
int n = num_papi_events;
PAPI_list_events( *eventset, events, &n );
PAPI_event_info_t info;
long_long * values = malloc( num_papi_events * sizeof(long_long));
PAPI_stop(*eventset, values);
int thread = omp_get_thread_num();
static long long accum_vals[5] = {0};
#pragma omp critical (papi)
{
printf("Thread %d\n", thread);
for( int i = 0; i < num_papi_events; i++ )
{
accum_vals[i] += values[i];
PAPI_get_event_info(events[i], &info);
printf("%-15lld\t%s\t%s\n", values[i],info.symbol,info.long_descr);
}
}
{
#pragma omp barrier
}
#pragma omp master
{
printf("Aummulated totals!\n");
for( int i = 0; i < num_papi_events; i++ )
{
PAPI_get_event_info(events[i], &info);
printf("%-15lld\t%s\n", accum_vals[i], info.symbol);
}
printf("GFLOPs: %lf\n", (double)accum_vals[0] / (double)accum_vals[1] * 32.);
}
free(events);
free(values);
}
// Stops the papi counters and prints results
void counter_stop( int * eventset, int num_papi_events )
{
int * events = malloc(num_papi_events * sizeof(int));
int n = num_papi_events;
PAPI_list_events( *eventset, events, &n );
PAPI_event_info_t info;
long_long * values = malloc( num_papi_events * sizeof(long_long));
PAPI_stop(*eventset, values);
int thread = omp_get_thread_num();
#pragma omp critical (papi)
{
printf("Thread %d\n", thread);
for( int i = 0; i < num_papi_events; i++ )
{
PAPI_get_event_info(events[i], &info);
printf("%-15lld\t%s\t%s\n", values[i],info.symbol,info.long_descr);
}
free(events);
free(values);
}
}
void
test_print_event_header( char *call, int evset )
{
int ev_ids[PAPI_MAX_HWCTRS + PAPI_MPX_DEF_DEG];
int i, nev;
int retval;
char evname[PAPI_MAX_STR_LEN];
nev = PAPI_MAX_HWCTRS + PAPI_MPX_DEF_DEG;
retval = PAPI_list_events( evset, ev_ids, &nev );
if ( *call )
fprintf( stdout, "%s", call );
if ( retval == PAPI_OK ) {
for ( i = 0; i < nev; i++ ) {
PAPI_event_code_to_name( ev_ids[i], evname );
printf( ONEHDR, evname );
}
} else {
fprintf( stdout, "Can not list event names." );
}
fprintf( stdout, "\n" );
}
int main(int argc, char **argv)
{
PAPI_event_info_t info;
char name2[PAPI_MAX_STR_LEN];
int i, j, retval, idx, repeats;
int iters = NUM_FLOPS;
double x = 1.1, y, dtmp;
long long t1, t2;
long long values[MAXEVENTS], refvals[MAXEVENTS];
int nsamples[MAXEVENTS], truelist[MAXEVENTS], ntrue;
#ifdef STARTSTOP
long long dummies[MAXEVENTS];
#endif
int sleep_time = SLEEPTIME;
double valsample[MAXEVENTS][REPEATS];
double valsum[MAXEVENTS];
double avg[MAXEVENTS];
double spread[MAXEVENTS];
int nevents = MAXEVENTS, nev1;
int eventset = PAPI_NULL;
int events[MAXEVENTS];
int eventidx[MAXEVENTS];
int eventmap[MAXEVENTS];
int fails;
events[0] = PAPI_FP_INS;
events[1] = PAPI_TOT_CYC;
events[2] = PAPI_TOT_INS;
events[3] = PAPI_TOT_IIS;
events[4] = PAPI_INT_INS;
events[5] = PAPI_STL_CCY;
events[6] = PAPI_BR_INS;
events[7] = PAPI_SR_INS;
events[8] = PAPI_LD_INS;
for (i = 0; i < MAXEVENTS; i++) {
values[i] = 0;
valsum[i] = 0;
nsamples[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("\nFunctional check of multiplexing routines.\n");
printf("Adding and removing events from an event set.\n\n");
}
if ((retval = PAPI_library_init(PAPI_VER_CURRENT)) != PAPI_VER_CURRENT)
test_fail(__FILE__, __LINE__, "PAPI_library_init", retval);
#ifdef MPX
init_multiplex();
#endif
if ((retval = PAPI_create_eventset(&eventset)))
test_fail(__FILE__, __LINE__, "PAPI_create_eventset", retval);
#ifdef MPX
/* In Component PAPI, EventSets must be assigned a component index
before you can fiddle with their internals.
0 is always the cpu component */
retval = PAPI_assign_eventset_component(eventset, 0);
if (retval != PAPI_OK)
test_fail(__FILE__, __LINE__, "PAPI_assign_eventset_component", retval);
if ((retval = PAPI_set_multiplex(eventset)))
test_fail(__FILE__, __LINE__, "PAPI_set_multiplex", retval);
#endif
nevents = MAXEVENTS;
for (i = 0; i < nevents; i++) {
if ((retval = PAPI_add_event(eventset, events[i]))) {
for (j = i; j < MAXEVENTS; j++)
events[j] = events[j + 1];
nevents--;
i--;
}
}
if (nevents < 3)
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);
j = nevents;
for (i = 1; i < nevents; i = i + 2)
eventidx[--j] = i;
for (i = 0; i < nevents; i = i + 2)
eventidx[--j] = i;
assert(j == 0);
for (i = 0; i < nevents; i++)
eventmap[i] = i;
x = 1.0;
if (!TESTS_QUIET)
printf("\nReference run:\n");
t1 = PAPI_get_real_usec();
if ((retval = PAPI_start(eventset)))
test_fail(__FILE__, __LINE__, "PAPI_start", retval);
y = dummy3(x, iters);
PAPI_read(eventset, refvals);
t2 = PAPI_get_real_usec();
ntrue = nevents;
PAPI_list_events(eventset, truelist, &ntrue);
if (!TESTS_QUIET) {
printf("\tOperations= %.1f Mflop", y * 1e-6);
printf("\t(%g Mflop/s)\n\n", ((float) y / (t2 - t1)));
printf("%20s %16s %-15s %-15s\n", "PAPI measurement:",
"Acquired count", "Expected event", "PAPI_list_events");
}
if (!TESTS_QUIET) {
for (j = 0; j < nevents; j++) {
PAPI_get_event_info(events[j], &info);
PAPI_event_code_to_name(truelist[j], name2);
if (!TESTS_QUIET)
printf("%20s = %16lld %-15s %-15s %s\n", info.short_descr, refvals[j],
info.symbol, name2, strcmp(info.symbol,
name2) ? "*** MISMATCH ***" : "");
}
printf("\n");
}
nev1 = nevents;
repeats = nevents * 4;
for (i = 0; i < repeats; i++) {
if ((i % nevents) + 1 == nevents)
continue;
if (!TESTS_QUIET)
printf("\nTest %d (of %d):\n", i + 1 - i / nevents, repeats - 4);
if ((retval = PAPI_stop(eventset, values)))
test_fail(__FILE__, __LINE__, "PAPI_stop", retval);
j = eventidx[i % nevents];
if ((i / nevents) % 2 == 0) {
PAPI_get_event_info(events[j], &info);
if (!TESTS_QUIET)
printf("Removing event[%d]: %s\n", j, info.short_descr);
if ((retval = PAPI_remove_event(eventset, events[j])))
test_fail(__FILE__, __LINE__, "PAPI_remove_event", retval);
nev1--;
for (idx = 0; eventmap[idx] != j; idx++);
for (j = idx; j < nev1; j++)
eventmap[j] = eventmap[j + 1];
} else {
PAPI_get_event_info(events[j], &info);
if (!TESTS_QUIET)
printf("Adding event[%d]: %s\n", j, info.short_descr);
if ((retval = PAPI_add_event(eventset, events[j])))
test_fail(__FILE__, __LINE__, "PAPI_add_event", retval);
eventmap[nev1] = j;
nev1++;
}
if ((retval = PAPI_start(eventset)))
test_fail(__FILE__, __LINE__, "PAPI_start", retval);
x = 1.0;
#ifndef STARTSTOP
if ((retval = PAPI_reset(eventset)))
test_fail(__FILE__, __LINE__, "PAPI_reset", retval);
#else
if ((retval = PAPI_stop(eventset, dummies)))
test_fail(__FILE__, __LINE__, "PAPI_stop", retval);
if ((retval = PAPI_start(eventset)))
test_fail(__FILE__, __LINE__, "PAPI_start", retval);
#endif
t1 = PAPI_get_real_usec();
y = dummy3(x, iters);
PAPI_read(eventset, values);
t2 = PAPI_get_real_usec();
if (!TESTS_QUIET) {
printf("\n(calculated independent of PAPI)\n");
printf("\tOperations= %.1f Mflop", y * 1e-6);
printf("\t(%g Mflop/s)\n\n", ((float) y / (t2 - t1)));
printf("%20s %16s %-15s %-15s\n", "PAPI measurement:",
"Acquired count", "Expected event", "PAPI_list_events");
}
ntrue = nev1;
PAPI_list_events(eventset, truelist, &ntrue);
for (j = 0; j < nev1; j++) {
idx = eventmap[j];
/* printf("Mapping: Counter %d -> slot %d.\n",j,idx); */
PAPI_get_event_info(events[idx], &info);
PAPI_event_code_to_name(truelist[j], name2);
if (!TESTS_QUIET)
printf("%20s = %16lld %-15s %-15s %s\n", info.short_descr, values[j],
info.symbol, name2, strcmp(info.symbol,
name2) ? "*** MISMATCH ***" : "");
dtmp = (double) values[j];
valsum[idx] += dtmp;
valsample[idx][nsamples[idx]] = dtmp;
nsamples[idx]++;
}
if (!TESTS_QUIET)
printf("\n");
}
if (!TESTS_QUIET) {
printf("\n\nEstimated variance relative to average counts:\n");
for (j = 0; j < nev1; j++)
printf(" Event %.2d", j);
printf("\n");
}
fails = nevents;
/* Due to limited precision of floating point cannot really use
typical standard deviation compuation for large numbers with
very small variations. Instead compute the std devation
problems with precision.
*/
for (j = 0; j < nev1; j++) {
avg[j] = valsum[j] / nsamples[j];
spread[j] = 0;
for (i=0; i < nsamples[j]; ++i) {
double diff = (valsample[j][i] - avg[j]);
spread[j] += diff * diff;
}
spread[j] = sqrt(spread[j] / nsamples[j]) / avg[j];
if (!TESTS_QUIET)
printf("%9.2g ", spread[j]);
/* Make sure that NaN get counted as errors */
if (spread[j] < MPX_TOLERANCE)
fails--;
else if (values[j] < MINCOUNTS) /* Neglect inprecise results with low counts */
fails--;
}
if (!TESTS_QUIET) {
printf("\n\n");
for (j = 0; j < nev1; j++) {
PAPI_get_event_info(events[j], &info);
printf("Event %.2d: mean=%10.0f, sdev/mean=%7.2g nrpt=%2d -- %s\n",
j, avg[j], spread[j], nsamples[j], info.short_descr);
}
printf("\n\n");
}
if (fails)
test_fail(__FILE__, __LINE__, "Values differ from reference", fails);
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 main(int argc, char **argv)
{
int retval, num_tests = 2, eventcnt, events[2], i, tmp;
int EventSet1 = PAPI_NULL, EventSet2 = PAPI_NULL;
int PAPI_event;
long_long values1[2], values2[2];
long_long elapsed_cyc;
char event_name[PAPI_MAX_STR_LEN], add_event_str[PAPI_MAX_STR_LEN];
retval = PAPI_library_init(PAPI_VER_CURRENT);
retval = PAPI_set_debug(PAPI_VERB_ECONT);
/* query and set up the right instruction to monitor */
if (PAPI_query_event(PAPI_FP_OPS) == PAPI_OK)
PAPI_event = PAPI_FP_OPS;
else
PAPI_event = PAPI_TOT_INS;
retval = PAPI_event_code_to_name(PAPI_event, event_name);
sprintf(add_event_str, "PAPI_add_event[%s]", event_name);
retval = PAPI_create_eventset(&EventSet1);
/* Add the events */
retval = PAPI_add_event(EventSet1, PAPI_event);
retval = PAPI_add_event(EventSet1, PAPI_TOT_CYC);
/* Add them reversed to EventSet2 */
retval = PAPI_create_eventset(&EventSet2);
eventcnt = 2;
retval = PAPI_list_events(EventSet1, events, &eventcnt);
for (i = eventcnt - 1; i >= 0; i--) {
retval = PAPI_event_code_to_name(events[i], event_name);
retval = PAPI_add_event(EventSet2, events[i]);
}
elapsed_cyc = PAPI_get_real_cyc();
retval = PAPI_start(EventSet1);
do_flops(NUM_FLOPS);
retval = PAPI_stop(EventSet1, values1);
retval = PAPI_start(EventSet2);
do_flops(NUM_FLOPS);
retval = PAPI_stop(EventSet2, values2);
elapsed_cyc = PAPI_get_real_cyc() - elapsed_cyc;
retval = PAPI_cleanup_eventset(EventSet1); /* JT */
retval = PAPI_destroy_eventset(&EventSet1);
retval = PAPI_cleanup_eventset(EventSet2); /* JT */
retval = PAPI_destroy_eventset(&EventSet2);
printf("Test case 0: start, stop.\n");
printf("-----------------------------------------------\n");
tmp = PAPI_get_opt(PAPI_DEFDOM, NULL);
tmp = PAPI_get_opt(PAPI_DEFGRN, NULL);
printf("Using %d iterations of c += a*b\n", NUM_FLOPS);
printf
("-------------------------------------------------------------------------\n");
printf("Test type : \t 1\t 2\n");
printf("%ld %ld\n", values1[0], values2[1]);
printf("%d %d\n", "PAPI_TOT_INS : \t", values1[1], values2[0]);
printf("%ld\n", "Real cycles : \t", elapsed_cyc);
printf
("-------------------------------------------------------------------------\n");
printf("Verification: none\n");
exit(1);
}
// Stops the papi counters and prints results
void counter_stop( int * eventset, int num_papi_events, Input * I )
{
int * events = malloc(num_papi_events * sizeof(int));
int n = num_papi_events;
PAPI_list_events( *eventset, events, &n );
PAPI_event_info_t info;
long_long * values = malloc( num_papi_events * sizeof(long_long));
PAPI_stop(*eventset, values);
int thread = omp_get_thread_num();
int nthreads = omp_get_num_threads();
static long LLC_cache_miss = 0;
static long total_cycles = 0;
static long FLOPS = 0;
static long stall_any = 0;
static long stall_SB = 0;
static long stall_RS = 0;
static long stall_OO = 0;
static long tlb_load = 0;
static long tlb_load_m = 0;
static long tlb_store = 0;
static long tlb_store_m = 0;
#pragma omp master
{
I->vals_accum = malloc( num_papi_events * sizeof(long long));
for(int i=0; i < num_papi_events ; i ++)
I->vals_accum[i] = 0;
}
#pragma omp barrier
#pragma omp critical (papi)
{
printf("Thread %d\n", thread);
for( int i = 0; i < num_papi_events; i++ )
{
I->vals_accum[i] += values[i];
PAPI_get_event_info(events[i], &info);
printf("%-15lld\t%s\t%s\n", values[i],info.symbol,info.long_descr);
if( strcmp(info.symbol, "PAPI_L3_TCM") == 0 )
LLC_cache_miss += values[i];
if( strcmp(info.symbol, "PAPI_TOT_CYC") == 0 )
total_cycles += values[i];
if( strcmp(info.symbol, "PAPI_SP_OPS") == 0 )
FLOPS += values[i];
if( strcmp(info.symbol, "RESOURCE_STALLS:ANY") == 0 )
stall_any += values[i];
if( strcmp(info.symbol, "RESOURCE_STALLS:SB") == 0 )
stall_SB += values[i];
if( strcmp(info.symbol, "RESOURCE_STALLS:RS") == 0 )
stall_RS += values[i];
if( strcmp(info.symbol, "RESOURCE_STALLS2:OOO_RSRC") == 0 )
stall_OO += values[i];
if( strcmp(info.symbol, "perf::DTLB-LOADS") == 0 )
tlb_load += values[i];
if( strcmp(info.symbol, "perf::DTLB-LOAD-MISSES") == 0 )
tlb_load_m += values[i];
if( strcmp(info.symbol, "perf::DTLB-STORES") == 0 )
tlb_store += values[i];
if( strcmp(info.symbol, "perf::DTLB-STORE-MISSES") == 0 )
tlb_store_m += values[i];
}
free(values);
}
{
#pragma omp barrier
}
#pragma omp master
{
if( omp_get_num_threads() > 1){
printf("Thread Totals:\n");
for( int i = 0; i < num_papi_events; i++ )
{
PAPI_get_event_info(events[i], &info);
printf("%-15lld\t%s\t%s\n", I->vals_accum[i],info.symbol,info.long_descr);
}
}
free( I->vals_accum );
border_print();
center_print("PERFORMANCE SUMMARY", 79);
border_print();
long cycles = (long) (total_cycles / (double) nthreads);
double bw = LLC_cache_miss*64./cycles*2.8e9/1024./1024./1024.;
if( I->papi_event_set == 0 )
printf("GFLOPs: %.3lf\n", FLOPS / (double) cycles * 2.8 );
if( I->papi_event_set == 1 )
printf("Bandwidth: %.3lf (GB/s)\n", bw);
if( I->papi_event_set == 2 )
{
printf("%-30s %.2lf%%\n", "Store Buffer Full:",
stall_SB / (double) stall_any * 100.);
printf("%-30s %.2lf%%\n", "Reservation Station Full:",
stall_RS / (double) stall_any * 100.);
printf("%-30s %.2lf%%\n", "OO Pipeline Full:",
stall_OO / (double) stall_any * 100.);
}
if( I->papi_event_set == 3 )
printf("CPU Stalled Cycles: %.2lf%%\n",
stall_any / (double) total_cycles * 100.);
if( I->papi_event_set == 7 )
{
printf("%-30s %.2lf%%\n", "Data TLB Load Miss Rate: ",
tlb_load_m / (double) tlb_load * 100 );
printf("%-30s %.2lf%%\n", "Data TLB Store Miss Rate: ",
tlb_store_m / (double) tlb_store * 100 );
}
border_print();
}
free(events);
}
int case1(void)
{
int retval, i, EventSet = PAPI_NULL, j = 0, k = 0, allvalid = 1;
int max_mux, nev, *events;
long long *values;
PAPI_event_info_t pset;
char evname[PAPI_MAX_STR_LEN];
init_papi();
init_multiplex();
retval = PAPI_create_eventset(&EventSet);
if (retval != PAPI_OK)
test_fail(__FILE__, __LINE__, "PAPI_create_eventset", retval);
/* In Component PAPI, EventSets must be assigned a component index
before you can fiddle with their internals.
0 is always the cpu component */
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);
max_mux = PAPI_get_opt(PAPI_MAX_MPX_CTRS, NULL);
if (max_mux > 32) max_mux = 32;
/* Fill up the event set with as many non-derived events as we can */
printf("\nFilling the event set with as many non-derived events as we can...\n");
i = PAPI_PRESET_MASK;
do {
if (PAPI_get_event_info(i, &pset) == PAPI_OK)
{
if (pset.count && (strcmp(pset.derived,"NOT_DERIVED") == 0))
{
retval = PAPI_add_event(EventSet, pset.event_code);
if (retval != PAPI_OK)
test_fail(__FILE__, __LINE__, "PAPI_add_event", retval);
else
{
printf("Added %s\n", pset.symbol);
j++;
}
}
}
} while ((PAPI_enum_event(&i, PAPI_PRESET_ENUM_AVAIL) == PAPI_OK) && (j < max_mux));
events = (int *) malloc(j * sizeof(int));
if (events == NULL)
test_fail(__FILE__, __LINE__, "malloc events", 0);
values = (long long *) malloc(j * sizeof(long long));
if (values == NULL)
test_fail(__FILE__, __LINE__, "malloc values", 0);
do_stuff();
if (PAPI_start(EventSet) != PAPI_OK)
test_fail(__FILE__, __LINE__, "PAPI_start", retval);
do_stuff();
retval = PAPI_stop(EventSet, values);
if (retval != PAPI_OK)
test_fail(__FILE__, __LINE__, "PAPI_stop", retval);
nev =j;
retval = PAPI_list_events(EventSet, events, &nev);
if (retval != PAPI_OK)
test_fail(__FILE__, __LINE__, "PAPI_list_events", retval);
printf("\nEvent Counts:\n");
for (i = 0, allvalid = 0; i < j; i++) {
PAPI_event_code_to_name(events[i], evname);
printf(TAB1, evname, values[i]);
if (values[i] == 0)
allvalid++;
}
printf("\n");
if (allvalid){
printf("Caution: %d counters had zero values\n", allvalid);
}
for (i = 0, allvalid = 0; i < j; i++) {
for (k = i+1; k < j; k++) {
if ((i != k) && (values[i] == values[k]))
{
allvalid++;
break;
}
}
}
if (allvalid){
printf("Caution: %d counter pair(s) had identical values\n", allvalid);
}
free(events);
free(values);
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);
return (SUCCESS);
}
