papi_libpfm_events.h File Reference

Include dependency graph for papi_libpfm_events.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	perf_event_attr

Macros
#define	PERF_TYPE_RAW   4;

Functions
int	_papi_libpfm_error (int pfm_error)
int	_papi_libpfm_setup_presets (char *name, int type, int cidx)
int	_papi_libpfm_ntv_enum_events (unsigned int *EventCode, int modifier)
int	_papi_libpfm_ntv_name_to_code (const char *ntv_name, unsigned int *EventCode)
int	_papi_libpfm_ntv_code_to_name (unsigned int EventCode, char *name, int len)
int	_papi_libpfm_ntv_code_to_descr (unsigned int EventCode, char *name, int len)
int	_papi_libpfm_ntv_code_to_bits (unsigned int EventCode, hwd_register_t *bits)
int	_papi_libpfm_ntv_code_to_bits_perfctr (unsigned int EventCode, hwd_register_t *bits)
int	_papi_libpfm_shutdown (void)
int	_papi_libpfm_init (papi_vector_t *my_vector, int cidx)
int	_pfm_decode_native_event (unsigned int EventCode, unsigned int *event, unsigned int *umask)
unsigned int	_pfm_convert_umask (unsigned int event, unsigned int umask)
int	prepare_umask (unsigned int foo, unsigned int *values)
int	_papi_libpfm_ntv_code_to_info (unsigned int EventCode, PAPI_event_info_t *info)
int	_papi_libpfm_setup_counters (struct perf_event_attr *attr, hwd_register_t *ni_bits)

Macro Definition Documentation

PERF_TYPE_RAW

#define PERF_TYPE_RAW   4;

Definition at line 47 of file papi_libpfm_events.h.

Function Documentation

_papi_libpfm_error()

int _papi_libpfm_error

(

int

pfm_error

)

Definition at line 149 of file papi_libpfm3_events.c.

{
    switch ( pfm_error ) {
        case PFMLIB_SUCCESS:        return PAPI_OK;         /* success */
        case PFMLIB_ERR_NOTSUPP:    return PAPI_ENOSUPP;    /* function not supported */
        case PFMLIB_ERR_INVAL:      return PAPI_EINVAL;     /* invalid parameters */
        case PFMLIB_ERR_NOINIT:     return PAPI_ENOINIT;    /* library was not initialized */
        case PFMLIB_ERR_NOTFOUND:   return PAPI_ENOEVNT;    /* event not found */
        case PFMLIB_ERR_NOASSIGN:   return PAPI_ECNFLCT;    /* cannot assign events to counters */
        case PFMLIB_ERR_FULL:       return PAPI_EBUF;       /* buffer is full or too small */
        case PFMLIB_ERR_EVTMANY:    return PAPI_EMISC;      /* event used more than once */
        case PFMLIB_ERR_MAGIC:      return PAPI_EBUG;       /* invalid library magic number */
        case PFMLIB_ERR_FEATCOMB:   return PAPI_ECOMBO;     /* invalid combination of features */
        case PFMLIB_ERR_EVTSET:     return PAPI_ENOEVST;    /* incompatible event sets */
        case PFMLIB_ERR_EVTINCOMP:  return PAPI_ECNFLCT;    /* incompatible event combination */
        case PFMLIB_ERR_TOOMANY:    return PAPI_ECOUNT;     /* too many events or unit masks */
        case PFMLIB_ERR_BADHOST:    return PAPI_ESYS;       /* not supported by host CPU */
        case PFMLIB_ERR_UMASK:      return PAPI_EATTR;      /* invalid or missing unit mask */
        case PFMLIB_ERR_NOMEM:      return PAPI_ENOMEM;     /* out of memory */

        /* Itanium only */
        case PFMLIB_ERR_IRRTOOBIG:      /* code range too big */
        case PFMLIB_ERR_IRREMPTY:       /* empty code range */
        case PFMLIB_ERR_IRRINVAL:       /* invalid code range */
        case PFMLIB_ERR_IRRTOOMANY:     /* too many code ranges */
        case PFMLIB_ERR_DRRINVAL:       /* invalid data range */
        case PFMLIB_ERR_DRRTOOMANY:     /* too many data ranges */
        case PFMLIB_ERR_IRRALIGN:       /* bad alignment for code range */
        case PFMLIB_ERR_IRRFLAGS:       /* code range missing flags */
        default:
            return PAPI_EINVAL;
    }
}

