pe_libpfm4_events.h File Reference

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

Go to the source code of this file.

Functions
int	_pe_libpfm4_setup_presets (char *name, int type, int cidx)
int	_pe_libpfm4_ntv_enum_events (unsigned int *EventCode, int modifier, int cidx, struct native_event_table_t *event_table)
int	_pe_libpfm4_ntv_name_to_code (const char *ntv_name, unsigned int *EventCode, int cidx, struct native_event_table_t *event_table)
int	_pe_libpfm4_ntv_code_to_name (unsigned int EventCode, char *name, int len, struct native_event_table_t *event_table)
int	_pe_libpfm4_ntv_code_to_descr (unsigned int EventCode, char *name, int len, struct native_event_table_t *event_table)
int	_pe_libpfm4_shutdown (papi_vector_t *my_vector, struct native_event_table_t *event_table)
int	_pe_libpfm4_ntv_code_to_info (unsigned int EventCode, PAPI_event_info_t *info, struct native_event_table_t *event_table)
int	_pe_libpfm4_init (papi_vector_t *my_vector, int cidx, struct native_event_table_t *event_table, int pmu_type)
int	_peu_libpfm4_init (papi_vector_t *my_vector, int cidx, struct native_event_table_t *event_table, int pmu_type)

Function Documentation

_pe_libpfm4_init()

int _pe_libpfm4_init	(	papi_vector_t *	my_vector,
		int	cidx,
		struct native_event_table_t *	event_table,
		int	pmu_type
	)

