papi_libpfm4_events.c

Go to the documentation of this file.

/*
* File:    papi_libpfm4_events.c
* Author:  Vince Weaver vweaver1 @ eecs.utk.edu
*          based heavily on existing papi_libpfm3_events.c
*/

#include <string.h>

#include "papi.h"
#include "papi_internal.h"
#include "papi_vector.h"

#include "papi_libpfm4_events.h"

#include "perfmon/pfmlib.h"
#include "perfmon/pfmlib_perf_event.h"

#define NATIVE_EVENT_CHUNK 1024

struct native_event_t {
  int component;
  char *pmu;
  int libpfm4_idx;
  char *allocated_name;
  char *base_name;
  char *pmu_plus_name;
  int users;
  long long config;
  long long config1;
  long long config2;
  int type;
};

static struct native_event_t *native_events;

static int num_native_events=0;
static int allocated_native_events=0;

static pfm_pmu_info_t default_pmu;


static int find_existing_event(char *name) {

  int i,event=PAPI_ENOEVNT;

  SUBDBG("Looking for %s in %d events\n",name,num_native_events);

  _papi_hwi_lock( NAMELIB_LOCK );

  for(i=0;i<num_native_events;i++) {

    if (!strcmp(name,native_events[i].allocated_name)) {
      SUBDBG("Found %s (%x)\n",
         native_events[i].allocated_name,
         native_events[i].libpfm4_idx);
      event=i;
      break;
    }
  }
  _papi_hwi_unlock( NAMELIB_LOCK );

  if (event<0) { SUBDBG("%s not allocated yet\n",name); }

  return event;
}

static struct native_event_t *find_existing_event_by_number(int eventnum) {

  struct native_event_t *temp_event=NULL;

  _papi_hwi_lock( NAMELIB_LOCK );

  temp_event=&native_events[eventnum];
  
  _papi_hwi_unlock( NAMELIB_LOCK );

  SUBDBG("Found %p for %x\n",temp_event,eventnum);

  return temp_event;
}


static int find_event_no_aliases(char *name) {

    int j,i, ret;
    pfm_pmu_info_t pinfo;
    pfm_event_info_t event_info;
    char full_name[BUFSIZ];

    SUBDBG("Looking for %s\n",name);

    pfm_for_all_pmus(j) {

       memset(&pinfo,0,sizeof(pfm_pmu_info_t));
       pfm_get_pmu_info(j, &pinfo);
       if (!pinfo.is_present) {
          continue;
       }

       SUBDBG("Looking in pmu %d\n",j);   
       i = pinfo.first_event; 
       while(1) {
          memset(&event_info,0,sizeof(pfm_event_info_t));
          ret=pfm_get_event_info(i, PFM_OS_PERF_EVENT, &event_info);
      if (ret<0) break;
    
      sprintf(full_name,"%s::%s",pinfo.name,event_info.name);

      if (!strcmp(name,full_name)) {
         SUBDBG("FOUND %s %s %x\n",name,full_name,i);
         return i;
      }

      if (!strcmp(name,event_info.name)) {
         SUBDBG("FOUND %s %s %x\n",name,event_info.name,i);
         return i;
      }
      i=pfm_get_event_next(i);
       }
    }
    return PFM_ERR_NOTFOUND;
}

static int find_next_no_aliases(int code) {

  int current_pmu=0,current_event=0;
  pfm_err_t ret;
  pfm_pmu_info_t pinfo;
  pfm_event_info_t event_info;

  /* Clear the structures, as libpfm4 requires it */
  memset(&event_info,0,sizeof(pfm_event_info_t));

  ret=pfm_get_event_info(code, PFM_OS_PERF_EVENT, &event_info);
  if (ret!=PFM_SUCCESS) {
     return ret;
  }

  current_pmu=event_info.pmu;
  current_event=pfm_get_event_next(code);

  SUBDBG("Current is %x guessing next is %x\n",code,current_event);

  while(1) {

     memset(&event_info,0,sizeof(pfm_event_info_t));
     ret=pfm_get_event_info(current_event, PFM_OS_PERF_EVENT, &event_info);
     if (ret==PFM_SUCCESS) {
        SUBDBG("Returning %x\n",current_event);
        return current_event;
     }

     /* next event not found, so try moving to next PMU */

     while(1) {

        current_pmu++;
        SUBDBG("Incrementing PMU: %x\n",current_pmu);

    /* Off the end, so done iterating */
        if (current_pmu>PFM_PMU_MAX) {
           return PFM_ERR_NOTFOUND;
        }
 
        memset(&pinfo,0,sizeof(pfm_pmu_info_t));
        pfm_get_pmu_info(current_pmu, &pinfo);
        if (pinfo.is_present) break;
     }

     current_event=pinfo.first_event;

  }

}