_papi_libpfm_init()

int _papi_libpfm_init	(	papi_vector_t *	my_vector,
		int	cidx
	)

Definition at line 442 of file papi_libpfm3_events.c.

                                                      {

   int retval;
   unsigned int ncnt;
   unsigned int version;
   char pmu_name[PAPI_MIN_STR_LEN];


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

   /* Get the libpfm3 version */
   SUBDBG( "pfm_get_version(%p)\n", &version );
   if ( pfm_get_version( &version ) != PFMLIB_SUCCESS ) {
      PAPIERROR( "pfm_get_version(%p): %s", version, pfm_strerror( retval ) );
      return PAPI_ESYS;
   }

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

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

   /* Always initialize globals dynamically to handle forks properly. */

   _perfmon2_pfm_pmu_type = -1;

   /* Opened once for all threads. */
   SUBDBG( "pfm_get_pmu_type(%p)\n", &_perfmon2_pfm_pmu_type );
   if ( pfm_get_pmu_type( &_perfmon2_pfm_pmu_type ) != PFMLIB_SUCCESS ) {
      PAPIERROR( "pfm_get_pmu_type(%p): %s", _perfmon2_pfm_pmu_type,
                   pfm_strerror( retval ) );
      return PAPI_ESYS;
   }

   pmu_name[0] = '\0';
   if ( pfm_get_pmu_name( pmu_name, PAPI_MIN_STR_LEN ) != PFMLIB_SUCCESS ) {
      PAPIERROR( "pfm_get_pmu_name(%p,%d): %s", pmu_name, PAPI_MIN_STR_LEN,
                   pfm_strerror( retval ) );
      return PAPI_ESYS;
   }
   SUBDBG( "PMU is a %s, type %d\n", pmu_name, _perfmon2_pfm_pmu_type );

   /* Setup presets */
   retval = _papi_load_preset_table( pmu_name, _perfmon2_pfm_pmu_type, cidx );
   if ( retval )
      return retval;

   /* Fill in cmp_info */

   SUBDBG( "pfm_get_num_events(%p)\n", &ncnt );
   if ( ( retval = pfm_get_num_events( &ncnt ) ) != PFMLIB_SUCCESS ) {
      PAPIERROR( "pfm_get_num_events(%p): %s\n", &ncnt,
                   pfm_strerror( retval ) );
      return PAPI_ESYS;
   }
   SUBDBG( "pfm_get_num_events: %d\n", ncnt );
   my_vector->cmp_info.num_native_events = ncnt;
   num_native_events = ncnt;

   pfm_get_num_counters( ( unsigned int * ) &my_vector->cmp_info.num_cntrs );
   SUBDBG( "pfm_get_num_counters: %d\n", my_vector->cmp_info.num_cntrs );


   if ( _papi_hwi_system_info.hw_info.vendor == PAPI_VENDOR_INTEL ) {
     /* Pentium4 */
     if ( _papi_hwi_system_info.hw_info.cpuid_family == 15 ) {
       PAPI_NATIVE_EVENT_AND_MASK = 0x000000ff;
       PAPI_NATIVE_UMASK_AND_MASK = 0x0fffff00;
       PAPI_NATIVE_UMASK_SHIFT = 8;
       /* Itanium2 */
     } else if ( _papi_hwi_system_info.hw_info.cpuid_family == 31 ||
         _papi_hwi_system_info.hw_info.cpuid_family == 32 ) {
       PAPI_NATIVE_EVENT_AND_MASK = 0x00000fff;
       PAPI_NATIVE_UMASK_AND_MASK = 0x0ffff000;
       PAPI_NATIVE_UMASK_SHIFT = 12;
     }
   }


   return PAPI_OK;
}

Here is the call graph for this function:

_papi_libpfm_ntv_code_to_bits()

int _papi_libpfm_ntv_code_to_bits	(	unsigned int	EventCode,
		hwd_register_t *	bits
	)

Definition at line 416 of file papi_libpfm3_events.c.