Definition at line 1146 of file pe_libpfm4_events.c.

                         {
 
    int detected_pmus=0, found_default=0;
    int i;
    int j=0;
    unsigned int ncnt;
 
    pfm_err_t retval = PFM_SUCCESS;
    pfm_pmu_info_t pinfo;
    unsigned int strSize;
 
    /* allocate the native event structure */
    event_table->num_native_events=0;
    event_table->pmu_type=pmu_type;
 
    event_table->native_events=calloc(NATIVE_EVENT_CHUNK,
                    sizeof(struct native_event_t));
    if (event_table->native_events==NULL) {
        return PAPI_ENOMEM;
    }
 
    event_table->allocated_native_events=NATIVE_EVENT_CHUNK;
 
    /* Count number of present PMUs */
    detected_pmus=0;
    ncnt=0;
 
    /* init default pmu */
    /* need to init pinfo or pfmlib might complain */
    memset(&(event_table->default_pmu), 0, sizeof(pfm_pmu_info_t));
    event_table->default_pmu.size = sizeof(pfm_pmu_info_t);
    retval=pfm_get_pmu_info(0, &(event_table->default_pmu));
 
    SUBDBG("Prescan for aliases.\n");
    /* We have to see if we have aliases in there as separate PMUs, */
    /* we don't want both PMUs with all the events duplicated.      */
    /* For aliases, either is valid alone, but if both are present  */
    /* specify a preference in the code.                            */
    /* Alias: amd64_fam17h_zen1 over amd64_fam17h.                  */
    /* Alias flags are static ints global to this file.             */
    i=0;
    while(1) {
        memset(&pinfo,0,sizeof(pfm_pmu_info_t));
        pinfo.size = sizeof(pfm_pmu_info_t);
        retval=pfm_get_pmu_info(i, &pinfo);
 
        /* We're done if we hit an invalid PMU entry            */
        /* We can't check against PFM_PMU_MAX as that might not */
        /* match if libpfm4 is dynamically linked               */
 
        if (retval==PFM_ERR_INVAL) {
            break;
        }
 
        if ( (retval==PFM_SUCCESS) && (pinfo.name != NULL) &&
            (pmu_is_present_and_right_type(&pinfo,pmu_type)) &&
            (strcmp(pinfo.name,"amd64_fam17h_zen1") == 0) ) {
            amd64_fam17h_zen1_present = 1;
        }
        i++;
    } 
 
    SUBDBG("Detected pmus:\n");
    i=0;
    while(1) {
        memset(&pinfo,0,sizeof(pfm_pmu_info_t));
        pinfo.size = sizeof(pfm_pmu_info_t);
        retval=pfm_get_pmu_info(i, &pinfo);
 
        /* We're done if we hit an invalid PMU entry        */
        /* We can't check against PFM_PMU_MAX as that might not */
        /* match if libpfm4 is dynamically linked       */
 
        if (retval==PFM_ERR_INVAL) {
            break;
        }
 
        if ((retval==PFM_SUCCESS) && (pinfo.name != NULL) &&
            (pmu_is_present_and_right_type(&pinfo,pmu_type))) {
 
            /* skip if it is amd64_fam17h and zen1 is also present. */
            if (strcmp(pinfo.name,"amd64_fam17h") == 0 && amd64_fam17h_zen1_present) {
                i++;
                continue;
            }
 
            SUBDBG("\t%d %s %s %d\n",i,
                pinfo.name,pinfo.desc,pinfo.type);
 
            detected_pmus++;
            ncnt+=pinfo.nevents;
 
            if (j < PAPI_PMU_MAX) {
                component->cmp_info.pmu_names[j++] =
                            strdup(pinfo.name);
            }
 
            if (pmu_type & PMU_TYPE_CORE) {
 
                /* Hack to have "default core" PMU */
                if ( (pinfo.type==PFM_PMU_TYPE_CORE) &&
                    strcmp(pinfo.name,"ix86arch")) {
                        memcpy(&(event_table->default_pmu),
                            &pinfo,sizeof(pfm_pmu_info_t));
                        found_default++;
                }
 
                /* For ARM processors, */
                if ( (pinfo.type==PFM_PMU_TYPE_CORE) &&
                    ( _papi_hwi_system_info.hw_info.vendor >= PAPI_VENDOR_ARM_ARM)) {
                    if (strlen(_papi_hwi_system_info.hw_info.model_string) == 0) {
                        strSize = sizeof(_papi_hwi_system_info.hw_info.model_string);
                        strncpy( _papi_hwi_system_info.hw_info.model_string, pinfo.desc, strSize - 1);
                    }
                }
            }
 
            if (pmu_type==PMU_TYPE_UNCORE) {
                /* To avoid confusion, no "default" CPU for uncore */
                found_default=1;
            }
        }
        i++;
    }
    SUBDBG("%d native events detected on %d pmus\n",ncnt,detected_pmus);
 
    if (detected_pmus==0) {
        SUBDBG("Could not find any PMUs\n");
        return PAPI_ENOSUPP;
    }
 
    if (!found_default) {
        return PAPI_ECMP;
    }
 
    if (found_default>1) {
        return PAPI_ECOUNT;
    }
 
    component->cmp_info.num_native_events = ncnt;
 
    component->cmp_info.num_cntrs = event_table->default_pmu.num_cntrs+
                event_table->default_pmu.num_fixed_cntrs;
 
    SUBDBG( "num_counters: %d\n", component->cmp_info.num_cntrs );
 
    /* Setup presets, only if Component 0 and default core PMU */
    if ((cidx==0) && (found_default)) {
        retval = _papi_load_preset_table( (char *)event_table->default_pmu.name,
                event_table->default_pmu.pmu, cidx );
        if ( retval!=PAPI_OK ) {
            return PAPI_ENOEVNT;
        }
    }
 
    return PAPI_OK;
}

Here is the call graph for this function:

_pe_libpfm4_ntv_code_to_descr()

int _pe_libpfm4_ntv_code_to_descr	(	unsigned int	EventCode,
		char *	name,
		int	len,
		struct native_event_table_t *	event_table
	)

Definition at line 725 of file pe_libpfm4_events.c.

