perf_t*
perf_init()
{
int retval;
int EventSet = PAPI_NULL;
retval = PAPI_create_eventset(&EventSet);
assert(retval == PAPI_OK);
retval = PAPI_assign_eventset_component(EventSet, 0);
assert(retval == PAPI_OK);
/* By default, the counter is inherited. */
PAPI_option_t opt;
memset(&opt, 0x0, sizeof(PAPI_option_t));
opt.inherit.inherit = PAPI_INHERIT_ALL;
opt.inherit.eventset = EventSet;
retval = PAPI_set_opt(PAPI_INHERIT, &opt);
assert(retval == PAPI_OK);
/* Add events by names */
for (int i = 0; i < NUM_EVENTS; i++) {
int EventCode;
if ((retval = PAPI_event_name_to_code(PERF_EVENT_NAMES[i], &EventCode)) != PAPI_OK) {
fprintf(stderr, "Event name %s not found, skipped.\n", PERF_EVENT_NAMES[i]);
continue;
}
if ((retval = PAPI_query_event(EventCode)) != PAPI_OK) {
fprintf(stderr, "Event %s not supported on this hardware, skipped.\n", PERF_EVENT_NAMES[i]);
continue;
}
if ((retval = PAPI_add_event(EventSet, EventCode)) != PAPI_OK) {
assert(retval == PAPI_ECNFLCT);
fprintf(stderr, "%s conflicts, skipped.\n", PERF_EVENT_NAMES[i]);
}
}
perf_t *perf = (perf_t*)malloc(sizeof(perf_t));
perf->EventSet = EventSet;
/* perf->values = (counter_t*)malloc(sizeof(counter_t) * NUM_EVENTS); */
/* memset(perf->values, 0x0, sizeof(counter_t) * NUM_EVENTS); */
return perf;
}
static void
measure_load_store( caddr_t start, caddr_t end )
{
PAPI_option_t option;
int retval;
/* set up the optional address structure for starting and ending data addresses */
option.addr.eventset = EventSet;
option.addr.start = start;
option.addr.end = end;
if ( ( retval = PAPI_set_opt( PAPI_DATA_ADDRESS, &option ) ) != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_set_opt(PAPI_DATA_ADDRESS)",
retval );
measure_event( 0, &option );
measure_event( 1, &option );
}
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
}
void
init_test(int SoftwareMPX, int KernelMPX, int* Events)
{
int i;
int retval;
PAPI_option_t option, itimer;
if ( ( retval = PAPI_assign_eventset_component( SoftwareMPX, 0 ) ) != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_assign_eventset_component", retval);
if ( ( retval = PAPI_assign_eventset_component( KernelMPX, 0 ) ) != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_assign_eventset_component", retval);
if ( ( retval = PAPI_set_multiplex( KernelMPX ) ) != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_set_multiplex", retval );
PAPI_get_opt(PAPI_DEF_ITIMER,&itimer);
memset(&option,0x0,sizeof(option));
option.multiplex.flags = PAPI_MULTIPLEX_FORCE_SW;
option.multiplex.eventset = SoftwareMPX;
option.multiplex.ns = itimer.itimer.ns;
PAPI_set_opt( PAPI_MULTIPLEX, &option );
for (i = 0; i < options.min - 1; i++) {
if ( options.kernel_mpx ) {
if ( ( retval = PAPI_add_event( KernelMPX, Events[i]) ) != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_add_event", retval );
}
}
if ( options.force_sw ) {
if ( ( retval = PAPI_add_event( SoftwareMPX, Events[i]) ) != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_add_event", retval );
}
}
}
}
int HWCBE_PAPI_Init_Thread (UINT64 time, int threadid, int forked)
{
int i, j, rc;
PAPI_option_t options;
if (HWC_num_sets <= 0)
return FALSE;
if (forked)
{
PAPI_stop (HWCEVTSET(threadid), NULL);
for (i = 0; i < HWC_num_sets; i++)
{
rc = PAPI_cleanup_eventset (HWC_sets[i].eventsets[threadid]);
if (rc == PAPI_OK)
PAPI_destroy_eventset (&HWC_sets[i].eventsets[threadid]);
HWC_sets[i].eventsets[threadid] = PAPI_NULL;
}
}
//if (!forked)
{
memset (&options, 0, sizeof(options));
for (i = 0; i < HWC_num_sets; i++)
{
/* Create the eventset. Each thread will create its own eventset */
rc = PAPI_create_eventset (&(HWC_sets[i].eventsets[threadid]));
if (PAPI_OK != rc)
{
fprintf (stderr, PACKAGE_NAME": Error! Unable to create eventset (%d of %d) in thread %d\n", i+1, HWC_num_sets, threadid);
continue;
}
/* Add the selected counters */
for (j = 0; j < HWC_sets[i].num_counters; j++)
{
if (HWC_sets[i].counters[j] != NO_COUNTER)
{
rc = PAPI_add_event (HWC_sets[i].eventsets[threadid], HWC_sets[i].counters[j]);
if (rc != PAPI_OK)
{
char EventName[PAPI_MAX_STR_LEN];
PAPI_event_code_to_name (HWC_sets[i].counters[j], EventName);
fprintf (stderr, PACKAGE_NAME": Error! Hardware counter %s (0x%08x) cannot be added in set %d (thread %d)\n", EventName, HWC_sets[i].counters[j], i+1, threadid);
HWC_sets[i].counters[j] = NO_COUNTER;
/* break; */
}
}
}
/* Set the domain for these eventsets */
options.domain.eventset = HWC_sets[i].eventsets[threadid];
options.domain.domain = HWC_sets[i].domain;
rc = PAPI_set_opt (PAPI_DOMAIN, &options);
if (rc != PAPI_OK)
fprintf (stderr, PACKAGE_NAME": Error when setting domain for eventset %d\n", i+1);
}
} /* forked */
HWC_Thread_Initialized[threadid] = HWCBE_PAPI_Start_Set (0, time, HWC_current_set[threadid], threadid);
return HWC_Thread_Initialized[threadid];
}
int main( int argc, char **argv ) {
int retval;
int EventSet = PAPI_NULL;
int EventSet2 = PAPI_NULL;
long long values[1],values2[1];
char *uncore_event=NULL;
char event_name[BUFSIZ];
int uncore_cidx=-1;
const PAPI_component_info_t *info;
/* Set TESTS_QUIET variable */
tests_quiet( argc, argv );
/* Init the PAPI library */
retval = PAPI_library_init( PAPI_VER_CURRENT );
if ( retval != PAPI_VER_CURRENT ) {
test_fail( __FILE__, __LINE__, "PAPI_library_init", retval );
}
/* Find the uncore PMU */
uncore_cidx=PAPI_get_component_index("perf_event_uncore");
if (uncore_cidx<0) {
test_skip(__FILE__,__LINE__,"perf_event_uncore component not found",0);
}
/* Check if component disabled */
info=PAPI_get_component_info(uncore_cidx);
if (info->disabled) {
test_skip(__FILE__,__LINE__,"uncore component disabled",0);
}
/* Get a relevant event name */
uncore_event=get_uncore_event(event_name, BUFSIZ);
if (uncore_event==NULL) {
test_skip( __FILE__, __LINE__,
"PAPI does not support uncore on this processor", PAPI_ENOSUPP );
}
/* Create an eventset */
retval = PAPI_create_eventset(&EventSet);
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_create_eventset",retval);
}
/* Create another eventset */
retval = PAPI_create_eventset(&EventSet2);
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_create_eventset",retval);
}
/* Set a component for the EventSet */
retval = PAPI_assign_eventset_component(EventSet, uncore_cidx);
/* we need to set to a certain cpu for uncore to work */
PAPI_cpu_option_t cpu_opt;
cpu_opt.eventset=EventSet;
cpu_opt.cpu_num=0;
retval = PAPI_set_opt(PAPI_CPU_ATTACH,(PAPI_option_t*)&cpu_opt);
if (retval != PAPI_OK) {
test_skip( __FILE__, __LINE__,
"this test; trying to PAPI_CPU_ATTACH; need to run as root",
retval);
}
/* we need to set the granularity to system-wide for uncore to work */
PAPI_granularity_option_t gran_opt;
gran_opt.def_cidx=0;
gran_opt.eventset=EventSet;
gran_opt.granularity=PAPI_GRN_SYS;
retval = PAPI_set_opt(PAPI_GRANUL,(PAPI_option_t*)&gran_opt);
if (retval != PAPI_OK) {
test_skip( __FILE__, __LINE__,
"this test; trying to set PAPI_GRN_SYS",
retval);
}
/* we need to set domain to be as inclusive as possible */
PAPI_domain_option_t domain_opt;
domain_opt.def_cidx=0;
domain_opt.eventset=EventSet;
domain_opt.domain=PAPI_DOM_ALL;
retval = PAPI_set_opt(PAPI_DOMAIN,(PAPI_option_t*)&domain_opt);
if (retval != PAPI_OK) {
test_skip( __FILE__, __LINE__,
"this test; trying to set PAPI_DOM_ALL; need to run as root",
retval);
}
/* Add our uncore event */
retval = PAPI_add_named_event(EventSet, uncore_event);
if (retval != PAPI_OK) {
if ( !TESTS_QUIET ) {
fprintf(stderr,"Error trying to use event %s\n", uncore_event);
}
test_fail(__FILE__, __LINE__, "adding uncore event ",retval);
}
/* Add PAPI_TOT_CYC */
retval = PAPI_add_named_event(EventSet2, "PAPI_TOT_CYC");
if (retval != PAPI_OK) {
if ( !TESTS_QUIET ) {
fprintf(stderr,"Error trying to add PAPI_TOT_CYC\n");
}
test_fail(__FILE__, __LINE__, "adding PAPI_TOT_CYC ",retval);
}
/* Start PAPI */
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 );
}
/* our work code */
do_flops( NUM_FLOPS );
/* Stop PAPI */
retval = PAPI_stop( EventSet, values );
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 );
}
if ( !TESTS_QUIET ) {
printf("Uncore and regular event test:\n");
printf("Using uncore event %s\n",uncore_event);
printf("\t%s: %lld\n",uncore_event,values[0]);
printf("\t%s: %lld\n","PAPI_TOT_CYC",values2[0]);
}
test_pass( __FILE__, NULL, 0 );
return 0;
}
int main( int argc, char **argv ) {
int retval,i,j;
int EventSet[EVENTS_TO_TRY][MAX_PACKAGES];
long long values[EVENTS_TO_TRY][MAX_PACKAGES];
char event_name[BUFSIZ];
char uncore_base[BUFSIZ];
char uncore_event[BUFSIZ];
int uncore_cidx=-1;
int max_cbox=0;
int core_to_use=0;
const PAPI_hw_info_t *hwinfo;
/* Set TESTS_QUIET variable */
tests_quiet( argc, argv );
/* Init the PAPI library */
retval = PAPI_library_init( PAPI_VER_CURRENT );
if ( retval != PAPI_VER_CURRENT ) {
test_fail( __FILE__, __LINE__, "PAPI_library_init", retval );
}
/* Find the uncore PMU */
uncore_cidx=PAPI_get_component_index("perf_event_uncore");
if (uncore_cidx<0) {
test_skip(__FILE__,__LINE__,"perf_event_uncore component not found",0);
}
/* Get hardware info */
hwinfo = PAPI_get_hardware_info();
if ( hwinfo == NULL ) {
test_fail(__FILE__,__LINE__,"PAPI_get_hardware_info()",retval);
}
/* Get event to use */
if (hwinfo->vendor == PAPI_VENDOR_INTEL) {
if ( hwinfo->cpuid_family == 6) {
switch(hwinfo->cpuid_model) {
case 45: /* SandyBridge EP */
strncpy(event_name,"UNC_C_TOR_OCCUPANCY:ALL",BUFSIZ);
strncpy(uncore_base,"snbep_unc_cbo",BUFSIZ);
break;
case 58: /* IvyBridge */
strncpy(event_name,"UNC_CBO_CACHE_LOOKUP:STATE_I:ANY_FILTER",BUFSIZ);
strncpy(uncore_base,"ivb_unc_cbo",BUFSIZ);
break;
default:
test_skip( __FILE__, __LINE__,
"We only support IVB and SNB-EP for now", PAPI_ENOSUPP );
}
}
else {
test_skip( __FILE__, __LINE__,
"We only support IVB and SNB-EP for now", PAPI_ENOSUPP );
}
}
else {
test_skip( __FILE__, __LINE__,
"This test only supported Intel chips", PAPI_ENOSUPP );
}
if (!TESTS_QUIET) {
printf("Trying for %d sockets\n",hwinfo->sockets);
printf("threads %d cores %d ncpus %d\n", hwinfo->threads,hwinfo->cores,
hwinfo->ncpu);
}
for(i=0;i < hwinfo->sockets; i++) {
/* perf_event provides which to use in "cpumask" */
/* but libpfm4 doesn't report this back to us (yet) */
core_to_use=i*hwinfo->threads*hwinfo->cores;
if (!TESTS_QUIET) {
printf("Using core %d for socket %d\n",core_to_use,i);
}
for(j=0;j<EVENTS_TO_TRY;j++) {
/* Create an eventset */
EventSet[j][i]=PAPI_NULL;
retval = PAPI_create_eventset(&EventSet[j][i]);
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_create_eventset",retval);
}
/* Set a component for the EventSet */
retval = PAPI_assign_eventset_component(EventSet[j][i], uncore_cidx);
if (retval!=PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_assign_eventset_component",retval);
}
/* we need to set to a certain cpu for uncore to work */
PAPI_cpu_option_t cpu_opt;
cpu_opt.eventset=EventSet[j][i];
cpu_opt.cpu_num=core_to_use;
retval = PAPI_set_opt(PAPI_CPU_ATTACH,(PAPI_option_t*)&cpu_opt);
if (retval != PAPI_OK) {
test_skip( __FILE__, __LINE__,
"this test; trying to PAPI_CPU_ATTACH; need to run as root",
retval);
}
/* Default Granularity should work */
/* Default domain should work */
/* Add our uncore event */
sprintf(uncore_event,"%s%d::%s",uncore_base,j,event_name);
retval = PAPI_add_named_event(EventSet[j][i], uncore_event);
if (retval != PAPI_OK) {
max_cbox=j;
break;
}
if (!TESTS_QUIET) printf("Added %s for socket %d\n",uncore_event,i);
}
}
for(i=0;i < hwinfo->sockets; i++) {
for(j=0;j<max_cbox;j++) {
if (!TESTS_QUIET) printf("Starting EventSet %d\n",EventSet[j][i]);
/* Start PAPI */
retval = PAPI_start( EventSet[j][i] );
if ( retval != PAPI_OK ) {
printf("Error starting socket %d cbox %d\n",i,j);
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
}
}
}
/* our work code */
do_flops( NUM_FLOPS );
/* Stop PAPI */
for(i=0;i < hwinfo->sockets; i++) {
for(j=0;j<max_cbox;j++) {
retval = PAPI_stop( EventSet[j][i],&values[j][i] );
if ( retval != PAPI_OK ) {
printf("Error stopping socket %d cbox %d\n",i,j);
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
}
}
}
/* Print Results */
if ( !TESTS_QUIET ) {
for(i=0;i < hwinfo->sockets; i++) {
printf("Socket %d\n",i);
for(j=0;j<max_cbox;j++) {
printf("\t%s%d::%s %lld\n",uncore_base,j,event_name,values[j][i]);
}
}
}
PAPI_shutdown();
test_pass( __FILE__, NULL, 0 );
return 0;
}
int
main( int argc, char **argv )
{
int retval, pid, status, EventSet = PAPI_NULL;
long long int values[] = {0,0};
PAPI_option_t opt;
tests_quiet( argc, argv );
if ( ( retval = PAPI_library_init( PAPI_VER_CURRENT ) ) != PAPI_VER_CURRENT )
test_fail_exit( __FILE__, __LINE__, "PAPI_library_init", retval );
if ( ( retval = PAPI_create_eventset( &EventSet ) ) != PAPI_OK )
test_fail_exit( __FILE__, __LINE__, "PAPI_create_eventset", retval );
if ( ( retval = PAPI_assign_eventset_component( EventSet, 0 ) ) != PAPI_OK )
test_fail_exit( __FILE__, __LINE__, "PAPI_assign_eventset_component", retval );
memset( &opt, 0x0, sizeof ( PAPI_option_t ) );
opt.inherit.inherit = PAPI_INHERIT_ALL;
opt.inherit.eventset = EventSet;
if ( ( retval = PAPI_set_opt( PAPI_INHERIT, &opt ) ) != PAPI_OK ) {
if ( retval == PAPI_ECMP) {
test_skip( __FILE__, __LINE__, "Inherit not supported by current component.\n", retval );
} else {
test_fail_exit( __FILE__, __LINE__, "PAPI_set_opt", retval );
}
}
if ( ( retval = PAPI_query_event( PAPI_TOT_CYC ) ) != PAPI_OK )
test_fail_exit( __FILE__, __LINE__, "PAPI_query_event", retval );
if ( ( retval = PAPI_add_event( EventSet, PAPI_TOT_CYC ) ) != PAPI_OK )
test_fail_exit( __FILE__, __LINE__, "PAPI_add_event", retval );
retval = PAPI_query_event( PAPI_FP_INS );
if ( retval == PAPI_ENOEVNT ) {
test_warn( __FILE__, __LINE__, "PAPI_FP_INS", retval);
values[1] = NUM_FLOPS; /* fake a return value to pass the test */
} else if ( retval != PAPI_OK )
test_fail_exit( __FILE__, __LINE__, "PAPI_query_event", retval );
else if ( ( retval = PAPI_add_event( EventSet, PAPI_FP_INS ) ) != PAPI_OK )
test_fail_exit( __FILE__, __LINE__, "PAPI_add_event", retval );
if ( ( retval = PAPI_start( EventSet ) ) != PAPI_OK )
test_fail_exit( __FILE__, __LINE__, "PAPI_start", retval );
pid = fork( );
if ( pid == 0 ) {
do_flops( NUM_FLOPS );
exit( 0 );
}
if ( waitpid( pid, &status, 0 ) == -1 ) {
perror( "waitpid()" );
exit( 1 );
}
if ( ( retval = PAPI_stop( EventSet, values ) ) != PAPI_OK )
test_fail_exit( __FILE__, __LINE__, "PAPI_stop", retval );
if (!TESTS_QUIET) {
printf( "Test case inherit: parent starts, child works, parent stops.\n" );
printf( "------------------------------------------------------------\n" );
printf( "Test run : \t1\n" );
printf( "PAPI_FP_INS : \t%lld\n", values[1] );
printf( "PAPI_TOT_CYC: \t%lld\n", values[0] );
printf( "------------------------------------------------------------\n" );
printf( "Verification:\n" );
printf( "Row 1 at least %d\n", NUM_FLOPS );
printf( "Row 2 greater than row 1\n");
}
if ( values[1] < NUM_FLOPS) {
test_fail( __FILE__, __LINE__, "PAPI_FP_INS", 1 );
}
if ( values[0] < values[1]) {
test_fail( __FILE__, __LINE__, "PAPI_TOT_CYC < PAPI_FP_INS", 1 );
}
test_pass( __FILE__, NULL, 0 );
exit( 1 );
}
int
main( int argc, char **argv )
{
int num_tests=1;
int num_events=1;
int retval;
int cpu_num = 1;
int EventSet1 = PAPI_NULL;
long long **values;
char event_name[PAPI_MAX_STR_LEN] = "PAPI_TOT_CYC";
PAPI_option_t opts;
// user can provide cpu number on which to count events as arg 1
if (argc > 1) {
retval = atoi(argv[1]);
if (retval >= 0) {
cpu_num = retval;
}
}
retval = PAPI_library_init( PAPI_VER_CURRENT );
if ( retval != PAPI_VER_CURRENT )
test_fail_exit( __FILE__, __LINE__, "PAPI_library_init", retval );
retval = PAPI_create_eventset(&EventSet1);
if ( retval != PAPI_OK )
test_fail_exit( __FILE__, __LINE__, "PAPI_attach", retval );
// Force event set to be associated with component 0 (perf_events component provides all core events)
retval = PAPI_assign_eventset_component( EventSet1, 0 );
if ( retval != PAPI_OK )
test_fail_exit( __FILE__, __LINE__, "PAPI_assign_eventset_component", retval );
// Attach this event set to cpu 1
opts.cpu.eventset = EventSet1;
opts.cpu.cpu_num = cpu_num;
retval = PAPI_set_opt( PAPI_CPU_ATTACH, &opts );
if ( retval != PAPI_OK )
test_fail_exit( __FILE__, __LINE__, "PAPI_set_opt", retval );
retval = PAPI_add_named_event(EventSet1, event_name);
if ( retval != PAPI_OK )
test_fail_exit( __FILE__, __LINE__, "PAPI_add_named_event", retval );
// get space for counter values (this needs to do this call because it malloc's space that test_pass and friends free)
values = allocate_test_space( num_tests, num_events);
retval = PAPI_start( EventSet1 );
if ( retval != PAPI_OK )
test_fail_exit( __FILE__, __LINE__, "PAPI_start", retval );
// do some work
do_flops(NUM_FLOPS);
retval = PAPI_stop( EventSet1, values[0] );
if ( retval != PAPI_OK )
test_fail_exit( __FILE__, __LINE__, "PAPI_stop", retval );
printf ("Event: %s: %8lld on Cpu: %d\n", event_name, values[0][0], cpu_num);
PAPI_shutdown( );
test_pass( __FILE__, values, 1 );
return PAPI_OK;
}
static int
mpx_insert_events( MPX_EventSet *mpx_events, int *event_list,
int num_events, int domain, int granularity )
{
int i, retval = 0, num_events_success = 0;
MasterEvent *mev;
PAPI_option_t options;
MasterEvent **head = &mpx_events->mythr->head;
MPXDBG("Inserting %p %d\n",mpx_events,mpx_events->num_events );
/* Make sure we don't overrun our buffers */
if (mpx_events->num_events + num_events > PAPI_MAX_SW_MPX_EVENTS) {
return PAPI_ECOUNT;
}
/* For each event, see if there is already a corresponding
* event in the master set for this thread. If not, add it.
*/
for ( i = 0; i < num_events; i++ ) {
/* Look for a matching event in the master list */
for( mev = *head; mev != NULL; mev = mev->next ) {
if ( (mev->pi.event_type == event_list[i]) &&
(mev->pi.domain == domain) &&
(mev->pi.granularity == granularity ))
break;
}
/* No matching event in the list; add a new one */
if ( mev == NULL ) {
mev = (MasterEvent *) papi_malloc( sizeof ( MasterEvent ) );
if ( mev == NULL ) {
return PAPI_ENOMEM;
}
mev->pi.event_type = event_list[i];
mev->pi.domain = domain;
mev->pi.granularity = granularity;
mev->uses = mev->active = 0;
mev->prev_total_c = mev->count = mev->cycles = 0;
mev->rate_estimate = 0.0;
mev->count_estimate = 0;
mev->is_a_rate = 0;
mev->papi_event = PAPI_NULL;
retval = PAPI_create_eventset( &( mev->papi_event ) );
if ( retval != PAPI_OK ) {
MPXDBG( "Event %d could not be counted.\n",
event_list[i] );
goto bail;
}
retval = PAPI_add_event( mev->papi_event, event_list[i] );
if ( retval != PAPI_OK ) {
MPXDBG( "Event %d could not be counted.\n",
event_list[i] );
goto bail;
}
/* Always count total cycles so we can scale results.
* If user just requested cycles,
* don't add that event again. */
if ( event_list[i] != SCALE_EVENT ) {
retval = PAPI_add_event( mev->papi_event, SCALE_EVENT );
if ( retval != PAPI_OK ) {
MPXDBG( "Scale event could not be counted "
"at the same time.\n" );
goto bail;
}
}
/* Set the options for the event set */
memset( &options, 0x0, sizeof ( options ) );
options.domain.eventset = mev->papi_event;
options.domain.domain = domain;
retval = PAPI_set_opt( PAPI_DOMAIN, &options );
if ( retval != PAPI_OK ) {
MPXDBG( "PAPI_set_opt(PAPI_DOMAIN, ...) = %d\n",
retval );
goto bail;
}
memset( &options, 0x0, sizeof ( options ) );
options.granularity.eventset = mev->papi_event;
options.granularity.granularity = granularity;
retval = PAPI_set_opt( PAPI_GRANUL, &options );
if ( retval != PAPI_OK ) {
if ( retval != PAPI_ECMP ) {
/* ignore component errors because they typically mean
"not supported by the component" */
MPXDBG( "PAPI_set_opt(PAPI_GRANUL, ...) = %d\n",
retval );
goto bail;
}
}
/* Chain the event set into the
* master list of event sets used in
* multiplexing. */
mev->next = *head;
*head = mev;
}
/* If we created a new event set, or we found a matching
* eventset already in the list, then add the pointer in
* the master list to this threads list. Then we bump the
* number of successfully added events. */
MPXDBG("Inserting now %p %d\n",mpx_events,mpx_events->num_events );
mpx_events->mev[mpx_events->num_events + num_events_success] = mev;
mpx_events->mev[mpx_events->num_events + num_events_success]->uses++;
num_events_success++;
}
/* Always be sure the head master event points to the thread */
if ( *head != NULL ) {
( *head )->mythr = mpx_events->mythr;
}
MPXDBG( "%d of %d events were added.\n", num_events_success, num_events );
mpx_events->num_events += num_events_success;
return ( PAPI_OK );
bail:
/* If there is a current mev, it is currently not linked into the list
* of multiplexing events, so we can just delete that
*/
if ( mev && mev->papi_event ) {
if (PAPI_cleanup_eventset( mev->papi_event )!=PAPI_OK) {
PAPIERROR("Cleanup eventset\n");
}
if (PAPI_destroy_eventset( &( mev->papi_event )) !=PAPI_OK) {
PAPIERROR("Destory eventset\n");
}
}
if ( mev )
papi_free( mev );
mev = NULL;
/* Decrease the usage count of events */
for ( i = 0; i < num_events_success; i++ ) {
mpx_events->mev[mpx_events->num_events + i]->uses--;
}
/* Run the garbage collector to remove unused events */
if ( num_events_success )
mpx_remove_unused( head );
return ( retval );
}
int main (int argc, char *argv[])
{
int i, j;
//papi init code begin
long long s;
long long e;
int retval;
int eventcode;
PAPI_option_t opt;
if(PAPI_VER_CURRENT != PAPI_library_init(PAPI_VER_CURRENT)){
printf("Can't initiate PAPI library!\n");
exit(-1);
}
if (PAPI_thread_init(pthread_self) != PAPI_OK) {
printf("Can't thread init!\n");
exit(-1);
}
eventset = PAPI_NULL;
if(PAPI_create_eventset(&eventset) != PAPI_OK){
printf("Can't create eventset!\n");
exit(-3);
}
if ( ( retval = PAPI_assign_eventset_component( eventset, 0 ) ) != PAPI_OK ) {
printf("Can't assign_event_component!\n");
exit(-3);
}
memset( &opt, 0x0, sizeof ( PAPI_option_t ) );
opt.inherit.inherit = PAPI_INHERIT_ALL;
opt.inherit.eventset = eventset;
if ( ( retval = PAPI_set_opt( PAPI_INHERIT, &opt ) ) != PAPI_OK ) {
printf("Can't set inherit!\n");
exit(-3);
}
PAPI_event_name_to_code("MEM_LOAD_MISC_RETIRED:LLC_MISS",&eventcode);
events[1] = eventcode;
PAPI_event_name_to_code("CPU_CLK_UNHALTED:THREAD_P",&eventcode);
events[2] = eventcode;
for(i=0;i<3;i++) {
retval = PAPI_add_event(eventset, events[i]);
if(retval != PAPI_OK){
printf("error %d\n",retval);
exit(-4);
}
}
//papi init code end
/* create output file in gnuplot format */
gnuplotfile = fopen("test2_tcm.txt", "w");
fprintf(gnuplotfile,"#time(ms)\tMEM_LOAD_MISC_RETIRED:LLC_MISS\tCPU_CLK_UNHALTED:THREAD_P\n");
s = PAPI_get_real_usec();
PAPI_start(eventset);
test();
PAPI_stop(eventset, values);
e = PAPI_get_real_usec();
fclose(gnuplotfile);
/*Print out PAPI reading*/
printf("Wallclock time: %lld usec\n",e-s);
printf("Total Cycles\t%lld\n", values[0]);
printf("MEM_LOAD_MISC_RETIRED:LLC_MISS\t%lld\n", values[1]);
printf("CPU_CLK_UNHALTED:THREAD_P\t%lld\n", values[2]);
return 0;
}
int
main( int argc, char **argv )
{
int EventSet = PAPI_NULL;
long long hard_min, hard_max, soft_min, soft_max;
int retval;
int PAPI_event = 0, mythreshold;
char event_name[PAPI_MAX_STR_LEN];
PAPI_option_t opt;
PAPI_event_info_t info;
PAPI_option_t itimer;
const PAPI_hw_info_t *hw_info = NULL;
tests_quiet( argc, argv ); /* Set TESTS_QUIET variable */
retval = PAPI_library_init( PAPI_VER_CURRENT );
if ( retval != PAPI_VER_CURRENT )
test_fail( __FILE__, __LINE__, "PAPI_library_init", retval );
/* query and set up the right instruction to monitor */
if ( PAPI_query_event( PAPI_FP_INS ) == PAPI_OK ) {
if ( PAPI_query_event( PAPI_FP_INS ) == PAPI_OK ) {
PAPI_get_event_info( PAPI_FP_INS, &info );
if ( info.count == 1 ||
!strcmp( info.derived, "DERIVED_CMPD" ) )
PAPI_event = PAPI_FP_INS;
}
}
if ( PAPI_event == 0 ) {
if ( PAPI_query_event( PAPI_FP_OPS ) == PAPI_OK ) {
PAPI_get_event_info( PAPI_FP_OPS, &info );
if ( info.count == 1 ||
!strcmp( info.derived, "DERIVED_CMPD" ) )
PAPI_event = PAPI_FP_OPS;
}
}
if ( PAPI_event == 0 ) {
if ( PAPI_query_event( PAPI_TOT_INS ) == PAPI_OK ) {
PAPI_get_event_info( PAPI_TOT_INS, &info );
if ( info.count == 1 ||
!strcmp( info.derived, "DERIVED_CMPD" ) )
PAPI_event = PAPI_TOT_INS;
}
}
if ( PAPI_event == 0 )
test_skip( __FILE__, __LINE__, "No suitable event for this test found!",
0 );
hw_info = PAPI_get_hardware_info( );
if ( hw_info == NULL )
test_fail( __FILE__, __LINE__, "PAPI_get_hardware_info", 2 );
if ( PAPI_event == PAPI_FP_INS )
mythreshold = THRESHOLD;
else
#if defined(linux)
mythreshold = ( int ) hw_info->cpu_max_mhz * 20000;
#else
mythreshold = THRESHOLD * 2;
#endif
retval = PAPI_create_eventset( &EventSet );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_create_eventset", retval );
retval = PAPI_add_event( EventSet, PAPI_event );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_add_event", retval );
retval = PAPI_get_opt( PAPI_COMPONENTINFO, &opt );
if ( retval != PAPI_OK )
test_skip( __FILE__, __LINE__,
"Platform does not support Hardware overflow", 0 );
do_stuff( );
/* Do reference count */
retval = PAPI_start( EventSet );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
do_stuff( );
retval = PAPI_stop( EventSet, &values[use_total] );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
use_total++;
/* Now do hardware overflow reference count */
retval = PAPI_overflow( EventSet, PAPI_event, mythreshold, 0, handler );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );
retval = PAPI_start( EventSet );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
do_stuff( );
retval = PAPI_stop( EventSet, &values[use_total] );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
use_total++;
retval = PAPI_overflow( EventSet, PAPI_event, 0, 0, handler );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );
/* Now do software overflow reference count, uses SIGPROF */
retval =
PAPI_overflow( EventSet, PAPI_event, mythreshold,
PAPI_OVERFLOW_FORCE_SW, handler );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );
retval = PAPI_start( EventSet );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
do_stuff( );
retval = PAPI_stop( EventSet, &values[use_total] );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
use_total++;
retval =
PAPI_overflow( EventSet, PAPI_event, 0, PAPI_OVERFLOW_FORCE_SW,
handler );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );
/* Now do software overflow with SIGVTALRM */
memset( &itimer, 0, sizeof ( itimer ) );
itimer.itimer.itimer_num = ITIMER_VIRTUAL;
itimer.itimer.itimer_sig = SIGVTALRM;
if ( PAPI_set_opt( PAPI_DEF_ITIMER, &itimer ) != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_set_opt", retval );
retval =
PAPI_overflow( EventSet, PAPI_event, mythreshold,
PAPI_OVERFLOW_FORCE_SW, handler );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );
retval = PAPI_start( EventSet );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
do_stuff( );
retval = PAPI_stop( EventSet, &values[use_total] );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
use_total++;
retval =
PAPI_overflow( EventSet, PAPI_event, 0, PAPI_OVERFLOW_FORCE_SW,
handler );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );
/* Now do software overflow with SIGALRM */
memset( &itimer, 0, sizeof ( itimer ) );
itimer.itimer.itimer_num = ITIMER_REAL;
itimer.itimer.itimer_sig = SIGALRM;
if ( PAPI_set_opt( PAPI_DEF_ITIMER, &itimer ) != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_set_opt", retval );
retval =
PAPI_overflow( EventSet, PAPI_event, mythreshold,
PAPI_OVERFLOW_FORCE_SW, handler );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );
retval = PAPI_start( EventSet );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
do_stuff( );
retval = PAPI_stop( EventSet, &values[use_total] );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
use_total++;
retval =
PAPI_overflow( EventSet, PAPI_event, 0, PAPI_OVERFLOW_FORCE_SW,
handler );
if ( retval != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );
if ( !TESTS_QUIET ) {
if ( ( retval =
PAPI_event_code_to_name( PAPI_event, event_name ) ) != PAPI_OK )
test_fail( __FILE__, __LINE__, "PAPI_event_code_to_name", retval );
printf
( "Test case: Software overflow of various types with 1 event in set.\n" );
printf
( "------------------------------------------------------------------------------\n" );
printf( "Threshold for overflow is: %d\n", mythreshold );
printf
( "------------------------------------------------------------------------------\n" );
printf( "Test type : %11s%13s%13s%13s%13s\n", "Reference", "Hardware",
"ITIMER_PROF", "ITIMER_VIRT", "ITIMER_REAL" );
printf( "%-12s: %11lld%13lld%13lld%13lld%13lld\n", info.symbol,
values[0], values[1], values[2], values[3], values[4] );
printf( "Overflows : %11d%13d%13d%13d%13d\n", total[0], total[1],
total[2], total[3], total[4] );
printf
( "------------------------------------------------------------------------------\n" );
printf( "Verification:\n" );
printf
( "Overflow in Column 2 greater than or equal to overflows in Columns 3, 4, 5\n" );
printf( "Overflow in Columns 3, 4, 5 greater than 0\n" );
}
hard_min =
( long long ) ( ( ( double ) values[0] * ( 1.0 - OVR_TOLERANCE ) ) /
( double ) mythreshold );
hard_max =
( long long ) ( ( ( double ) values[0] * ( 1.0 + OVR_TOLERANCE ) ) /
( double ) mythreshold );
soft_min =
( long long ) ( ( ( double ) values[0] * ( 1.0 - SOFT_TOLERANCE ) ) /
( double ) mythreshold );
soft_max =
( long long ) ( ( ( double ) values[0] * ( 1.0 + SOFT_TOLERANCE ) ) /
( double ) mythreshold );
if ( total[1] > hard_max || total[1] < hard_min )
test_fail( __FILE__, __LINE__, "Hardware Overflows outside limits", 1 );
if ( total[2] > soft_max || total[3] > soft_max || total[4] > soft_max )
test_fail( __FILE__, __LINE__,
"Software Overflows exceed theoretical maximum", 1 );
if ( total[2] < soft_min || total[3] < soft_min || total[4] < soft_min )
printf( "WARNING: Software Overflow occuring but suspiciously low\n" );
if ( ( total[2] == 0 ) || ( total[3] == 0 ) || ( total[4] == 0 ) )
test_fail( __FILE__, __LINE__, "Software Overflows", 1 );
test_pass( __FILE__, NULL, 0 );
exit( 1 );
}
int main( int argc, char **argv ) {
int retval;
int EventSet1 = PAPI_NULL;
int EventSet2 = PAPI_NULL;
int EventSet3 = PAPI_NULL;
int EventSet4 = PAPI_NULL;
int EventSet5 = PAPI_NULL;
int EventSet6 = PAPI_NULL;
int EventSet7 = PAPI_NULL;
int EventSet8 = PAPI_NULL;
int EventSet9 = PAPI_NULL;
int EventSet10 = PAPI_NULL;
PAPI_domain_option_t domain_opt;
PAPI_granularity_option_t gran_opt;
PAPI_cpu_option_t cpu_opt;
cpu_set_t mask;
long long dom_user_values[1],dom_userkernel_values[1],dom_all_values[1];
long long grn_thr_values[1],grn_proc_values[1];
long long grn_sys_values[1],grn_sys_cpu_values[1];
long long total_values[1],total_affinity_values[1];
long long total_all_values[1];
dom_user_values[0]=0;
dom_userkernel_values[0]=0;
dom_all_values[0]=0;
grn_thr_values[0]=0;
grn_proc_values[0]=0;
grn_sys_values[0]=0;
grn_sys_cpu_values[0]=0;
total_values[0]=0;
total_affinity_values[0]=0;
total_all_values[0]=0;
/* Set TESTS_QUIET variable */
tests_quiet( argc, argv );
/* Init the PAPI library */
retval = PAPI_library_init( PAPI_VER_CURRENT );
if ( retval != PAPI_VER_CURRENT ) {
test_fail( __FILE__, __LINE__, "PAPI_library_init", retval );
}
/***************************/
/***************************/
/* Default, user events */
/***************************/
/***************************/
if (!TESTS_QUIET) {
printf("\nTrying PAPI_TOT_CYC with different domains:\n");
}
if (!TESTS_QUIET) {
printf("\tPAPI_DOM_USER:\t\t\t");
}
retval = PAPI_create_eventset(&EventSet1);
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_create_eventset",retval);
}
retval = PAPI_add_named_event(EventSet1, "PAPI_TOT_CYC");
if (retval != PAPI_OK) {
if ( !TESTS_QUIET ) {
fprintf(stderr,"Error trying to add PAPI_TOT_CYC\n");
}
test_fail(__FILE__, __LINE__, "adding PAPI_TOT_CYC ",retval);
}
retval = PAPI_start( EventSet1 );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
}
do_flops( NUM_FLOPS );
retval = PAPI_stop( EventSet1, dom_user_values );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
}
if ( !TESTS_QUIET ) {
printf("%lld\n",dom_user_values[0]);
}
/***************************/
/***************************/
/* User+Kernel events */
/***************************/
/***************************/
if (!TESTS_QUIET) {
printf("\tPAPI_DOM_USER|PAPI_DOM_KERNEL:\t");
}
retval = PAPI_create_eventset(&EventSet2);
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_create_eventset",retval);
}
retval = PAPI_assign_eventset_component(EventSet2, 0);
/* we need to set domain to be as inclusive as possible */
domain_opt.def_cidx=0;
domain_opt.eventset=EventSet2;
domain_opt.domain=PAPI_DOM_USER|PAPI_DOM_KERNEL;
retval = PAPI_set_opt(PAPI_DOMAIN,(PAPI_option_t*)&domain_opt);
if (retval != PAPI_OK) {
if (retval==PAPI_EPERM) {
test_skip( __FILE__, __LINE__,
"this test; trying to set PAPI_DOM_ALL; need to run as root",
retval);
}
else {
test_fail(__FILE__, __LINE__, "setting PAPI_DOM_ALL",retval);
}
}
retval = PAPI_add_named_event(EventSet2, "PAPI_TOT_CYC");
if (retval != PAPI_OK) {
if ( !TESTS_QUIET ) {
fprintf(stderr,"Error trying to add PAPI_TOT_CYC\n");
}
test_fail(__FILE__, __LINE__, "adding PAPI_TOT_CYC ",retval);
}
retval = PAPI_start( EventSet2 );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
}
do_flops( NUM_FLOPS );
retval = PAPI_stop( EventSet2, dom_userkernel_values );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
}
if ( !TESTS_QUIET ) {
printf("%lld\n",dom_userkernel_values[0]);
}
/***************************/
/***************************/
/* DOMAIN_ALL events */
/***************************/
/***************************/
if (!TESTS_QUIET) {
printf("\tPAPI_DOM_ALL:\t\t\t");
}
retval = PAPI_create_eventset(&EventSet3);
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_create_eventset",retval);
}
retval = PAPI_assign_eventset_component(EventSet3, 0);
/* we need to set domain to be as inclusive as possible */
domain_opt.def_cidx=0;
domain_opt.eventset=EventSet3;
domain_opt.domain=PAPI_DOM_ALL;
retval = PAPI_set_opt(PAPI_DOMAIN,(PAPI_option_t*)&domain_opt);
if (retval != PAPI_OK) {
if (retval==PAPI_EPERM) {
test_skip( __FILE__, __LINE__,
"this test; trying to set PAPI_DOM_ALL; need to run as root",
retval);
}
else {
test_fail(__FILE__, __LINE__, "setting PAPI_DOM_ALL",retval);
}
}
retval = PAPI_add_named_event(EventSet3, "PAPI_TOT_CYC");
if (retval != PAPI_OK) {
if ( !TESTS_QUIET ) {
fprintf(stderr,"Error trying to add PAPI_TOT_CYC\n");
}
test_fail(__FILE__, __LINE__, "adding PAPI_TOT_CYC ",retval);
}
retval = PAPI_start( EventSet3 );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
}
do_flops( NUM_FLOPS );
retval = PAPI_stop( EventSet3, dom_all_values );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
}
if ( !TESTS_QUIET ) {
printf("%lld\n",dom_all_values[0]);
}
/***************************/
/***************************/
/* PAPI_GRN_THR events */
/***************************/
/***************************/
if ( !TESTS_QUIET ) {
printf("\nTrying different granularities:\n");
}
if ( !TESTS_QUIET ) {
printf("\tPAPI_GRN_THR:\t\t\t");
}
retval = PAPI_create_eventset(&EventSet4);
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_create_eventset",retval);
}
retval = PAPI_assign_eventset_component(EventSet4, 0);
/* Set the granularity to system-wide */
gran_opt.def_cidx=0;
gran_opt.eventset=EventSet4;
gran_opt.granularity=PAPI_GRN_THR;
retval = PAPI_set_opt(PAPI_GRANUL,(PAPI_option_t*)&gran_opt);
if (retval != PAPI_OK) {
test_skip( __FILE__, __LINE__,
"this test; trying to set PAPI_GRN_THR",
retval);
}
retval = PAPI_add_named_event(EventSet4, "PAPI_TOT_CYC");
if (retval != PAPI_OK) {
if ( !TESTS_QUIET ) {
fprintf(stderr,"Error trying to add PAPI_TOT_CYC\n");
}
test_fail(__FILE__, __LINE__, "adding PAPI_TOT_CYC ",retval);
}
retval = PAPI_start( EventSet4 );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
}
do_flops( NUM_FLOPS );
retval = PAPI_stop( EventSet4, grn_thr_values );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
}
if ( !TESTS_QUIET ) {
printf("%lld\n",grn_thr_values[0]);
}
/***************************/
/***************************/
/* PAPI_GRN_PROC events */
/***************************/
/***************************/
if ( !TESTS_QUIET ) {
printf("\tPAPI_GRN_PROC:\t\t\t");
}
retval = PAPI_create_eventset(&EventSet5);
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_create_eventset",retval);
}
retval = PAPI_assign_eventset_component(EventSet5, 0);
/* Set the granularity to system-wide */
gran_opt.def_cidx=0;
gran_opt.eventset=EventSet5;
gran_opt.granularity=PAPI_GRN_PROC;
retval = PAPI_set_opt(PAPI_GRANUL,(PAPI_option_t*)&gran_opt);
if (retval != PAPI_OK) {
if (!TESTS_QUIET) {
printf("Unable to set PAPI_GRN_PROC\n");
}
}
else {
retval = PAPI_add_named_event(EventSet5, "PAPI_TOT_CYC");
if (retval != PAPI_OK) {
if ( !TESTS_QUIET ) {
printf("Error trying to add PAPI_TOT_CYC\n");
}
test_fail(__FILE__, __LINE__, "adding PAPI_TOT_CYC ",retval);
}
retval = PAPI_start( EventSet5 );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
}
do_flops( NUM_FLOPS );
retval = PAPI_stop( EventSet5, grn_proc_values );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
}
if ( !TESTS_QUIET ) {
printf("%lld\n",grn_proc_values[0]);
}
}
/***************************/
/***************************/
/* PAPI_GRN_SYS events */
/***************************/
/***************************/
if ( !TESTS_QUIET ) {
printf("\tPAPI_GRN_SYS:\t\t\t");
}
retval = PAPI_create_eventset(&EventSet6);
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_create_eventset",retval);
}
retval = PAPI_assign_eventset_component(EventSet6, 0);
/* Set the granularity to system-wide */
gran_opt.def_cidx=0;
gran_opt.eventset=EventSet6;
gran_opt.granularity=PAPI_GRN_SYS;
retval = PAPI_set_opt(PAPI_GRANUL,(PAPI_option_t*)&gran_opt);
if (retval != PAPI_OK) {
if (!TESTS_QUIET) {
printf("Unable to set PAPI_GRN_SYS\n");
}
}
else {
retval = PAPI_add_named_event(EventSet6, "PAPI_TOT_CYC");
if (retval != PAPI_OK) {
if ( !TESTS_QUIET ) {
printf("Error trying to add PAPI_TOT_CYC\n");
}
} else {
retval = PAPI_start( EventSet6 );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
}
do_flops( NUM_FLOPS );
retval = PAPI_stop( EventSet6, grn_sys_values );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
}
if ( !TESTS_QUIET ) {
printf("GRN_SYS PAPI_TOT_CYC: %lld\n",grn_sys_values[0]);
}
}
}
/****************************/
/****************************/
/* PAPI_GRN_SYS_CPU events */
/****************************/
/****************************/
if ( !TESTS_QUIET ) {
printf("\tPAPI_GRN_SYS_CPU:\t\t");
}
retval = PAPI_create_eventset(&EventSet7);
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_create_eventset",retval);
}
retval = PAPI_assign_eventset_component(EventSet7, 0);
/* Set the granularity to system-wide */
gran_opt.def_cidx=0;
gran_opt.eventset=EventSet7;
gran_opt.granularity=PAPI_GRN_SYS_CPU;
retval = PAPI_set_opt(PAPI_GRANUL,(PAPI_option_t*)&gran_opt);
if (retval != PAPI_OK) {
if (!TESTS_QUIET) {
printf("Unable to set PAPI_GRN_SYS_CPU\n");
}
}
else {
retval = PAPI_add_named_event(EventSet7, "PAPI_TOT_CYC");
if (retval != PAPI_OK) {
if ( !TESTS_QUIET ) {
printf("Error trying to add PAPI_TOT_CYC\n");
}
test_fail(__FILE__, __LINE__, "adding PAPI_TOT_CYC ",retval);
}
retval = PAPI_start( EventSet7 );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
}
do_flops( NUM_FLOPS );
retval = PAPI_stop( EventSet7, grn_sys_cpu_values );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
}
if ( !TESTS_QUIET ) {
printf("%lld\n",grn_sys_cpu_values[0]);
}
}
/***************************/
/***************************/
/* SYS and ATTACH events */
/***************************/
/***************************/
if ( !TESTS_QUIET ) {
printf("\nPAPI_GRN_SYS plus CPU attach:\n");
}
if ( !TESTS_QUIET ) {
printf("\tGRN_SYS, DOM_USER, CPU 0 attach:\t");
}
retval = PAPI_create_eventset(&EventSet8);
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_create_eventset",retval);
}
retval = PAPI_assign_eventset_component(EventSet8, 0);
/* Set the granularity to system-wide */
gran_opt.def_cidx=0;
gran_opt.eventset=EventSet8;
gran_opt.granularity=PAPI_GRN_SYS;
retval = PAPI_set_opt(PAPI_GRANUL,(PAPI_option_t*)&gran_opt);
if (retval != PAPI_OK) {
if (!TESTS_QUIET) {
printf("Unable to set PAPI_GRN_SYS\n");
}
}
else {
/* we need to set to a certain cpu */
cpu_opt.eventset=EventSet8;
cpu_opt.cpu_num=0;
retval = PAPI_set_opt(PAPI_CPU_ATTACH,(PAPI_option_t*)&cpu_opt);
if (retval != PAPI_OK) {
if (retval==PAPI_EPERM) {
test_skip( __FILE__, __LINE__,
"this test; trying to CPU_ATTACH; need to run as root",
retval);
}
test_fail(__FILE__, __LINE__, "PAPI_CPU_ATTACH",retval);
}
retval = PAPI_add_named_event(EventSet8, "PAPI_TOT_CYC");
if (retval != PAPI_OK) {
if ( !TESTS_QUIET ) {
printf("Error trying to add PAPI_TOT_CYC\n");
}
test_fail(__FILE__, __LINE__, "adding PAPI_TOT_CYC ",retval);
}
retval = PAPI_start( EventSet8 );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
}
do_flops( NUM_FLOPS );
retval = PAPI_stop( EventSet8, total_values );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
}
if ( !TESTS_QUIET ) {
printf("%lld\n",total_values[0]);
}
}
/***************************/
/***************************/
/* SYS and ATTACH, bind CPU events */
/***************************/
/***************************/
if ( !TESTS_QUIET ) {
printf("\tGRN_SYS, DOM_USER, CPU 0 affinity:\t");
}
/* Set affinity to CPU 0 */
CPU_ZERO(&mask);
CPU_SET(0,&mask);
retval=sched_setaffinity(0, sizeof(mask), &mask);
if (retval<0) {
if (!TESTS_QUIET) {
printf("Setting affinity failed: %s\n",strerror(errno));
}
} else {
retval = PAPI_create_eventset(&EventSet9);
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_create_eventset",retval);
}
retval = PAPI_assign_eventset_component(EventSet9, 0);
/* Set the granularity to system-wide */
gran_opt.def_cidx=0;
gran_opt.eventset=EventSet9;
gran_opt.granularity=PAPI_GRN_SYS;
retval = PAPI_set_opt(PAPI_GRANUL,(PAPI_option_t*)&gran_opt);
if (retval != PAPI_OK) {
if (!TESTS_QUIET) {
printf("Unable to set PAPI_GRN_SYS\n");
}
}
else {
/* we need to set to a certain cpu for uncore to work */
cpu_opt.eventset=EventSet9;
cpu_opt.cpu_num=0;
retval = PAPI_set_opt(PAPI_CPU_ATTACH,(PAPI_option_t*)&cpu_opt);
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_CPU_ATTACH",retval);
}
retval = PAPI_add_named_event(EventSet9, "PAPI_TOT_CYC");
if (retval != PAPI_OK) {
if ( !TESTS_QUIET ) {
printf("Error trying to add PAPI_TOT_CYC\n");
}
test_fail(__FILE__, __LINE__, "adding PAPI_TOT_CYC ",retval);
}
retval = PAPI_start( EventSet9 );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
}
do_flops( NUM_FLOPS );
retval = PAPI_stop( EventSet9, total_affinity_values );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
}
if ( !TESTS_QUIET ) {
printf("%lld\n",total_affinity_values[0]);
}
}
}
/***************************/
/***************************/
/* SYS and ATTACH, bind CPU events */
/***************************/
/***************************/
if ( !TESTS_QUIET ) {
printf("\tGRN_SYS, DOM_ALL, CPU 0 affinity:\t");
}
/* Set affinity to CPU 0 */
CPU_ZERO(&mask);
CPU_SET(0,&mask);
retval=sched_setaffinity(0, sizeof(mask), &mask);
if (retval<0) {
if (!TESTS_QUIET) {
printf("Setting affinity failed: %s\n",strerror(errno));
}
} else {
retval = PAPI_create_eventset(&EventSet10);
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_create_eventset",retval);
}
retval = PAPI_assign_eventset_component(EventSet10, 0);
/* Set DOM_ALL */
domain_opt.def_cidx=0;
domain_opt.eventset=EventSet10;
domain_opt.domain=PAPI_DOM_ALL;
retval = PAPI_set_opt(PAPI_DOMAIN,(PAPI_option_t*)&domain_opt);
if (retval != PAPI_OK) {
if (retval==PAPI_EPERM) {
test_skip( __FILE__, __LINE__,
"this test; trying to set PAPI_DOM_ALL; need to run as root",
retval);
}
else {
test_fail(__FILE__, __LINE__, "setting PAPI_DOM_ALL",retval);
}
}
/* Set the granularity to system-wide */
gran_opt.def_cidx=0;
gran_opt.eventset=EventSet10;
gran_opt.granularity=PAPI_GRN_SYS;
retval = PAPI_set_opt(PAPI_GRANUL,(PAPI_option_t*)&gran_opt);
if (retval != PAPI_OK) {
if (!TESTS_QUIET) {
printf("Unable to set PAPI_GRN_SYS\n");
}
}
else {
/* we need to set to a certain cpu for uncore to work */
cpu_opt.eventset=EventSet10;
cpu_opt.cpu_num=0;
retval = PAPI_set_opt(PAPI_CPU_ATTACH,(PAPI_option_t*)&cpu_opt);
if (retval != PAPI_OK) {
test_fail(__FILE__, __LINE__, "PAPI_CPU_ATTACH",retval);
}
retval = PAPI_add_named_event(EventSet10, "PAPI_TOT_CYC");
if (retval != PAPI_OK) {
if ( !TESTS_QUIET ) {
printf("Error trying to add PAPI_TOT_CYC\n");
}
test_fail(__FILE__, __LINE__, "adding PAPI_TOT_CYC ",retval);
}
retval = PAPI_start( EventSet10 );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_start", retval );
}
do_flops( NUM_FLOPS );
retval = PAPI_stop( EventSet10, total_all_values );
if ( retval != PAPI_OK ) {
test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
}
if ( !TESTS_QUIET ) {
printf("%lld\n",total_all_values[0]);
}
}
}
/**************/
/* Validation */
/**************/
if ( !TESTS_QUIET ) {
printf("\n");
}
if ( !TESTS_QUIET ) {
printf("Validating:\n");
printf("\tDOM_USER|DOM_KERNEL (%lld) > DOM_USER (%lld)\n",
dom_userkernel_values[0],dom_user_values[0]);
}
if (dom_user_values[0] > dom_userkernel_values[0]) {
test_fail( __FILE__, __LINE__, "DOM_USER too high", 0 );
}
if ( !TESTS_QUIET ) {
printf("\n");
}
test_pass( __FILE__, NULL, 0 );
return 0;
}