{
    unsigned int event, umask;
    pfmlib_event_t gete;

    /* For PFM & Perfmon, native info is just an index into PFM event table. */
    if ( _pfm_decode_native_event( EventCode, &event, &umask ) != PAPI_OK )
       return PAPI_ENOEVNT;

    memset( &gete, 0x0, sizeof ( pfmlib_event_t ) );

    gete.event = event;
    gete.num_masks = prepare_umask( umask, gete.unit_masks );

    memcpy( bits, &gete, sizeof ( pfmlib_event_t ) );

    return PAPI_OK;

}

Here is the call graph for this function:

_papi_libpfm_ntv_code_to_bits_perfctr()

int _papi_libpfm_ntv_code_to_bits_perfctr	(	unsigned int	EventCode,
		hwd_register_t *	bits
	)

Definition at line 1015 of file perfctr-x86.c.

{
    unsigned int event, umask;

    X86_register_t *bits = (X86_register_t *)newbits;

    if ( is_pentium4() ) {
       pentium4_escr_value_t escr_value;
       pentium4_cccr_value_t cccr_value;
       unsigned int num_masks, replay_mask, unit_masks[12];
       unsigned int event_mask;
       unsigned int tag_value, tag_enable;
       unsigned int i;
       int j, escr, cccr, pmd;

       if ( _pfm_decode_native_event( EventCode, &event, &umask ) != PAPI_OK )
      return PAPI_ENOEVNT;

       /* for each allowed escr (1 or 2) find the allowed cccrs.
      for each allowed cccr find the pmd index
      convert to an intel counter number; or it into bits->counter */
       for ( i = 0; i < MAX_ESCRS_PER_EVENT; i++ ) {
      bits->counter[i] = 0;
      escr = pentium4_events[event].allowed_escrs[i];
      if ( escr < 0 ) {
         continue;
      }

      bits->escr[i] = escr;

      for ( j = 0; j < MAX_CCCRS_PER_ESCR; j++ ) {
         cccr = pentium4_escrs[escr].allowed_cccrs[j];
         if ( cccr < 0 ) {
        continue;
         }

         pmd = pentium4_cccrs[cccr].pmd;
         bits->counter[i] |= ( 1 << pfm2intel[pmd] );
      }
       }

       /* if there's only one valid escr, copy the values */
       if ( escr < 0 ) {
      bits->escr[1] = bits->escr[0];
      bits->counter[1] = bits->counter[0];
       }

       /* Calculate the event-mask value. Invalid masks
    * specified by the caller are ignored. */
       tag_value = 0;
       tag_enable = 0;
       event_mask = _pfm_convert_umask( event, umask );

       if ( event_mask & 0xF0000 ) {
      tag_enable = 1;
      tag_value = ( ( event_mask & 0xF0000 ) >> EVENT_MASK_BITS );
       }

       event_mask &= 0x0FFFF;   /* mask off possible tag bits */

       /* Set up the ESCR and CCCR register values. */
       escr_value.val = 0;
       escr_value.bits.t1_usr = 0;  /* controlled by kernel */
       escr_value.bits.t1_os = 0;   /* controlled by kernel */
//    escr_value.bits.t0_usr       = (plm & PFM_PLM3) ? 1 : 0;
//    escr_value.bits.t0_os        = (plm & PFM_PLM0) ? 1 : 0;
       escr_value.bits.tag_enable = tag_enable;
       escr_value.bits.tag_value = tag_value;
       escr_value.bits.event_mask = event_mask;
       escr_value.bits.event_select = pentium4_events[event].event_select;
       escr_value.bits.reserved = 0;

       /* initialize the proper bits in the cccr register */
       cccr_value.val = 0;
       cccr_value.bits.reserved1 = 0;
       cccr_value.bits.enable = 1;
       cccr_value.bits.escr_select = pentium4_events[event].escr_select;
       cccr_value.bits.active_thread = 3;   
       /* FIXME: This is set to count when either logical
    *        CPU is active. Need a way to distinguish
    *        between logical CPUs when HT is enabled.
        *        the docs say these bits should always 
    *        be set.                                  */
       cccr_value.bits.compare = 0; 
       /* FIXME: What do we do with "threshold" settings? */
       cccr_value.bits.complement = 0;  
       /* FIXME: What do we do with "threshold" settings? */
       cccr_value.bits.threshold = 0;   
       /* FIXME: What do we do with "threshold" settings? */
       cccr_value.bits.force_ovf = 0;   
       /* FIXME: Do we want to allow "forcing" overflow
        *        interrupts on all counter increments? */
       cccr_value.bits.ovf_pmi_t0 = 0;
       cccr_value.bits.ovf_pmi_t1 = 0;  
       /* PMI taken care of by kernel typically */
       cccr_value.bits.reserved2 = 0;
       cccr_value.bits.cascade = 0; 
       /* FIXME: How do we handle "cascading" counters? */
       cccr_value.bits.overflow = 0;

       /* these flags are always zero, from what I can tell... */
       bits->pebs_enable = 0;   /* flag for PEBS counting */
       bits->pebs_matrix_vert = 0;  
       /* flag for PEBS_MATRIX_VERT, whatever that is */

       /* ...unless the event is replay_event */
       if ( !strcmp( pentium4_events[event].name, "replay_event" ) ) {
      escr_value.bits.event_mask = event_mask & P4_REPLAY_REAL_MASK;
      num_masks = prepare_umask( umask, unit_masks );
      for ( i = 0; i < num_masks; i++ ) {
         replay_mask = unit_masks[i];
         if ( replay_mask > 1 && replay_mask < 11 ) {
            /* process each valid mask we find */
        bits->pebs_enable |= p4_replay_regs[replay_mask].enb;
        bits->pebs_matrix_vert |= p4_replay_regs[replay_mask].mat_vert;
         }
      }
       }

       /* store the escr and cccr values */
       bits->event = escr_value.val;
       bits->cccr = cccr_value.val;
       bits->ireset = 0;     /* I don't really know what this does */
       SUBDBG( "escr: 0x%lx; cccr:  0x%lx\n", escr_value.val, cccr_value.val );
    } else {

       int ret, code;

       if ( _pfm_decode_native_event( EventCode, &event, &umask ) != PAPI_OK )
      return PAPI_ENOEVNT;

       if ( ( ret = _pfm_get_counter_info( event, &bits->selector,
                          &code ) ) != PAPI_OK )
      return ret;

       bits->counter_cmd=(int) (code | ((_pfm_convert_umask(event,umask))<< 8) );

       SUBDBG( "selector: %#x\n", bits->selector );
       SUBDBG( "event: %#x; umask: %#x; code: %#x; cmd: %#x\n", event,
           umask, code, ( ( hwd_register_t * ) bits )->counter_cmd );
    }

    return PAPI_OK;
}