{
    SUBDBG("ENTER: EventCode: %#x, ntv_descr: %p, len: %d: event_table: %p\n", EventCode, ntv_descr, len, event_table);
 
    int eidx;
    int papi_event_code;
    char *mdesc;
    char *edesc;
 
    // get the attribute index for this papi event
    papi_event_code = _papi_hwi_get_papi_event_code();
 
    // a papi event code less than 0 is invalid, return error
    if (papi_event_code <= 0) {
        SUBDBG("EXIT: PAPI_ENOEVNT\n");
        return PAPI_ENOEVNT;
    }
 
    // find our native event table for this papi event code (search list backwards because it improves chances of finding it quickly)
    for (eidx=event_table->num_native_events-1 ; eidx>=0 ; eidx--) {
        SUBDBG("native_event[%d]: papi_event_code: %#x, libpfm4_idx: %#x\n", eidx, event_table->native_events[eidx].papi_event_code, event_table->native_events[eidx].libpfm4_idx);
        if ((papi_event_code == event_table->native_events[eidx].papi_event_code) && (EventCode == ((unsigned)event_table->native_events[eidx].libpfm4_idx))) {
            break;
        }
    }
 
    // if we did not find a match, return an error
    if (eidx < 0) {
        // If we did not find a match in our native event table, then the code passed in has not been
        // allocated yet  It should not be possible to get to this code.  The user has to call the papi
        // code_to_name api with a papi event code for a native event.  But the only way to get one of
        // those is to call either name_to_code or enum_cmp_events first.  When one of these calls is
        // done we allocate the event so it should always be there.
 
        SUBDBG("EXIT: PAPI_ENOEVNT\n");
        return PAPI_ENOEVNT;
    }
 
    edesc = event_table->native_events[eidx].event_description;
 
    // if it will not fit, return error
    if (strlen (edesc) >= (unsigned)len) {
        SUBDBG("EXIT: event name %s will not fit in buffer provided\n", edesc);
        return PAPI_EBUF;
    }
    strcpy (ntv_descr, edesc);
 
    // if this event had masks, also add their descriptions
    mdesc = event_table->native_events[eidx].mask_description;
    if ((mdesc != NULL)  &&  (strlen(mdesc) > 0)) {
        if ((strlen(edesc) + 8 + strlen(mdesc)) >= (unsigned)len) {
            SUBDBG("EXIT: Not enough room for event and mask descriptions: need: %u, have: %u", (unsigned)(strlen(edesc) + 8 + strlen(mdesc)), (unsigned)len);
            return PAPI_EBUF;
        }
        strcat (ntv_descr, ", masks:");
        strcat (ntv_descr, mdesc);
    }
 
    SUBDBG("EXIT: event description: %s\n", ntv_descr);
    return PAPI_OK;
}

Here is the call graph for this function:

_pe_libpfm4_ntv_code_to_info()

int _pe_libpfm4_ntv_code_to_info	(	unsigned int	EventCode,
		PAPI_event_info_t *	info,
		struct native_event_table_t *	event_table
	)

Definition at line 791 of file pe_libpfm4_events.c.

{
    SUBDBG("ENTER: EventCode: %#x, info: %p, event_table: %p\n", EventCode, info, event_table);
 
    int ret;
 
    // get the event name first
    if ((ret = _pe_libpfm4_ntv_code_to_name(EventCode, info->symbol, sizeof(info->symbol), event_table)) != PAPI_OK) {
        SUBDBG("EXIT: _pe_libpfm4_ntv_code_to_name returned: %d\n", ret);
        return PAPI_ENOEVNT;
    }
 
    if ((ret = _pe_libpfm4_ntv_code_to_descr(EventCode, info->long_descr, sizeof(info->long_descr), event_table)) != PAPI_OK) {
        SUBDBG("EXIT: _pe_libpfm4_ntv_code_to_descr returned: %d\n", ret);
        return PAPI_ENOEVNT;
    }
 
    SUBDBG("EXIT: EventCode: %#x, name: %s, desc: %s\n", EventCode, info->symbol, info->long_descr);
    return PAPI_OK;
}

Here is the caller graph for this function:

_pe_libpfm4_ntv_code_to_name()

int _pe_libpfm4_ntv_code_to_name	(	unsigned int	EventCode,
		char *	name,
		int	len,
		struct native_event_table_t *	event_table
	)

Definition at line 632 of file pe_libpfm4_events.c.