static struct native_event_t *allocate_native_event(char *name, 
                            int event_idx) {

  int new_event;

  pfm_err_t ret;
  unsigned int i;
  char *base_start;
  pfm_event_info_t info;
  pfm_pmu_info_t pinfo;
  char base[BUFSIZ],pmuplusbase[BUFSIZ];
  char fullname[BUFSIZ];

  pfm_perf_encode_arg_t perf_arg;

  struct perf_event_attr perf_attr;

  /* get the event name from libpfm */
  memset(&info,0,sizeof(pfm_event_info_t));
  ret = pfm_get_event_info(event_idx, PFM_OS_PERF_EVENT, &info);
  if (ret!=PFM_SUCCESS) {
     return NULL;
  }

  /* get the PMU info */
  memset(&pinfo,0,sizeof(pfm_pmu_info_t));
  pfm_get_pmu_info(info.pmu, &pinfo);

  /* calculate the base name, meaning strip off pmu identifier */
  strncpy(base,name,BUFSIZ);
  i=0;
  base_start=base;
  while(i<strlen(base)) {
    if (base[i]==':') {
      if (base[i+1]==':') {
          i++;
      base_start=&base[i+1];
      }
      else {
    base[i]=0;
      }
    }
    i++;
  }

  /* add the event */
  _papi_hwi_lock( NAMELIB_LOCK );

  new_event=num_native_events;

  native_events[new_event].base_name=strdup(base_start);

  sprintf(fullname,"%s::%s",pinfo.name,info.name);
  native_events[new_event].pmu_plus_name=strdup(fullname);

  sprintf(pmuplusbase,"%s::%s",pinfo.name,base_start);

  native_events[new_event].component=0;
  native_events[new_event].pmu=strdup(pinfo.name);
    
  native_events[new_event].libpfm4_idx=find_event_no_aliases(pmuplusbase);

  SUBDBG("Using %x as index instead of %x for %s\n",
     native_events[new_event].libpfm4_idx,event_idx,pmuplusbase);

  native_events[new_event].allocated_name=strdup(name);

  /* is this needed? */
  native_events[new_event].users=0;


  /* use name of the event to get the perf_event encoding */

  /* clear the attribute structure */
  memset(&perf_arg,0,sizeof(pfm_perf_encode_arg_t));

  /* clear out the perf_attr struct */
  memset(&perf_attr,0,sizeof(struct perf_event_attr));
  perf_arg.attr=&perf_attr;

  ret = pfm_get_os_event_encoding(name, 
                  PFM_PLM0 | PFM_PLM3, 
                                  PFM_OS_PERF_EVENT, 
                  &perf_arg);
  if (ret!=PFM_SUCCESS) {
     /* should do something! */
  }
  
  native_events[new_event].config=perf_arg.attr->config;
  native_events[new_event].config1=perf_arg.attr->config1;
  native_events[new_event].type=perf_arg.attr->type;

  SUBDBG( "pe_event: config 0x%"PRIx64" config1 0x%"PRIx64" type 0x%"PRIx32"\n", 
          perf_arg.attr->config, 
      perf_arg.attr->config1,
      perf_arg.attr->type);

  SUBDBG("Creating event %s with perfidx %x\n",
     name,
     native_events[new_event].libpfm4_idx);

  num_native_events++;

  /* If we've allocated too many native events, then allocate more room */
  if (num_native_events >= allocated_native_events) {

     SUBDBG("Allocating more room for native events (%d %ld)\n",
        (allocated_native_events+NATIVE_EVENT_CHUNK),
        (long)sizeof(struct native_event_t) *
        (allocated_native_events+NATIVE_EVENT_CHUNK));

     native_events=realloc(native_events,
               sizeof(struct native_event_t) * 
               (allocated_native_events+NATIVE_EVENT_CHUNK));
     allocated_native_events+=NATIVE_EVENT_CHUNK;
  }

  _papi_hwi_unlock( NAMELIB_LOCK );

  if (native_events==NULL) {
     return NULL;
  }

  return &native_events[new_event];

}