Here is the call graph for this function:

_papi_libpfm_ntv_code_to_descr()

int _papi_libpfm_ntv_code_to_descr	(	unsigned int	EventCode,
		char *	name,
		int	len
	)

Definition at line 262 of file papi_libpfm3_events.c.

{
    unsigned int event, umask;
    char *eventd, **maskd, *tmp;
    int i, ret;
    pfmlib_event_t gete;
    size_t total_len = 0;

    memset( &gete, 0, sizeof ( gete ) );

    if ( _pfm_decode_native_event( EventCode, &event, &umask ) != PAPI_OK )
        return ( PAPI_ENOEVNT );

    ret = pfm_get_event_description( event, &eventd );
    if ( ret != PFMLIB_SUCCESS ) {
        PAPIERROR( "pfm_get_event_description(%d,%p): %s",
                   event, &eventd, pfm_strerror( ret ) );
        return ( PAPI_ENOEVNT );
    }

    if ( ( gete.num_masks =
           ( unsigned int ) prepare_umask( umask, gete.unit_masks ) ) ) {
        maskd = ( char ** ) malloc( gete.num_masks * sizeof ( char * ) );
        if ( maskd == NULL ) {
            free( eventd );
            return ( PAPI_ENOMEM );
        }
        for ( i = 0; i < ( int ) gete.num_masks; i++ ) {
            ret =
                pfm_get_event_mask_description( event, gete.unit_masks[i],
                                                &maskd[i] );
            if ( ret != PFMLIB_SUCCESS ) {
                PAPIERROR( "pfm_get_event_mask_description(%d,%d,%p): %s",
                           event, umask, &maskd, pfm_strerror( ret ) );
                free( eventd );
                for ( ; i >= 0; i-- )
                    free( maskd[i] );
                free( maskd );
                return ( PAPI_EINVAL );
            }
            total_len += strlen( maskd[i] );
        }
        tmp =
            ( char * ) malloc( strlen( eventd ) + strlen( ", masks:" ) +
                               total_len + gete.num_masks + 1 );
        if ( tmp == NULL ) {
            for ( i = ( int ) gete.num_masks - 1; i >= 0; i-- )
                free( maskd[i] );
            free( maskd );
            free( eventd );
        }
        tmp[0] = '\0';
        strcat( tmp, eventd );
        strcat( tmp, ", masks:" );
        for ( i = 0; i < ( int ) gete.num_masks; i++ ) {
            if ( i != 0 )
                strcat( tmp, "," );
            strcat( tmp, maskd[i] );
            free( maskd[i] );
        }
        free( maskd );
    } else {
        tmp = ( char * ) malloc( strlen( eventd ) + 1 );
        if ( tmp == NULL ) {
            free( eventd );
            return ( PAPI_ENOMEM );
        }
        tmp[0] = '\0';
        strcat( tmp, eventd );
        free( eventd );
    }
    strncpy( ntv_descr, tmp, ( size_t ) len );
    if ( ( int ) strlen( tmp ) > len - 1 )
        ret = PAPI_EBUF;
    else
        ret = PAPI_OK;
    free( tmp );
    return ( ret );
}