{
    SUBDBG("ENTER: EventCode: %#x, ntv_name: %p, len: %d, event_table: %p\n", EventCode, ntv_name, len, event_table);
 
    int eidx;
    int papi_event_code;
 
    // get the attribute index for this papi event
    papi_event_code = _papi_hwi_get_papi_event_code();
 
    // a papi event code less than 0 is invalid, return error
    if (papi_event_code <= 0) {
        SUBDBG("EXIT: PAPI_ENOEVNT\n");
        return PAPI_ENOEVNT;
    }
 
    // find our native event table for this papi event code (search list backwards because it improves chances of finding it quickly)
    for (eidx=event_table->num_native_events-1 ; eidx>=0 ; eidx--) {
        if ((papi_event_code == event_table->native_events[eidx].papi_event_code) && (EventCode == ((unsigned)event_table->native_events[eidx].libpfm4_idx))) {
            SUBDBG("Found native_event[%d]: papi_event_code: %#x, libpfm4_idx: %#x\n", eidx, event_table->native_events[eidx].papi_event_code, event_table->native_events[eidx].libpfm4_idx);
            break;
        }
    }
 
    // if we did not find a match, return an error
    if (eidx < 0) {
        // If we did not find a match in our native event table, then the code passed in has not been
        // allocated yet  It should not be possible to get to this code.  The user has to call the papi
        // code_to_name api with a papi event code for a native event.  But the only way to get one of
        // those is to call either name_to_code or enum_cmp_events first.  When one of these calls is
        // done we allocate the event so it should always be there.
 
        SUBDBG("EXIT: PAPI_ENOEVNT\n");
        return PAPI_ENOEVNT;
    }
 
    // if this event is defined by the default pmu, then use only the event name
    // if it is not defined by the default pmu, then use both the pmu name and event name
    char *ename;
    if ((event_table->default_pmu.name) && (strcmp(event_table->default_pmu.name, event_table->native_events[eidx].pmu) == 0)) {
        ename = event_table->native_events[eidx].base_name;
    } else {
        ename = event_table->native_events[eidx].pmu_plus_name;
    }
 
    // if it will not fit, return error
    if (strlen (ename) >= (unsigned)len) {
        SUBDBG("EXIT: event name %s will not fit in buffer provided\n", ename);
        return PAPI_EBUF;
    }
    strcpy (ntv_name, ename);
 
    // if this event had masks, also add their names
    char *mname = event_table->native_events[eidx].mask_string;
    if ((mname != NULL)  &&  (strlen(mname) > 0)) {
        if ((strlen(ename) + 8 + strlen(mname)) >= (unsigned)len) {
            SUBDBG("EXIT: Not enough room for event and mask descriptions: need: %u, have: %u", (unsigned)(strlen(ename) + 8 + strlen(mname)), (unsigned)len);
            return PAPI_EBUF;
        }
        strcat (ntv_name, ":");
        strcat (ntv_name, mname);
    }
 
    SUBDBG("EXIT: event name: %s\n", ntv_name);
    return PAPI_OK;
}

Here is the call graph for this function:

_pe_libpfm4_ntv_enum_events()

int _pe_libpfm4_ntv_enum_events	(	unsigned int *	EventCode,
		int	modifier,
		int	cidx,
		struct native_event_table_t *	event_table
	)