static int find_max_umask(struct native_event_t *current_event) {

  pfm_event_attr_info_t ainfo;
  char *b;
  int a, ret, max =0;
  pfm_event_info_t info;
  char event_string[BUFSIZ],*ptr;
  char temp_string[BUFSIZ];

  SUBDBG("Trying to find max umask in %s\n",current_event->allocated_name);

  strcpy(event_string,current_event->allocated_name);

  /* Skip leading :: delimited PMU name and point to first umask */
  if (strstr(event_string,"::")) {
     ptr=strstr(event_string,"::");
     ptr+=2;
     b=strtok(ptr,":");
  }
  else {
     b=strtok(event_string,":");
  }

  if (!b) {
     SUBDBG("No colon!\n");
     return PFM_ERR_UMASK; /* Must be this value!! */
  }

  memset(&info,0,sizeof(pfm_event_info_t));
  ret = pfm_get_event_info(current_event->libpfm4_idx, 
               PFM_OS_PERF_EVENT, &info);
  if (ret!=PFM_SUCCESS) {
     SUBDBG("get_event_info failed\n");
     return PFM_ERR_NOTFOUND;
  }

  /* skip first */
  b=strtok(NULL,":");
  if (!b) {
     SUBDBG("Skipping first failed\n");
     return PFM_ERR_UMASK; /* Must be this value!! */
  }

  while(b) {
    a=0;
    while(1) {

      SUBDBG("get_event_attr %x %d %p\n",current_event->libpfm4_idx,a,&ainfo);

      memset(&ainfo,0,sizeof(pfm_event_attr_info_t));

      ret = pfm_get_event_attr_info(current_event->libpfm4_idx, a, 
                    PFM_OS_PERF_EVENT, &ainfo);

      if (ret != PFM_SUCCESS) {
    SUBDBG("get_event_attr failed %s\n",pfm_strerror(ret));
    return ret;
      }

      SUBDBG("Trying %s with %s\n",ainfo.name,b);

      if (ainfo.type == PFM_ATTR_MOD_BOOL) {
     sprintf(temp_string,"%s=0",ainfo.name);
         if (!strcasecmp(temp_string, b)) {
        SUBDBG("Found %s %d\n",b,a);
        if (a>max) max=a;
        goto found_attr;
     }
      }
      else if (ainfo.type == PFM_ATTR_MOD_INTEGER) {
     sprintf(temp_string,"%s=0",ainfo.name);
         if (!strcasecmp(temp_string, b)) {
        SUBDBG("Found %s %d\n",b,a);
        if (a>max) max=a;
        goto found_attr;
     }
      }
      else {
         if (!strcasecmp(ainfo.name, b)) {
        SUBDBG("Found %s %d\n",b,a);
        if (a>max) max=a;
        goto found_attr;
     }
      }
      a++;
    }

    SUBDBG("attr=%s not found for event %s\n", b, info.name);

    return PFM_ERR_ATTR;

found_attr:

    b=strtok(NULL,":");
  }

  SUBDBG("Found max %d\n", max);

  return max;
}



static int
get_event_first_active(void)
{
  int pidx, pmu_idx, ret;

  pfm_pmu_info_t pinfo;

  pmu_idx=0;

  while(pmu_idx<PFM_PMU_MAX) {

    /* clear the PMU structure (required by libpfm4) */
    memset(&pinfo,0,sizeof(pfm_pmu_info_t));
    ret=pfm_get_pmu_info(pmu_idx, &pinfo);

    if ((ret==PFM_SUCCESS) && pinfo.is_present) {

      pidx=pinfo.first_event;

      SUBDBG("First event in %s is %d\n",pinfo.name,pidx);

      if (pidx<0) {
    /* For some reason no events available */
    /* despite the PMU being active.       */
        /* This can happen, for example with ix86arch */
    /* inside of VMware                           */
      }
      else {
         return pidx;
      }
    }

    pmu_idx++;

  }

  return PAPI_ENOEVNT;
  
}



static int
convert_libpfm4_to_string( int code, char **event_name)
{

  int ret;
  pfm_event_info_t gete;
  pfm_pmu_info_t pinfo;
  char name[BUFSIZ];

  SUBDBG("ENTER %x\n",code);

  /* Clear structures, as wanted by libpfm4 */
  memset( &gete, 0, sizeof (pfm_event_info_t) );

  ret=pfm_get_event_info(code, PFM_OS_PERF_EVENT, &gete);
  if (ret!=PFM_SUCCESS) {
     return ret;
  }

  memset( &pinfo, 0, sizeof(pfm_pmu_info_t) );
  ret=pfm_get_pmu_info(gete.pmu, &pinfo);
  if (ret!=PFM_SUCCESS) {
     return ret;
  }

  /* Only prepend PMU name if not on the "default" PMU */

  if (pinfo.pmu == default_pmu.pmu) {
     *event_name=strdup(gete.name);
  }
  else {
     sprintf(name,"%s::%s",pinfo.name,gete.name);
     *event_name=strdup(name);
  }

  SUBDBG("Found name: %s\n",*event_name);

  return PFM_SUCCESS;

}


