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