Definition at line 832 of file pe_libpfm4_events.c.

                                                             {
 
    SUBDBG("ENTER: PapiEventCode: %p, *PapiEventCode: %#x, modifier: %d, event_table: %p\n", PapiEventCode, *PapiEventCode, modifier, event_table);
 
    int code,ret, pnum;
    int max_umasks;
    char event_string[BUFSIZ];
    pfm_pmu_info_t pinfo;
    pfm_event_info_t einfo;
    struct native_event_t *our_event;
 
    /* return first event if so specified */
    if ( modifier == PAPI_ENUM_FIRST ) {
        attr_idx = 0;   // set so if they want attribute information, it will start with the first attribute
        code=get_first_event_next_pmu(-1, event_table->pmu_type);
       if (code < 0 ) {
           SUBDBG("EXIT: Invalid component first event code: %d\n", code);
          return code;
       }
 
        // get the event information from libpfm4 (must zero structure)
        memset( &einfo, 0, sizeof( pfm_event_info_t ));
        einfo.size = sizeof(pfm_event_info_t);
        if ((ret = pfm_get_event_info(code, PFM_OS_PERF_EVENT_EXT, &einfo)) != PFM_SUCCESS) {
            SUBDBG("EXIT: pfm_get_event_info returned: %d\n", ret);
            return PAPI_ENOIMPL;
        }
 
        // get the pmu information from libpfm4 (must zero structure)
        memset( &pinfo, 0, sizeof(pfm_pmu_info_t) );
        pinfo.size = sizeof(pfm_pmu_info_t);
        ret=pfm_get_pmu_info(einfo.pmu, &pinfo);
        if (ret!=PFM_SUCCESS) {
            SUBDBG("EXIT: pfm_get_pmu_info returned: %d\n", ret);
            return ret;
        }
 
        // build full event name
        sprintf (event_string, "%s::%s", pinfo.name, einfo.name);
        SUBDBG("code: %#x, pmu: %s, event: %s, event_string: %s\n", code, pinfo.name, einfo.name, event_string);
 
        // go allocate this event, need to create tables used by the get event info call that will probably follow
        if ((our_event = allocate_native_event(event_string, code, cidx, event_table)) == NULL) {
            // allocate may have created the event table but returned NULL to tell the caller the event string was invalid (attempt to encode it failed).
            // if the caller wants to use this event to count something, it will report an error
            // but if the caller is just interested in listing the event, then we need an event table with an event name and libpfm4 index
            int evt_idx;
            if ((evt_idx = find_existing_event(event_string, event_table)) < 0) {
                SUBDBG("EXIT: Allocating event: '%s' failed\n", event_string);
                return PAPI_ENOEVNT;
            }
 
            // give back the new event code
            *PapiEventCode = event_table->native_events[evt_idx].libpfm4_idx;
            SUBDBG("EXIT: event code: %#x\n", *PapiEventCode);
            return PAPI_OK;
        }
 
        *PapiEventCode = our_event->libpfm4_idx;
 
        SUBDBG("EXIT: *PapiEventCode: %#x\n", *PapiEventCode);
        return PAPI_OK;
    }
 
    /* Handle looking for the next event */
    if ( modifier == PAPI_ENUM_EVENTS ) {
        attr_idx = 0;   // set so if they want attribute information, it will start with the first attribute
 
        // get the next event code from libpfm4, if there are no more in this pmu find first event in next pmu
        if ((code = pfm_get_event_next(*PapiEventCode)) < 0) {
 
            // get this events information from libpfm4, we need the pmu number of the last event we processed (table must be cleared)
            memset( &einfo, 0, sizeof( pfm_event_info_t ));
            einfo.size = sizeof(pfm_event_info_t);
            if ((ret = pfm_get_event_info(*PapiEventCode, PFM_OS_PERF_EVENT_EXT, &einfo)) != PFM_SUCCESS) {
                SUBDBG("EXIT: pfm_get_event_info returned: %d\n", ret);
                return PAPI_ENOIMPL;
            }
            SUBDBG("*PapiEventCode: %#x, event: %s\n", *PapiEventCode, einfo.name);
 
            // get the pmu number of the last event
            pnum = einfo.pmu;
 
            SUBDBG("pnum: %d\n", pnum);
            code=get_first_event_next_pmu(pnum, event_table->pmu_type);
            if (code < 0) {
                SUBDBG("EXIT: No more PMUs to list, returning: %d\n", code);
                return code;
            }
        }
 
 
        // get the event information from libpfm4 (must zero structure)
        memset( &einfo, 0, sizeof( pfm_event_info_t ));
        einfo.size = sizeof(pfm_event_info_t);
        if ((ret = pfm_get_event_info(code, PFM_OS_PERF_EVENT_EXT, &einfo)) != PFM_SUCCESS) {
            SUBDBG("EXIT: pfm_get_event_info returned: %d\n", ret);
            return PAPI_ENOIMPL;
        }
 
        // get the pmu information from libpfm4 (must zero structure)
        memset( &pinfo, 0, sizeof(pfm_pmu_info_t) );
        pinfo.size = sizeof(pfm_pmu_info_t);
        ret=pfm_get_pmu_info(einfo.pmu, &pinfo);
        if (ret!=PFM_SUCCESS) {
            SUBDBG("EXIT: pfm_get_pmu_info returned: %d\n", ret);
            return ret;
        }
 
        // build full event name
        sprintf (event_string, "%s::%s", pinfo.name, einfo.name);
        SUBDBG("code: %#x, pmu: %s, event: %s, event_string: %s\n", code, pinfo.name, einfo.name, event_string);
 
        // go allocate this event, need to create tables used by the get event info call that will follow
        if ((our_event = allocate_native_event(event_string, code, cidx, event_table)) == NULL) {
            // allocate may have created the event table but returned NULL to tell the caller the event string was invalid (attempt to encode it failed).
            // if the caller wants to use this event to count something, it will report an error
            // but if the caller is just interested in listing the event, then we need an event table with an event name and libpfm4 index
            int evt_idx;
            if ((evt_idx = find_existing_event(event_string, event_table)) < 0) {
                SUBDBG("EXIT: Allocating event: '%s' failed\n", event_string);
                return PAPI_ENOEVNT;
            }
 
            // give back the new event code
            *PapiEventCode = event_table->native_events[evt_idx].libpfm4_idx;
            SUBDBG("EXIT: event code: %#x\n", *PapiEventCode);
            return PAPI_OK;
        }
 
        // give back the new event code
        *PapiEventCode = our_event->libpfm4_idx;
 
        SUBDBG("EXIT: *PapiEventCode: %#x\n", *PapiEventCode);
        return PAPI_OK;
    }
 
    /* We don't handle PAPI_NTV_ENUM_UMASK_COMBOS */
    if ( modifier == PAPI_NTV_ENUM_UMASK_COMBOS ) {
        SUBDBG("EXIT: do not support umask combos yet\n");
        return PAPI_ENOIMPL;
    } 
 
    /* Enumerate PAPI_NTV_ENUM_UMASKS (umasks on an event) */
    if ( modifier == PAPI_NTV_ENUM_UMASKS ) {
        // get this events information from libpfm4, we need the number of masks this event knows about (table must be cleared)
        memset( &einfo, 0, sizeof( pfm_event_info_t ));
        einfo.size = sizeof(pfm_event_info_t);
        if ((ret = pfm_get_event_info(*PapiEventCode, PFM_OS_PERF_EVENT_EXT, &einfo)) != PFM_SUCCESS) {
            SUBDBG("EXIT: pfm_get_event_info returned: %d\n", ret);
            return PAPI_ENOIMPL;
        }
//      SUBDBG("*PapiEventCode: %#x, einfo.name: %s, einfo.code: %#x, einfo.nattrs: %d\n", *PapiEventCode, einfo.name, einfo.code, einfo.nattrs);
 
        // set max number of masks
        max_umasks = einfo.nattrs;
 
        // if we reached last attribute, return error to show we are done with this events masks
        if (attr_idx == max_umasks) {
            SUBDBG("EXIT: already processed all umasks: attr_idx: %d\n", attr_idx);
            return PAPI_ENOEVNT;
        }
 
        // find the event table for this event, we need the pmu name and event name without any masks
        int ntv_idx = _papi_hwi_get_ntv_idx(_papi_hwi_get_papi_event_code());
        if (ntv_idx < 0) {
            SUBDBG("EXIT: _papi_hwi_get_ntv_idx returned: %d\n", ntv_idx);
            return ntv_idx;
        }
        char *ename = event_table->native_events[ntv_idx].pmu_plus_name;
        if ((ename == NULL)  ||  (strlen(ename) >= sizeof(event_string))) {
            SUBDBG("EXIT: Event name will not fit into buffer\n");
            return PAPI_EBUF;
        }
        strcpy (event_string, ename);
        SUBDBG("event_string: %s\n", event_string);
 
        // go get the attribute information for this event
        // libpfm4 likes the table cleared
        pfm_event_attr_info_t ainfo;
        memset (&ainfo, 0, sizeof(pfm_event_attr_info_t));
        ainfo.size = sizeof(pfm_event_attr_info_t);
        ret = pfm_get_event_attr_info(*PapiEventCode, attr_idx, PFM_OS_PERF_EVENT_EXT, &ainfo);
        if (ret != PFM_SUCCESS) {
            SUBDBG("EXIT: Attribute info not found, EventCode: %#x, attr_idx: %d, ret: %d\n", *PapiEventCode, attr_idx, _papi_libpfm4_error(ret));
            return _papi_libpfm4_error(ret);
        }
        SUBDBG("*PapiEventCode: %#x, attr_idx: %d, type: %d, name: %s, description: %s\n", *PapiEventCode, attr_idx, ainfo.type, ainfo.name, ainfo.desc);
 
        if (strlen(event_string) + strlen(ainfo.name) + 35 > sizeof(event_string)) {
            SUBDBG("EXIT: Event name and mask will not fit into buffer\n");
            return PAPI_EBUF;
        }
 
        strcat (event_string, ":");
        strcat (event_string, ainfo.name);
        switch (ainfo.type) {
            case PFM_ATTR_UMASK:
                break;
            case PFM_ATTR_MOD_BOOL:
            case PFM_ATTR_MOD_INTEGER:
                // a few attributes require a non-zero value to encode correctly (most would accept zero here)
                strcat(event_string,"=0");
                break;
            default:
                SUBDBG("EXIT: Unsupported attribute type: %d", ainfo.type);
                return PAPI_EATTR;
        }
 
        // go allocate this event, need to create tables used by the get event info call that will follow
        if ((our_event = allocate_native_event(event_string, *PapiEventCode, cidx, event_table)) == NULL) {
            // allocate may have created the event table but returned NULL to tell the caller the event string was invalid.
            // if the caller wants to use this event to count something, it must report the error
            // but if the caller is just interested in listing the event (like this code), then find the table that was created and return its libpfm4 index
            int evt_idx;
            if ((evt_idx = find_existing_event(event_string, event_table)) < 0) {
                SUBDBG("EXIT: Allocating event: '%s' failed\n", event_string);
                return PAPI_ENOEVNT;
            }
            // bump so next time we will use next attribute
            attr_idx++;
            // give back the new event code
            *PapiEventCode = event_table->native_events[evt_idx].libpfm4_idx;
            SUBDBG("EXIT: event code: %#x\n", *PapiEventCode);
            return PAPI_OK;
        }
 
        // bump so next time we will use next attribute
        attr_idx++;
 
        // give back the new event code
        *PapiEventCode = our_event->libpfm4_idx;
 
        SUBDBG("EXIT: event code: %#x\n", *PapiEventCode);
        return PAPI_OK;
    }
 
    /* Enumerate PAPI_NTV_ENUM_GROUPS (groups on an event) */
    if ( modifier == PAPI_NTV_ENUM_GROUPS ) {
        SUBDBG("EXIT: do not support enumerating groups in this component\n");
        return PAPI_ENOIMPL;
    }
 
    /* An unknown enumeration method was indicated */
 
    SUBDBG("EXIT: Invalid modifier argument provided\n");
    return PAPI_ENOIMPL;
}