static int convert_pfmidx_to_native(int code, unsigned int *PapiEventCode) {

  int ret;
  char *name=NULL;

  ret=convert_libpfm4_to_string( code, &name);
  if (ret!=PFM_SUCCESS) {
     return _papi_libpfm4_error(ret);
  }

  SUBDBG("Converted %x to %s\n",code,name);

  ret=_papi_libpfm4_ntv_name_to_code(name,PapiEventCode);

  SUBDBG("Converted %s to event %x\n",name,*PapiEventCode);

  if (name) free(name);

  return ret;

}


static int find_next_umask(struct native_event_t *current_event,
                           int current,char *umask_name) {

  char temp_string[BUFSIZ];
  pfm_event_info_t event_info;
  pfm_event_attr_info_t ainfo;
  int num_masks=0;
  pfm_err_t ret;
  int i;

  /* get number of attributes */

  memset(&event_info, 0, sizeof(event_info));
  ret=pfm_get_event_info(current_event->libpfm4_idx, 
             PFM_OS_PERF_EVENT, &event_info);
  if (ret!=PFM_SUCCESS) {
     return ret;
  }
    
  SUBDBG("%d possible attributes for event %s\n",
     event_info.nattrs,
     event_info.name);

  pfm_for_each_event_attr(i, &event_info) {

     ainfo.size = sizeof(ainfo);

     ret = pfm_get_event_attr_info(event_info.idx, i, PFM_OS_PERF_EVENT, 
                   &ainfo);
     if (ret != PFM_SUCCESS) {
        SUBDBG("Not found\n");
    return PFM_ERR_NOTFOUND;
     }

     if (ainfo.type == PFM_ATTR_UMASK) {
    SUBDBG("nm %d looking for %d\n",num_masks,current);
    if (num_masks==current+1) {   
       SUBDBG("Found attribute %d: %s type: %d\n",
          i,ainfo.name,ainfo.type);
    
           sprintf(temp_string,"%s",ainfo.name);
           strncpy(umask_name,temp_string,BUFSIZ);

       return current+1;
    }
    num_masks++;
     }

     if (ainfo.type == PFM_ATTR_MOD_BOOL) {
    SUBDBG("nm %d looking for %d\n",num_masks,current);
    
    if (num_masks==current+1) {   
       SUBDBG("Found attribute %d: %s type: %d\n",
          i,ainfo.name,ainfo.type);
    
           sprintf(temp_string,"%s=0",ainfo.name);
           strncpy(umask_name,temp_string,BUFSIZ);

       return current+1;
    }
    num_masks++;
     }

     if (ainfo.type == PFM_ATTR_MOD_INTEGER) {
    SUBDBG("nm %d looking for %d\n",num_masks,current);
    if (num_masks==current+1) {   
       SUBDBG("Found attribute %d: %s type: %d\n",
          i,ainfo.name,ainfo.type);
    
           sprintf(temp_string,"%s=0",ainfo.name);
           strncpy(umask_name,temp_string,BUFSIZ);

       return current+1;
    }
    num_masks++;
     }
  }

  return PFM_ERR_ATTR;

}



/***********************************************************/
/* Exported functions                                      */
/***********************************************************/


int
_papi_libpfm4_error( int pfm_error ) {

  switch ( pfm_error ) {
  case PFM_SUCCESS:      return PAPI_OK;       /* success */
  case PFM_ERR_NOTSUPP:  return PAPI_ENOSUPP;  /* function not supported */
  case PFM_ERR_INVAL:    return PAPI_EINVAL;   /* invalid parameters */
  case PFM_ERR_NOINIT:   return PAPI_ENOINIT;  /* library not initialized */
  case PFM_ERR_NOTFOUND: return PAPI_ENOEVNT;  /* event not found */
  case PFM_ERR_FEATCOMB: return PAPI_ECOMBO;   /* invalid combination of features */
  case PFM_ERR_UMASK:    return PAPI_EATTR;    /* invalid or missing unit mask */
  case PFM_ERR_NOMEM:    return PAPI_ENOMEM;   /* out of memory */
  case PFM_ERR_ATTR:     return PAPI_EATTR;    /* invalid event attribute */
  case PFM_ERR_ATTR_VAL: return PAPI_EATTR;    /* invalid event attribute value */
  case PFM_ERR_ATTR_SET: return PAPI_EATTR;    /* attribute value already set */
  case PFM_ERR_TOOMANY:  return PAPI_ECOUNT;   /* too many parameters */
  case PFM_ERR_TOOSMALL: return PAPI_ECOUNT;   /* parameter is too small */
  default: return PAPI_EINVAL;
  }
}