Here is the call graph for this function:

_papi_libpfm_ntv_code_to_info()

int _papi_libpfm_ntv_code_to_info	(	unsigned int	EventCode,
		PAPI_event_info_t *	info
	)

Definition at line 344 of file papi_libpfm3_events.c.

{

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

  _papi_libpfm_ntv_code_to_name(EventCode,info->symbol,
                                 sizeof(info->symbol));

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

  return PAPI_OK;
}

Here is the call graph for this function:

_papi_libpfm_ntv_code_to_name()

int _papi_libpfm_ntv_code_to_name	(	unsigned int	EventCode,
		char *	name,
		int	len
	)

Definition at line 225 of file papi_libpfm3_events.c.

{
    int ret;
    unsigned int event, umask;
    pfmlib_event_t gete;

    memset( &gete, 0, sizeof ( gete ) );

    if ( _pfm_decode_native_event( EventCode, &event, &umask ) != PAPI_OK )
        return ( PAPI_ENOEVNT );

    gete.event = event;
    gete.num_masks = ( unsigned int ) prepare_umask( umask, gete.unit_masks );
    if ( gete.num_masks == 0 )
        ret = pfm_get_event_name( gete.event, ntv_name, ( size_t ) len );
    else
        ret = pfm_get_full_event_name( &gete, ntv_name, ( size_t ) len );
    if ( ret != PFMLIB_SUCCESS ) {
        char tmp[PAPI_2MAX_STR_LEN];
        pfm_get_event_name( gete.event, tmp, sizeof ( tmp ) );
        /* Skip error message if event is not supported by host cpu;
         * we don't need to give this info away for papi_native_avail util */
        if ( ret != PFMLIB_ERR_BADHOST )
            PAPIERROR
                ( "pfm_get_full_event_name(%p(event %d,%s,%d masks),%p,%d): %d -- %s",
                  &gete, gete.event, tmp, gete.num_masks, ntv_name, len, ret,
                  pfm_strerror( ret ) );
        if ( ret == PFMLIB_ERR_FULL ) {
            return PAPI_EBUF;
        }

        return PAPI_EMISC;
    }
    return PAPI_OK;
}

Here is the call graph for this function:

_papi_libpfm_ntv_enum_events()

int _papi_libpfm_ntv_enum_events	(	unsigned int *	EventCode,
		int	modifier
	)

Definition at line 360 of file papi_libpfm3_events.c.

