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

Data Structures
struct	perf_event_attr
Defines
#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 (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)

Define Documentation

#define PERF_TYPE_RAW 4;

Definition at line 45 of file papi_libpfm_events.h.

Function Documentation

int _papi_libpfm_error ( int pfm_error )

< No error

< Not supported

< Invalid argument

< PAPI hasn't been initialized yet

< Event does not exist

< Event exists, but cannot be counted due to counter resource limitations

< Buffer size exceeded

< Unknown error code

< Internal error, please send mail to the developers

< Bad combination of features

< No such EventSet Available

< Event exists, but cannot be counted due to counter resource limitations

< Too many events or attributes

< A System/C library call failed

< Invalid or missing event attributes

< Insufficient memory

< Invalid argument

Definition at line 148 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;
    }
}

Here is the caller graph for this function:

int _papi_libpfm_init	(	papi_vector_t *	my_vector,
		int	cidx
	)

< A System/C library call failed

< No error

Definition at line 441 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:

Here is the caller graph for this function:

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_ntv_code_to_descr	(	unsigned int	EventCode,
		char *	name,
		int	len
	)

< No error

< Event does not exist

< Insufficient memory

< Invalid argument

< Insufficient memory

< Buffer size exceeded

< No error

Definition at line 261 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:

Here is the caller graph for this function:

int _papi_libpfm_ntv_code_to_info	(	unsigned int	EventCode,
		PAPI_event_info_t *	info
	)

< No error

Definition at line 343 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:

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

< No error

< Event does not exist

< Buffer size exceeded

< Unknown error code

< No error

Definition at line 224 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:

Here is the caller graph for this function:

int _papi_libpfm_ntv_enum_events	(	unsigned int *	EventCode,
		int	modifier
	)

< No error

< Event does not exist

< No error

< Event does not exist

< No error

< Event does not exist

< No error

< Event does not exist

< Invalid argument

Definition at line 359 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:

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

< Event does not exist

< No error

< Invalid or missing event attributes

< Event does not exist

Definition at line 183 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:

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

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

int _papi_libpfm_shutdown ( void )

< No error

Definition at line 832 of file papi_libpfm3_events.c.

                            {

  SUBDBG("shutdown\n");

  return PAPI_OK;
}

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

Definition at line 136 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:

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

< Event does not exist

< No error

Definition at line 78 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 0x%08x is event %d, umask 0x%x\n", EventCode, major,
            minor );
    return PAPI_OK;
}

Here is the caller graph for this function:

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

Definition at line 98 of file papi_libpfm3_events.c.

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

    SUBDBG( "umask 0x%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 );
}

Here is the caller graph for this function:

Data Structures

Defines

Functions

Define Documentation

Function Documentation