int
_papi_libpfm4_ntv_name_to_code( char *name, unsigned int *event_code )
{

  int actual_idx;
  struct native_event_t *our_event;
  int event_num;

  SUBDBG( "Converting %s\n", name);

  event_num=find_existing_event(name);

  if (event_num<0) {

     /* event currently doesn't exist, so try to find it */
     /* using libpfm4                                    */

     SUBDBG("Using pfm to look up event %s\n",name);
     actual_idx=pfm_find_event(name);
     if (actual_idx<0) {
        return _papi_libpfm4_error(actual_idx);
     }

     SUBDBG("Using %x as the index\n",actual_idx);

     /* We were found in libpfm4, so allocate our copy of the event */

     our_event=allocate_native_event(name,actual_idx);
     if (our_event==NULL) return PAPI_ENOEVNT;

     event_num=find_existing_event(name);
  }

  if (event_num>=0) {      
     *event_code=event_num;
     SUBDBG("Found code: %x\n",*event_code);
     return PAPI_OK;
  }

  /* Failure here means allocate_native_event failed */

  SUBDBG("Event %s not found\n",name);

  return PAPI_ENOEVNT;   

}


int
_papi_libpfm4_ntv_code_to_name(unsigned int EventCode, char *ntv_name, int len)
{

        struct native_event_t *our_event;

        SUBDBG("ENTER %x\n",EventCode);

        our_event=find_existing_event_by_number(EventCode);
    if (our_event==NULL) {
      return PAPI_ENOEVNT;
    }

    strncpy(ntv_name,our_event->allocated_name,len);

    if (strlen(our_event->allocated_name) > (unsigned)len) {
       return PAPI_EBUF;
    }

    return PAPI_OK;
}