{
    unsigned int event, umask, num_masks;
    int ret;

    if ( modifier == PAPI_ENUM_FIRST ) {
        *EventCode = PAPI_NATIVE_MASK;  /* assumes first native event is always 0x4000000 */
        return ( PAPI_OK );
    }

    if ( _pfm_decode_native_event( *EventCode, &event, &umask ) != PAPI_OK )
        return ( PAPI_ENOEVNT );

    ret = pfm_get_num_event_masks( event, &num_masks );
    if ( ret != PFMLIB_SUCCESS ) {
        PAPIERROR( "pfm_get_num_event_masks(%d,%p): %s", event, &num_masks,
                   pfm_strerror( ret ) );
        return ( PAPI_ENOEVNT );
    }
    if ( num_masks > PAPI_NATIVE_UMASK_MAX )
        num_masks = PAPI_NATIVE_UMASK_MAX;
    SUBDBG( "This is umask %d of %d\n", umask, num_masks );

    if ( modifier == PAPI_ENUM_EVENTS ) {
        if ( event < ( unsigned int ) num_native_events - 1 ) {
            *EventCode =
                ( unsigned int ) encode_native_event_raw( event + 1, 0 );
            return ( PAPI_OK );
        }
        return ( PAPI_ENOEVNT );
    } else if ( modifier == PAPI_NTV_ENUM_UMASK_COMBOS ) {
        if ( umask + 1 < ( unsigned int ) ( 1 << num_masks ) ) {
            *EventCode =
                ( unsigned int ) encode_native_event_raw( event, umask + 1 );
            return ( PAPI_OK );
        }
        return ( PAPI_ENOEVNT );
    } else if ( modifier == PAPI_NTV_ENUM_UMASKS ) {
        int thisbit = ffs( ( int ) umask );

        SUBDBG( "First bit is %d in %08x\b\n", thisbit - 1, umask );
        thisbit = 1 << thisbit;

        if ( thisbit & ( ( 1 << num_masks ) - 1 ) ) {
            *EventCode =
                ( unsigned int ) encode_native_event_raw( event,
                                                          ( unsigned int )
                                                          thisbit );
            return ( PAPI_OK );
        }
        return ( PAPI_ENOEVNT );
    } else
        return ( PAPI_EINVAL );
}

Here is the call graph for this function:

_papi_libpfm_ntv_name_to_code()

int _papi_libpfm_ntv_name_to_code	(	const char *	ntv_name,
		unsigned int *	EventCode
	)

Definition at line 184 of file papi_libpfm3_events.c.

{
    pfmlib_event_t event;
    unsigned int i;
    int ret;

    SUBDBG( "pfm_find_full_event(%s,%p)\n", name, &event );
    ret = pfm_find_full_event( name, &event );
    if ( ret == PFMLIB_SUCCESS ) {
        SUBDBG( "Full event name found\n" );
        /* we can only capture PAPI_NATIVE_UMASK_MAX or fewer masks */
        if ( event.num_masks > PAPI_NATIVE_UMASK_MAX ) {
            SUBDBG( "num_masks (%d) > max masks (%d)\n", event.num_masks,
                    PAPI_NATIVE_UMASK_MAX );
            return PAPI_ENOEVNT;
        } else {
            /* no mask index can exceed PAPI_NATIVE_UMASK_MAX */
            for ( i = 0; i < event.num_masks; i++ ) {
                if ( event.unit_masks[i] > PAPI_NATIVE_UMASK_MAX ) {
                    SUBDBG( "mask index (%d) > max masks (%d)\n",
                            event.unit_masks[i], PAPI_NATIVE_UMASK_MAX );
                    return PAPI_ENOEVNT;
                }
            }
            *event_code =
                encode_native_event( event.event, event.num_masks,
                                     event.unit_masks );
            return PAPI_OK;
        }
    } else if ( ret == PFMLIB_ERR_UMASK ) {
        SUBDBG( "UMASK error, looking for base event only\n" );
        ret = pfm_find_event( name, &event.event );
        if ( ret == PFMLIB_SUCCESS ) {
            *event_code = encode_native_event( event.event, 0, 0 );
            return PAPI_EATTR;
        }
    }
    return PAPI_ENOEVNT;
}

Here is the call graph for this function:

_papi_libpfm_setup_counters()

int _papi_libpfm_setup_counters	(	struct perf_event_attr *	attr,
		hwd_register_t *	ni_bits
	)