Here is the call graph for this function:

_pe_libpfm4_ntv_name_to_code()

int _pe_libpfm4_ntv_name_to_code	(	const char *	ntv_name,
		unsigned int *	EventCode,
		int	cidx,
		struct native_event_table_t *	event_table
	)

Definition at line 582 of file pe_libpfm4_events.c.

{
  SUBDBG( "ENTER: name: %s, event_code: %p, *event_code: %#x, event_table: %p\n", name, event_code, *event_code, event_table);
 
  struct native_event_t *our_event;
  int event_num;
 
  // if we already know this event name, just return its native code
  event_num=find_existing_event(name, event_table);
  if (event_num >= 0) {
         *event_code=event_table->native_events[event_num].libpfm4_idx;
         // the following call needs to happen to prevent the internal layer from creating a new papi native event table
         _papi_hwi_set_papi_event_code(event_table->native_events[event_num].papi_event_code, 1);
         SUBDBG("EXIT: Found papi_event_code: %#x, libpfm4_idx: %#x\n", event_table->native_events[event_num].papi_event_code, event_table->native_events[event_num].libpfm4_idx);
         return PAPI_OK;
  }
 
     // Try to allocate this event to see if it is known by libpfm4, if allocate fails tell the caller it is not valid
     our_event=allocate_native_event(name, -1, cidx, event_table);
     if (our_event==NULL) {
         SUBDBG("EXIT: Allocating event: '%s' failed\n", name);
         return PAPI_ENOEVNT;
     }
 
     *event_code = our_event->libpfm4_idx;
     SUBDBG("EXIT: Found code: %#x\n",*event_code);
     return PAPI_OK;
}