int
_papi_libpfm4_ntv_code_to_descr( unsigned int EventCode, 
                char *ntv_descr, int len )
{
  int ret,a,first_mask=1;
  char *eventd, *tmp=NULL;
  pfm_event_info_t gete;

  pfm_event_attr_info_t ainfo;
  char *b;
  char event_string[BUFSIZ],*ptr;
  char temp_string[BUFSIZ];

  struct native_event_t *our_event;

  SUBDBG("ENTER %x\n",EventCode);

  our_event=find_existing_event_by_number(EventCode);
  if (our_event==NULL) {
     return PAPI_ENOEVNT;
  }

  SUBDBG("Getting info on %x\n",our_event->libpfm4_idx);
    
  /* libpfm requires the structure be zeroed */
  memset( &gete, 0, sizeof ( gete ) );

  ret=pfm_get_event_info(our_event->libpfm4_idx, PFM_OS_PERF_EVENT, &gete);
  if (ret<0) {
     SUBDBG("Return=%d\n",ret);
     return _papi_libpfm4_error(ret);
  }

  eventd=strdup(gete.desc);

  tmp = ( char * ) malloc( strlen( eventd ) + 1 );
  if ( tmp == NULL ) {
     free( eventd );
     return PAPI_ENOMEM;
  }
    
  tmp[0] = '\0';
  strcat( tmp, eventd );
  free( eventd );
    
  /* Handle Umasks */

  /* attributes concactinated onto end of descr separated by ", masks" */
  /* then comma separated */

  strcpy(event_string,our_event->allocated_name);

  /* Point to first umask */

  /* Skip the pmu name :: if one exists */
  if (strstr(event_string,"::")) {
     ptr=strstr(event_string,"::");
     ptr+=2;
     b=strtok(ptr,":");
  }
  else {
     b=strtok(event_string,":");
  }
  
  /* if no umask, then done */
  if (!b) {
     SUBDBG("No colon!\n"); /* no umask */
     goto descr_in_tmp;
  }

  /* skip first */
  b=strtok(NULL,":");
  if (!b) {
     SUBDBG("Skipping first failed\n");
     goto descr_in_tmp;
  }

  /* loop through all umasks, seeing which match */
  while(b) {
    a=0;
    while(1) {

      SUBDBG("get_event_attr %x %p\n",our_event->libpfm4_idx,&ainfo);

      memset(&ainfo,0,sizeof(pfm_event_attr_info_t));

      ret = pfm_get_event_attr_info(our_event->libpfm4_idx, a, 
                    PFM_OS_PERF_EVENT, &ainfo);
      if (ret != PFM_SUCCESS) {
    SUBDBG("get_event_attr failed %s\n",pfm_strerror(ret));
    return _papi_libpfm4_error(ret);
      }

      /* Plain UMASK case */
      if (ainfo.type == PFM_ATTR_UMASK) {
   
         SUBDBG("Trying %s with %s\n",ainfo.name,b);

         if (!strcasecmp(ainfo.name, b)) {
        int new_length;

        SUBDBG("Found %s\n",b);
        new_length=strlen(ainfo.desc);

        if (first_mask) {
           tmp=realloc(tmp,strlen(tmp)+new_length+1+strlen(", masks:"));
           strcat(tmp,", masks:");
           first_mask=0;
        }
        else {
           tmp=realloc(tmp,strlen(tmp)+new_length+1+strlen(","));
           strcat(tmp,",");
        }
        strcat(tmp,ainfo.desc);

        goto found_attr;
     }
      }

      /* Boolean Case */
      if (ainfo.type == PFM_ATTR_MOD_BOOL) {
    
     sprintf(temp_string,"%s=0",ainfo.name);

         SUBDBG("Trying %s with %s\n",temp_string,b);

         if (!strcasecmp(temp_string, b)) {
        int new_length;

        SUBDBG("Found %s\n",b);
        new_length=strlen(ainfo.desc);

        if (first_mask) {
           tmp=realloc(tmp,strlen(tmp)+new_length+1+strlen(", masks:"));
           strcat(tmp,", masks:");
           first_mask=0;
        }
        else {
           tmp=realloc(tmp,strlen(tmp)+new_length+1+strlen(","));
           strcat(tmp,",");
        }
        strcat(tmp,ainfo.desc);

        goto found_attr;
     }
      }

      /* Integer Case */
      if (ainfo.type == PFM_ATTR_MOD_INTEGER) {

     sprintf(temp_string,"%s=0",ainfo.name);

         SUBDBG("Trying %s with %s\n",temp_string,b);

         if (!strcasecmp(temp_string, b)) {
        int new_length;

        SUBDBG("Found %s\n",b);
        new_length=strlen(ainfo.desc);

        if (first_mask) {
           tmp=realloc(tmp,strlen(tmp)+new_length+1+strlen(", masks:"));
           strcat(tmp,", masks:");
           first_mask=0;
        }
        else {
           tmp=realloc(tmp,strlen(tmp)+new_length+1+strlen(","));
           strcat(tmp,",");
        }
        strcat(tmp,ainfo.desc);

        goto found_attr;
     }
      }

      a++;
    }

    SUBDBG("attr=%s not found for event %s\n", b, ainfo.name);

    return PAPI_EATTR;

found_attr:

    b=strtok(NULL,":");
  }

  /* We are done and the description to copy is in tmp */
descr_in_tmp:
    strncpy( ntv_descr, tmp, ( size_t ) len );
    if ( ( int ) strlen( tmp ) > len - 1 )
        ret = PAPI_EBUF;
    else
        ret = PAPI_OK;
    free( tmp );

    SUBDBG("PFM4 Code: %x %s\n",EventCode,ntv_descr);

    return ret;
}


int
_papi_libpfm4_ntv_code_to_info(unsigned int EventCode, PAPI_event_info_t *info)
{


  struct native_event_t *our_event;

  SUBDBG("ENTER %x\n",EventCode);

  our_event=find_existing_event_by_number(EventCode);
  if (our_event==NULL) {
     return PAPI_ENOEVNT;
  }

  strncpy(info->symbol, our_event->allocated_name, sizeof(info->symbol));

  if (strlen(our_event->allocated_name) > sizeof(info->symbol)) {
     return PAPI_EBUF;
  }

  _papi_libpfm4_ntv_code_to_descr(EventCode,info->long_descr,
                 sizeof(info->long_descr));

  return PAPI_OK;
}