Definition at line 770 of file papi_libpfm3_events.c.

                                         {

  int ret,pe_event;
  (void)ni_bits;

    /*
     * We need an event code that is common across all counters.
     * The implementation is required to know how to translate the supplied
     * code to whichever counter it ends up on.
     */

#if defined(__powerpc__)
    int code;
    ret = pfm_get_event_code_counter( ( ( pfm_register_t * ) ni_bits )->event, 0, &code );
    if ( ret ) {
       /* Unrecognized code, but should never happen */
       return PAPI_EBUG;
    }
    pe_event = code;
    SUBDBG( "Stuffing native event index (code %#x, raw code %#x) into events array.\n",
                  ( ( pfm_register_t * ) ni_bits )->event, code );
#else

   pfmlib_input_param_t inp;
   pfmlib_output_param_t outp;

   memset( &inp, 0, sizeof ( inp ) );
   memset( &outp, 0, sizeof ( outp ) );
   inp.pfp_event_count = 1;
   inp.pfp_dfl_plm = PAPI_DOM_USER;
   pfm_regmask_set( &inp.pfp_unavail_pmcs, 16 );    // mark fixed counters as unavailable

    inp.pfp_events[0] = *( ( pfm_register_t * ) ni_bits );
    ret = pfm_dispatch_events( &inp, NULL, &outp, NULL );
    if (ret != PFMLIB_SUCCESS) {
       SUBDBG( "Error: pfm_dispatch_events returned: %d\n", ret);
       return PAPI_ESYS;
    }
            
       /* Special case p4 */
    if (( _papi_hwi_system_info.hw_info.vendor == PAPI_VENDOR_INTEL ) && 
        ( _papi_hwi_system_info.hw_info.cpuid_family == 15)) {

    pe_event=generate_p4_event( outp.pfp_pmcs[0].reg_value, /* escr */  
                            outp.pfp_pmcs[1].reg_value, /* cccr */
                            outp.pfp_pmcs[0].reg_addr); /* escr_addr */
    }
    else {
        pe_event = outp.pfp_pmcs[0].reg_value;   
    }
    SUBDBG( "pe_event: %#llx\n", outp.pfp_pmcs[0].reg_value );
#endif

    attr->config=pe_event;

    /* for libpfm3 we currently only handle RAW type */
    attr->type=PERF_TYPE_RAW;

    return PAPI_OK;
}

Here is the call graph for this function:

_papi_libpfm_setup_presets()

int _papi_libpfm_setup_presets	(	char *	name,
		int	type,
		int	cidx
	)

_papi_libpfm_shutdown()

int _papi_libpfm_shutdown

(

void

)

Definition at line 833 of file papi_libpfm3_events.c.

                            {

  SUBDBG("shutdown\n");

  return PAPI_OK;
}

_pfm_convert_umask()

unsigned int _pfm_convert_umask	(	unsigned int	event,
		unsigned int	umask
	)

Definition at line 137 of file papi_libpfm3_events.c.

{
    pfmlib_event_t gete;
    memset( &gete, 0, sizeof ( gete ) );
    gete.event = event;
    gete.num_masks = ( unsigned int ) prepare_umask( umask, gete.unit_masks );
    return ( convert_pfm_masks( &gete ) );
}

Here is the call graph for this function:

_pfm_decode_native_event()

int _pfm_decode_native_event	(	unsigned int	EventCode,
		unsigned int *	event,
		unsigned int *	umask
	)

Definition at line 79 of file papi_libpfm3_events.c.

{
    unsigned int tevent, major, minor;

    tevent = EventCode & PAPI_NATIVE_AND_MASK;
    major = ( tevent & PAPI_NATIVE_EVENT_AND_MASK ) >> PAPI_NATIVE_EVENT_SHIFT;
    if ( ( int ) major >= num_native_events )
        return PAPI_ENOEVNT;

    minor = ( tevent & PAPI_NATIVE_UMASK_AND_MASK ) >> PAPI_NATIVE_UMASK_SHIFT;
    *event = major;
    *umask = minor;
    SUBDBG( "EventCode %#08x is event %d, umask %#x\n", EventCode, major,
            minor );
    return PAPI_OK;
}

prepare_umask()

int prepare_umask	(	unsigned int	foo,
		unsigned int *	values
	)

Definition at line 99 of file papi_libpfm3_events.c.

{
    unsigned int tmp = foo, i;
    int j = 0;

    SUBDBG( "umask %#x\n", tmp );
    while ( ( i = ( unsigned int ) ffs( ( int ) tmp ) ) ) {
        tmp = tmp ^ ( 1 << ( i - 1 ) );
        values[j] = i - 1;
        SUBDBG( "umask %d is %d\n", j, values[j] );
        j++;
    }
    return ( j );
}