Here is the call graph for this function:

_pe_libpfm4_setup_presets()

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

_pe_libpfm4_shutdown()

int _pe_libpfm4_shutdown	(	papi_vector_t *	my_vector,
		struct native_event_table_t *	event_table
	)

Definition at line 1095 of file pe_libpfm4_events.c.

                                                  {
  SUBDBG("ENTER: event_table: %p\n", event_table);
 
  int i;
 
  for (i=0 ; i<PAPI_PMU_MAX ; i++) {
      if (my_vector->cmp_info.pmu_names[i] != NULL) {
          free (my_vector->cmp_info.pmu_names[i]);
      }
  }
 
  /* clean out and free the native events structure */
  _papi_hwi_lock( NAMELIB_LOCK );
 
  /* free memory allocated with strdup or malloc */
  for( i=0; i<event_table->num_native_events; i++) {
     free(event_table->native_events[i].base_name);
     free(event_table->native_events[i].pmu_plus_name);
     free(event_table->native_events[i].pmu);
     free(event_table->native_events[i].allocated_name);
     free(event_table->native_events[i].mask_string);
     free(event_table->native_events[i].event_description);
     if (event_table->native_events[i].mask_description != NULL) {
          free(event_table->native_events[i].mask_description);
     }
  }
 
  free(event_table->native_events);
 
  _papi_hwi_unlock( NAMELIB_LOCK );
 
  SUBDBG("EXIT: PAPI_OK\n");
  return PAPI_OK;
}