int
_papi_libpfm4_ntv_enum_events( unsigned int *PapiEventCode, int modifier )
{
    int code,ret;
    struct native_event_t *current_event;

        SUBDBG("ENTER\n");

    /* return first event if so specified */
    if ( modifier == PAPI_ENUM_FIRST ) {

       unsigned int papi_event=0;

           SUBDBG("ENUM_FIRST\n");

       code=get_event_first_active();
       SUBDBG("ENUM_FIRST code: %d\n",code);
       if (code < 0 ) {
          return code;
       }

       /* convert the libpfm4 event to a PAPI event */
       ret=convert_pfmidx_to_native(code, &papi_event);

       *PapiEventCode=(unsigned int)papi_event;

           SUBDBG("FOUND %x (from %x) ret=%d\n",*PapiEventCode,code,ret);

       return ret;
    }

    /* If we get this far, we're looking for a        */
    /* next-event.  So gather info on the current one */
    current_event=find_existing_event_by_number(*PapiEventCode);
    if (current_event==NULL) {
           SUBDBG("EVENTS %x not found\n",*PapiEventCode);
       return PAPI_ENOEVNT;
    }


    /* Handle looking for the next event */

    if ( modifier == PAPI_ENUM_EVENTS ) {

       unsigned int papi_event=0;

       SUBDBG("PAPI_ENUM_EVENTS %x\n",*PapiEventCode);

       code=current_event->libpfm4_idx;

       ret=find_next_no_aliases(code);
       SUBDBG("find_next_no_aliases() Returned %x\n",ret);
       if (ret<0) {
          return ret;
       }

       /* Convert libpfm4 event code to PAPI event code */
       ret=convert_pfmidx_to_native(ret, &papi_event);
       if (ret<0) {
           SUBDBG("Couldn't convert to native %d %s\n",
              ret,PAPI_strerror(ret));
           return ret;
       }

       *PapiEventCode=(unsigned int)papi_event;

           SUBDBG("Returning PAPI_OK\n");

       return ret;
    }

    /* We don't handle PAPI_NTV_ENUM_UMASK_COMBOS */
    if ( modifier == PAPI_NTV_ENUM_UMASK_COMBOS ) {
       return PAPI_ENOIMPL;
    } 

    /* Enumerate PAPI_NTV_ENUM_UMASKS (umasks on an event) */
    if ( modifier == PAPI_NTV_ENUM_UMASKS ) {

       int max_umask,next_umask;
       char umask_string[BUFSIZ],new_name[BUFSIZ];

       SUBDBG("Finding maximum mask in event %s\n",
                  current_event->allocated_name);

       max_umask=find_max_umask(current_event);
       SUBDBG("Found max %d\n",max_umask);

       if (max_umask<0) {
          if (max_umask==PFM_ERR_UMASK) {
             max_umask=-1; /* needed for find_next_umask() to work */
                       /* indicates the event as passed had no */
                       /* umask in it.                         */
          }
          else {
             return _papi_libpfm4_error(max_umask);
          }
       }

       next_umask=find_next_umask(current_event,max_umask,
                      umask_string);

       SUBDBG("Found next %d\n",next_umask);

       if (next_umask>=0) {

          unsigned int papi_event;

          sprintf(new_name,"%s:%s",current_event->base_name,
             umask_string);
     
          SUBDBG("Found new name %s\n",new_name);

              ret=_papi_libpfm4_ntv_name_to_code(new_name,&papi_event);
          if (ret!=PAPI_OK) {
         return PAPI_ENOEVNT;
          }

          *PapiEventCode=(unsigned int)papi_event;
          SUBDBG("found code %x\n",*PapiEventCode);

          return PAPI_OK;
       }

       SUBDBG("couldn't find umask\n");

       return _papi_libpfm4_error(next_umask);

    }
    
    /* An unknown enumeration method was indicated */

    return PAPI_ENOIMPL;
}

int 
_papi_libpfm4_shutdown(void) {

  int i;

  SUBDBG("shutdown\n");

  /* clean out and free the native events structure */
  _papi_hwi_lock( NAMELIB_LOCK );

  /* free memory allocate with strdup */
  for( i=0; i<num_native_events; i++) {
     free(native_events[i].base_name);
     free(native_events[i].pmu_plus_name);
     free(native_events[i].pmu);
     free(native_events[i].allocated_name);
  }

  memset(native_events,0,
     sizeof(struct native_event_t)*allocated_native_events);
  num_native_events=0;
  allocated_native_events=0;
  free(native_events);
  _papi_hwi_unlock( NAMELIB_LOCK );

  return PAPI_OK;
}


int
_papi_libpfm4_init(papi_vector_t *my_vector, int cidx) {

   int detected_pmus=0, found_default=0;
   int i, version;
   pfm_err_t retval;
   unsigned int ncnt;
   pfm_pmu_info_t pinfo;

   /* The following checks the version of the PFM library
      against the version PAPI linked to... */
   if ( ( retval = pfm_initialize(  ) ) != PFM_SUCCESS ) {
      PAPIERROR( "pfm_initialize(): %s", pfm_strerror( retval ) );
      return PAPI_ESYS;
   }

   /* get the libpfm4 version */
   SUBDBG( "pfm_get_version()\n");
   if ( (version=pfm_get_version( )) < 0 ) {
      PAPIERROR( "pfm_get_version(): %s", pfm_strerror( retval ) );
      return PAPI_ESYS;
   }

   /* Set the version */
   sprintf( my_vector->cmp_info.support_version, "%d.%d",
        PFM_MAJ_VERSION( version ), PFM_MIN_VERSION( version ) );

   /* Complain if the compiled-against version doesn't match current version */
   if ( PFM_MAJ_VERSION( version ) != PFM_MAJ_VERSION( LIBPFM_VERSION ) ) {
      PAPIERROR( "Version mismatch of libpfm: compiled %x vs. installed %x\n",
                   PFM_MAJ_VERSION( LIBPFM_VERSION ),
                   PFM_MAJ_VERSION( version ) );
      return PAPI_ESYS;
   }

   /* allocate the native event structure */

   num_native_events=0;

   native_events=calloc(NATIVE_EVENT_CHUNK,sizeof(struct native_event_t));
   if (native_events==NULL) {
      return PAPI_ENOMEM;
   }
   allocated_native_events=NATIVE_EVENT_CHUNK;

   /* Count number of present PMUs */
   detected_pmus=0;
   ncnt=0;

   /* need to init pinfo or pfmlib might complain */
   memset(&default_pmu, 0, sizeof(pfm_pmu_info_t));
   /* init default pmu */
   retval=pfm_get_pmu_info(0, &default_pmu);
   
   SUBDBG("Detected pmus:\n");
   for(i=0;i<PFM_PMU_MAX;i++) {
      memset(&pinfo,0,sizeof(pfm_pmu_info_t));
      retval=pfm_get_pmu_info(i, &pinfo);
      if (retval!=PFM_SUCCESS) {
     continue;
      }
      if (pinfo.is_present) {
     SUBDBG("\t%d %s %s %d\n",i,pinfo.name,pinfo.desc,pinfo.type);

         detected_pmus++;
     ncnt+=pinfo.nevents;

     /* Choose default PMU */
     if ( (pinfo.type==PFM_PMU_TYPE_CORE) &&
              strcmp(pinfo.name,"ix86arch")) {

        SUBDBG("\t  %s is default\n",pinfo.name);
        memcpy(&default_pmu,&pinfo,sizeof(pfm_pmu_info_t));
        found_default++;
     }
      }
   }
   SUBDBG("%d native events detected on %d pmus\n",ncnt,detected_pmus);

   if (!found_default) {
      PAPIERROR("Could not find default PMU\n");
      return PAPI_ECMP;
   }

   if (found_default>1) {
     PAPIERROR("Found too many default PMUs!\n");
     return PAPI_ECMP;
   }

   my_vector->cmp_info.num_native_events = ncnt;

   my_vector->cmp_info.num_cntrs = default_pmu.num_cntrs+
                                  default_pmu.num_fixed_cntrs;

   SUBDBG( "num_counters: %d\n", my_vector->cmp_info.num_cntrs );
   
   /* Setup presets */
   retval = _papi_load_preset_table( (char *)default_pmu.name, 
                    default_pmu.pmu, cidx );
   if ( retval ) {
      return retval;
   }    

   return PAPI_OK;
}


int
_papi_libpfm4_setup_counters( struct perf_event_attr *attr,
                 int event ) {

  struct native_event_t *our_event;

  our_event=find_existing_event_by_number(event);
  if (our_event==NULL) {
     return PAPI_ENOEVNT;
  }

  attr->config=our_event->config; 
  attr->config1=our_event->config1;
  attr->config2=our_event->config2;
  attr->type=our_event->type;
  
  SUBDBG( "pe_event: config 0x%"PRIx64
          " config1 0x%"PRIx64
          " type 0x%"PRIx32"\n", 
          attr->config, 
      attr->config1,
      attr->type);
      

  return PAPI_OK;
}