Here is the call graph for this function:

_peu_libpfm4_init()

int _peu_libpfm4_init	(	papi_vector_t *	my_vector,
		int	cidx,
		struct native_event_table_t *	event_table,
		int	pmu_type
	)

Definition at line 1318 of file pe_libpfm4_events.c.

                         {
 
   int detected_pmus=0;
   int i;
   int j=0;
   pfm_err_t retval = PFM_SUCCESS;
   unsigned int ncnt;
   pfm_pmu_info_t pinfo;
 
    (void)cidx;
 
   /* allocate the native event structure */
 
   event_table->num_native_events=0;
   event_table->pmu_type=pmu_type;
 
   event_table->native_events=calloc(NATIVE_EVENT_CHUNK,
                       sizeof(struct native_event_t));
   if (event_table->native_events==NULL) {
      return PAPI_ENOMEM;
   }
   event_table->allocated_native_events=NATIVE_EVENT_CHUNK;
 
   /* Count number of present PMUs */
   detected_pmus=0;
   ncnt=0;
 
   my_vector->cmp_info.num_cntrs=0;
 
   SUBDBG("Detected pmus:\n");
    i=0;
    while(1) {
      memset(&pinfo,0,sizeof(pfm_pmu_info_t));
      pinfo.size = sizeof(pfm_pmu_info_t);
      retval=pfm_get_pmu_info(i, &pinfo);
 
    /* We're done if we hit an invalid PMU entry                    */
    /* We can't check against PFM_PMU_MAX                           */
    /* as that might not match if libpfm4 is dynamically linked     */
 
    if (retval==PFM_ERR_INVAL) {
        break;
    }
 
    if ((retval==PFM_SUCCESS) && (pinfo.name != NULL) &&
        (pmu_is_present_and_right_type(&pinfo,pmu_type))) {
 
     SUBDBG("\t%d %s %s %d\n",i,pinfo.name,pinfo.desc,pinfo.type);
 
         detected_pmus++;
     ncnt+=pinfo.nevents;
 
     if ((j < PAPI_PMU_MAX) && (pinfo.name != NULL)) {
         my_vector->cmp_info.pmu_names[j++] = strdup(pinfo.name);
     }
         my_vector->cmp_info.num_cntrs += pinfo.num_cntrs+
                                   pinfo.num_fixed_cntrs;
      }
    i++;
   }
   SUBDBG("%d native events detected on %d pmus\n",ncnt,detected_pmus);
 
   my_vector->cmp_info.num_native_events = ncnt;
 
   SUBDBG( "num_counters: %d\n", my_vector->cmp_info.num_cntrs );
 
   return PAPI_OK;
}

Here is the call graph for this function: