linux_intel_gpu_metrics.c File Reference

Include dependency graph for linux_intel_gpu_metrics.c:

Go to the source code of this file.

Macros
#define	DEFAULT_LOOPS   0
#define	DEFAULT_MODE   METRIC_SUMMARY
#define	GPUDEBUG   SUBDBG

Functions
void	parseMetricName (const char *metricName, int *devnum, int *tilenum)
	Parser a metric name with qualifiers metricName can be component:::metrcGroup.metricname:device=xx:tile=yy or metrcGroup.metricname:device=xx:tile=yy.
DEVICE_HANDLE	getHandle (uint32_t device_code)
	Get handle from device code.
int	addMetricToDevice (uint32_t code, int rootDev)
	Add a metrics to a certain metric device.
static int	intel_gpu_init_thread (hwd_context_t *ctx)
static int	intel_gpu_init_component (int cidx)
static int	intel_gpu_init_control_state (hwd_control_state_t *ctl)
	Setup a counter control state. In general a control state holds the hardware info for an EventSet.
static int	intel_gpu_update_control_state (hwd_control_state_t *ctl, NativeInfo_t *native, int count, hwd_context_t *ctx)
static int	intel_gpu_start (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	intel_gpu_stop (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	intel_gpu_read (hwd_context_t *ctx, hwd_control_state_t *ctl, long long **events, int flags)
static int	intel_gpu_shutdown_thread (hwd_context_t *ctx)
static int	intel_gpu_shutdown_component (void)
static int	intel_gpu_reset (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	intel_gpu_ctl (hwd_context_t *ctx, int code, _papi_int_option_t *option)
static int	intel_gpu_set_domain (hwd_control_state_t *ctl, int domain)
static int	intel_gpu_ntv_enum_events (uint32_t *EventCode, int modifier)
static int	intel_gpu_ntv_code_to_name (uint32_t EventCode, char *name, int len)
static int	intel_gpu_ntv_code_to_descr (uint32_t EventCode, char *desc, int len)
static int	intel_gpu_ntv_name_to_code (const char *name, uint32_t *event_code)
static int	intel_gpu_ntv_code_to_info (uint32_t EventCode, PAPI_event_info_t *info)

Variables
static uint32_t	num_avail_devices = 0
static DEVICE_HANDLE *	avail_devices
static uint32_t	num_active_devices = 0
DeviceContext *	active_devices
static MetricInfo	metricInfoList
static int	total_metrics = 0
static int	global_metrics_type = TIME_BASED
papi_vector_t	_intel_gpu_vector

Macro Definition Documentation

DEFAULT_LOOPS

#define DEFAULT_LOOPS   0

Definition at line 37 of file linux_intel_gpu_metrics.c.

DEFAULT_MODE

#define DEFAULT_MODE   METRIC_SUMMARY

Definition at line 38 of file linux_intel_gpu_metrics.c.

GPUDEBUG

#define GPUDEBUG   SUBDBG

Definition at line 40 of file linux_intel_gpu_metrics.c.

Function Documentation

addMetricToDevice()

int addMetricToDevice	(	uint32_t	code,
		int	rootDev
	)

Definition at line 107 of file linux_intel_gpu_metrics.c.

                                              {
 
    int index = GetIdx(code);
    if  (index >= total_metrics) {
        return -1;
    }
    uint32_t group  = GetGroupIdx(metricInfoList.infoEntries[index].code);
    uint32_t metric = GetMetricIdx(metricInfoList.infoEntries[index].code);
    uint32_t devcode = GetDeviceCode(code);
    if (rootDev) {
        devcode = devcode & ~DMASK;
    }
    GPUDEBUG("addMetricToDevice, code 0x%x, group 0x%x,  metric 0x%x, devcode 0x%x\n",
          code, group, metric, devcode);
    uint32_t i=0;
    for (i=0; i<num_active_devices; i++)  {
        if  (active_devices[i].device_code == devcode) {
            if (active_devices[i].mgroup_code != group) {
                // conflict with existing metric group
                GPUDEBUG("intel_gpu: metrics from more than one group cannot be collected "
                        " in the same device at the same time. "
                        " Failed with return code 0x%x \n", PAPI_ENOSUPP);
                return -1;
            }
            break;
        }
    }
    if (i >= num_avail_devices) {
        GPUDEBUG("intel_gpu: invalid event code 0x%x\n", code);
        return -1;
    }
 
    DEVICE_HANDLE hd = getHandle(devcode);
    if (!hd) {
        GPUDEBUG("intel_gpu: Metric is not supported. For multi devices and/or multi-tiles GPUs, "
                "metric name should be qualified with :device=0 and/or :tile=0. "
                "Failed with return code 0x%x \n", PAPI_ENOSUPP);
        return -1;
    }
 
    // add a new device entry
    DeviceContext *dev = &(active_devices[i]);
    if (i==num_active_devices) {
        dev->device_code = devcode;
        dev->mgroup_code = group;
        dev->handle = hd;
        num_active_devices++;
    }
    // add a new metric to collect on this device
    dev->metric_code[dev->num_metrics++] = metric;
    return i;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getHandle()

DEVICE_HANDLE getHandle

(

uint32_t

device_code

)

Definition at line 93 of file linux_intel_gpu_metrics.c.

                                {
    uint32_t i=0;
    for (i=0; i<num_avail_devices; i++) {
        if (IsDeviceHandle(device_code, avail_devices[i])) {
           return avail_devices[i];
        }
    }
    return 0;
}

Here is the caller graph for this function:

intel_gpu_ctl()

static int intel_gpu_ctl ( hwd_context_t *  ctx, int  code, _papi_int_option_t *  option  )

static

Definition at line 542 of file linux_intel_gpu_metrics.c.

{
    GPUDEBUG("Entering intel_gpu_ctl\n");
 
    (void) ctx;
    (void) code;
    (void) option;
    return PAPI_OK;
}

intel_gpu_init_component()

static int intel_gpu_init_component ( int  cidx )

static

Definition at line 174 of file linux_intel_gpu_metrics.c.

{
    int retval = PAPI_OK;
    GPUDEBUG("Entering intel_init_component\n");
    if (cidx < 0) {
        return  PAPI_EINVAL;
    }
    char *errStr = NULL;
    memset(_intel_gpu_vector.cmp_info.disabled_reason, 0, PAPI_MAX_STR_LEN);
 
    if (putenv("ZET_ENABLE_METRICS=1")) {
        errStr = "Set ZET_ENABLE_METRICS=1 failed. Cannot access GPU metrics. ";
        strncpy_se(_intel_gpu_vector.cmp_info.disabled_reason, PAPI_MAX_STR_LEN,
                   errStr, strlen(errStr));
        retval = PAPI_ENOSUPP;
        goto fn_fail;
    }
    if ( _dl_non_dynamic_init != NULL ) {
        errStr = "The intel_gpu component does not support statically linking of libc.";
        strncpy_se(_intel_gpu_vector.cmp_info.disabled_reason, PAPI_MAX_STR_LEN,
                   errStr, strlen(errStr));
        retval = PAPI_ENOSUPP;
        goto fn_fail;
    }
    if (GPUDetectDevice(&avail_devices, &num_avail_devices) || (num_avail_devices==0)) {
        errStr = "The intel_gpu component does not detect metrics device.";
        strncpy_se(_intel_gpu_vector.cmp_info.disabled_reason, PAPI_MAX_STR_LEN,
                   errStr, strlen(errStr));
        retval = PAPI_ENOSUPP;
        goto fn_fail;
    }
 
    DEVICE_HANDLE handle = avail_devices[0];
 
    char *envStr = NULL;
    envStr =  getenv(ENABLE_API_TRACING);
    if (envStr != NULL) {
       if (atoi(envStr) == 1) {
           global_metrics_type = EVENT_BASED;
       }
    }
 
    metricInfoList.numEntries = 0;
    if (GPUGetMetricList(handle, "", global_metrics_type, &metricInfoList)) {
        errStr = "The intel_gpu component failed on get all available metrics.";
        strncpy_se(_intel_gpu_vector.cmp_info.disabled_reason, PAPI_MAX_STR_LEN,
                   errStr, strlen(errStr));
        GPUFreeDevice(handle);
        retval = PAPI_ENOSUPP;
        goto fn_fail;
    }; 
    total_metrics = metricInfoList.numEntries;
    GPUDEBUG("total metrics %d\n", total_metrics);
 
    _intel_gpu_vector.cmp_info.num_native_events = metricInfoList.numEntries;
    _intel_gpu_vector.cmp_info.num_cntrs         = GPU_MAX_COUNTERS;
    _intel_gpu_vector.cmp_info.num_mpx_cntrs     = GPU_MAX_COUNTERS;
 
    /* Export the component id */
    _intel_gpu_vector.cmp_info.CmpIdx = cidx;
 
    active_devices = calloc(num_avail_devices, sizeof(DeviceContext));
    num_active_devices = 0;
 
  fn_exit:
    _papi_hwd[cidx]->cmp_info.disabled = retval;
    return retval;
  fn_fail:
    goto fn_exit;
}

Here is the call graph for this function:

intel_gpu_init_control_state()

static int intel_gpu_init_control_state ( hwd_control_state_t *  ctl )

static

Definition at line 250 of file linux_intel_gpu_metrics.c.

{
    GPUDEBUG("Entering intel_gpu_control_state\n");
 
    if (!ctl) {
        return PAPI_EINVAL;
    }
 
    MetricCtlState *mCtlSt = (MetricCtlState *)ctl;
    mCtlSt->metrics_type  = global_metrics_type;
 
    char *envStr = NULL;
    mCtlSt->interval = DEFAULT_SAMPLING_PERIOD;
    envStr =  getenv(METRICS_SAMPLING_PERIOD);
    if (envStr) {
        mCtlSt->interval = atoi(envStr);
        if (mCtlSt->interval < MINIMUM_SAMPLING_PERIOD) {
            mCtlSt->interval = DEFAULT_SAMPLING_PERIOD;
        }
    }
    // set default mode  (get aggragated value or average value overtime).
    mCtlSt->mode     = DEFAULT_MODE;
    mCtlSt->loops   = DEFAULT_LOOPS;
 
    return PAPI_OK;
}

intel_gpu_init_thread()

static int intel_gpu_init_thread ( hwd_context_t *  ctx )

static

Definition at line 164 of file linux_intel_gpu_metrics.c.

{
    GPUDEBUG("Entering intel_gpu_init_thread\n");
    MetricContext *mContext = (MetricContext *)ctx;
    mContext->active_devices = calloc(num_avail_devices, sizeof(uint32_t));
    return PAPI_OK;
}

intel_gpu_ntv_code_to_descr()

static int intel_gpu_ntv_code_to_descr ( uint32_t  EventCode, char *  desc, int  len  )

static

Definition at line 611 of file linux_intel_gpu_metrics.c.

{
    GPUDEBUG("Entering intel_gpu_ntv_code_to_descr\n");
    int  index = GetIdx(EventCode);
 
    if( ( index < 0 ) || ( index >= total_metrics ) || !desc || !len) {
        return PAPI_EINVAL;
    }
 
    memset(desc, 0, len);
    strncpy_se(desc, len, metricInfoList.infoEntries[index].desc, MAX_STR_LEN-1);
    return PAPI_OK;
}

Here is the call graph for this function:

intel_gpu_ntv_code_to_info()

static int intel_gpu_ntv_code_to_info ( uint32_t  EventCode, PAPI_event_info_t *  info  )

static

Definition at line 648 of file linux_intel_gpu_metrics.c.

{
    GPUDEBUG("Entering intel_gpu_ntv_code_to_info\n");
    int  index = GetIdx(EventCode);
    if( ( index < 0 ) || ( index >= total_metrics ) || !info) {
        return PAPI_EINVAL;
    }
 
    info->event_code = EventCode;
    strncpy_se(info->symbol, PAPI_HUGE_STR_LEN,
            metricInfoList.infoEntries[index].name, MAX_STR_LEN-1);
    // short description could be truncated due to the longer string size of metric name
    strncpy_se(info->short_descr, PAPI_MIN_STR_LEN,
           metricInfoList.infoEntries[index].name,
           strlen(metricInfoList.infoEntries[index].name));
    strncpy_se(info->long_descr, PAPI_HUGE_STR_LEN,
           metricInfoList.infoEntries[index].desc,  MAX_STR_LEN-1);
    info->component_index = _intel_gpu_vector.cmp_info.CmpIdx;
    return PAPI_OK;
}

Here is the call graph for this function:

intel_gpu_ntv_code_to_name()

static int intel_gpu_ntv_code_to_name ( uint32_t  EventCode, char *  name, int  len  )

static

Definition at line 595 of file linux_intel_gpu_metrics.c.

{
    GPUDEBUG("Entering intel_gpu_ntv_code_to_name\n");
    int  index = GetIdx(EventCode);
 
    if( ( index < 0 ) || ( index >= total_metrics ) || !name || !len ) {
        return PAPI_EINVAL;
    }
 
    memset(name, 0, len);
    strncpy_se(name,  len, metricInfoList.infoEntries[index].name, 
           strlen(metricInfoList.infoEntries[index].name));
    return PAPI_OK;
}

Here is the call graph for this function:

intel_gpu_ntv_enum_events()

static int intel_gpu_ntv_enum_events ( uint32_t *  EventCode, int  modifier  )

static

Definition at line 568 of file linux_intel_gpu_metrics.c.

{
    GPUDEBUG("Entering intel_gpu_ntv_enum_events\n");
    int index = 0;
 
    if (!EventCode)  {
        return PAPI_EINVAL;
    }
    switch ( modifier ) {
        case PAPI_ENUM_FIRST:
            *EventCode = 0;
            break;
        case PAPI_ENUM_EVENTS:
            index = GetIdx(*EventCode);
            uint32_t dev_code = GetDeviceCode(*EventCode);
            if ( (index < 0 ) || (index >= (total_metrics-1)) ) {
                return PAPI_ENOEVNT;
            }
            *EventCode = CreateIdxCode(dev_code, index+1);
            break;
        default:
            return PAPI_EINVAL;
    } 
    return PAPI_OK;
}

intel_gpu_ntv_name_to_code()

static int intel_gpu_ntv_name_to_code ( const char *  name, uint32_t *  event_code  )

static

Definition at line 626 of file linux_intel_gpu_metrics.c.

{
    GPUDEBUG("Entering intel_gpu_ntv_name_to_code\n");
    if( !name || !event_code) {
        return PAPI_EINVAL;
    }
 
   for (int i=0; i<total_metrics; i++) {
        if (strncmp(metricInfoList.infoEntries[i].name, name, 
             strlen(metricInfoList.infoEntries[i].name)) == 0) {
           int devnum   = 0;
           int tilenum = 0;
           parseMetricName(name, &devnum, &tilenum);
           uint32_t code = CreateDeviceCode(1, devnum, tilenum);
           *event_code = CreateIdxCode(code, i);
           return PAPI_OK;
        }
    }
    return PAPI_ENOEVNT;
}

Here is the call graph for this function:

intel_gpu_read()

static int intel_gpu_read ( hwd_context_t *  ctx, hwd_control_state_t *  ctl, long long **  events, int  flags  )

static

Definition at line 419 of file linux_intel_gpu_metrics.c.

{
    GPUDEBUG("Entering intel_gpu_read\n");
 
    (void)flags;
 
    MetricCtlState *mCtlSt = (MetricCtlState *)ctl;
    MetricContext *mContext = (MetricContext *)ctx;
    MetricData *reports = NULL;
    uint32_t numReports = 0;
    int ret = PAPI_OK;
 
    if (!events) {
        return PAPI_EINVAL;
    }
 
    if (mContext->num_metrics == 0) {
        GPUDEBUG("intel_gpu_read: no metric is selected\n");
        return PAPI_OK;
    }
    for (uint32_t i=0; i<mContext->num_devices; i++) {
        uint32_t dc_idx = mContext->active_devices[i];
        numReports = 0;
        if  (dc_idx >= num_active_devices) {
             continue;
        }
 
        DeviceContext *dc = &active_devices[dc_idx];
        DEVICE_HANDLE handle = dc->handle;
        reports = GPUReadMetricData(handle, mCtlSt->mode, &numReports);
 
        if (!reports) {
             GPUDEBUG("intel_gpu_read failed on device 0x%x\n", GetDeviceCode(handle));
             continue;
        } else if (!numReports) {
             GPUFreeMetricData(reports, numReports);
             GPUDEBUG("intel_gpu_read: no data available on device 0x%x\n", GetDeviceCode(handle));
             continue;
        }
 
        if (dc->data) {
            GPUFreeMetricData(dc->data, dc->num_reports);
        }
        /* take last report, it is expected the numReports is 1 */
        dc->data = &reports[numReports-1];
        dc->num_reports = numReports;
    }
    for (uint32_t i=0; i<mContext->num_metrics; i++) {
        uint32_t dc_idx = mContext->dev_ctx_idx[i];
        DeviceContext *dc = &(active_devices[dc_idx]);
        int index = GetIdx(mContext->metric_idx[i]);
        int start_idx = 0;
        if (!(dc->device_code &DMASK)) {  // root device
            uint32_t dc_sidx = GetSDev(mContext->metric_idx[i]);
            if (dc_sidx > 0) {
                dc_sidx--;  // zero index
            }
            if (dc_sidx < dc->data->numDataSets) {
                start_idx = dc->data->dataSetStartIdx[dc_sidx];
            } else {
               start_idx = -1;
            }
        }
        if ((start_idx < 0) || !dc->data  || !dc->num_reports) {
            mContext->metric_values[i] = 0;   // no data available
        } else {
            uint32_t midx = GetMetricIdx(metricInfoList.infoEntries[index].code)-1;
            if (!dc->data->dataEntries[midx].type) {
                mContext->metric_values[i] =
                    (long long)dc->data->dataEntries[start_idx + midx].value.ival;
            } else {
                mContext->metric_values[i] =
                    (long long)dc->data->dataEntries[start_idx + midx].value.fpval;
            }
        }
    }
 
    mContext->num_reports = numReports;
    *events = mContext->metric_values;
    return ret;
}

Here is the call graph for this function:

intel_gpu_reset()

static int intel_gpu_reset ( hwd_context_t *  ctx, hwd_control_state_t *  ctl  )

static

Definition at line 524 of file linux_intel_gpu_metrics.c.

{
 
    (void)ctl;
    GPUDEBUG("Entering intel_gpu_reset\n");
    MetricContext *mContext = (MetricContext *)ctx;
 
    for (uint32_t i=0; i<num_avail_devices; i++) {
        uint32_t dev_idx = mContext->active_devices[i];
        if  (dev_idx < num_active_devices) {
            DeviceContext *dev = &active_devices[dev_idx];
            GPUSetMetricControl(dev->handle, METRIC_RESET);
        }
    }
    return PAPI_OK;
}

Here is the call graph for this function:

intel_gpu_set_domain()

static int intel_gpu_set_domain ( hwd_control_state_t *  ctl, int  domain  )

static

Definition at line 554 of file linux_intel_gpu_metrics.c.

{
    GPUDEBUG("Entering intel_gpu_set_domain\n");
 
    if (!ctl) {
        return PAPI_EINVAL;
    }
    MetricCtlState *mCtlSt = (MetricCtlState *)ctl;
    mCtlSt->domain = domain;
    return PAPI_OK;
 
}

intel_gpu_shutdown_component()

static int intel_gpu_shutdown_component ( void  )

static

Definition at line 510 of file linux_intel_gpu_metrics.c.

{
    GPUDEBUG("Entering intel_gpu_shutdown_component\n");
    for (uint32_t i=0; i<num_avail_devices; i++) {
        DEVICE_HANDLE handle = avail_devices[i];
        GPUFreeDevice(handle);
    }
    return PAPI_OK;
}

Here is the call graph for this function:

intel_gpu_shutdown_thread()

static int intel_gpu_shutdown_thread ( hwd_context_t *  ctx )

static

Definition at line 502 of file linux_intel_gpu_metrics.c.

{
    (void)ctx;
    GPUDEBUG("Entering intel_gpu_shutdown_thread\n" );
    return PAPI_OK;
}

intel_gpu_start()

static int intel_gpu_start ( hwd_context_t *  ctx, hwd_control_state_t *  ctl  )

static

Definition at line 356 of file linux_intel_gpu_metrics.c.

{
    GPUDEBUG("Entering intel_gpu_start\n");
 
    MetricCtlState *mCtlSt = (MetricCtlState *)ctl;
    MetricContext *mContext = (MetricContext *)ctx;
 
    int  ret    = PAPI_OK;
    if (mContext->num_metrics == 0) {
        GPUDEBUG("intel_gpu_start : No metric selected, abort.\n");
        return PAPI_EINVAL;
    }
 
    char **metrics = calloc(mContext->num_metrics, sizeof(char *));
    if (!metrics) {
        GPUDEBUG("intel_gpu_start : insufficient memory, abort.\n");
        return PAPI_ENOMEM;
    }
 
    mContext->num_reports = 0;
 
    for (uint32_t i=0; i<mContext->num_devices; i++) {
        uint32_t dev_idx = mContext->active_devices[i];
        if (dev_idx >= num_active_devices) {
            ret = PAPI_ENOMEM;
            break;
        }
        DeviceContext *dev = &active_devices[dev_idx];
        DEVICE_HANDLE handle = dev->handle;
        if (GPUEnableMetricGroup(handle, "", dev->mgroup_code,
                mCtlSt->metrics_type, mCtlSt->interval, mCtlSt->loops)) {
            GPUDEBUG("intel_gpu_start on EnableMetrics failed, return 0x%x \n", PAPI_ENOSUPP);
            ret = PAPI_ENOMEM;
            break;
        }
    }
    return ret;
}

Here is the call graph for this function:

intel_gpu_stop()

static int intel_gpu_stop ( hwd_context_t *  ctx, hwd_control_state_t *  ctl  )

static

Definition at line 396 of file linux_intel_gpu_metrics.c.

{
    GPUDEBUG("Entering intel_gpu_stop\n");
 
    MetricContext *mContext = (MetricContext *)ctx;
    MetricCtlState *mCtlSt = (MetricCtlState *)ctl;
    int          ret    = PAPI_OK;
 
    for (uint32_t i=0; i<mContext->num_devices; i++) {
        uint32_t dev_idx = mContext->active_devices[i];
        if  (dev_idx < num_active_devices) {
            DeviceContext *dev = &active_devices[dev_idx];
            DEVICE_HANDLE handle = dev->handle;
            if (GPUDisableMetricGroup(handle, mCtlSt->metrics_type)) {
                GPUDEBUG("intel_gpu_stop : failed with ret %d\n", ret);
                ret = PAPI_EINVAL;
            }
        }
    }
    return ret;
}

Here is the call graph for this function:

intel_gpu_update_control_state()

static int intel_gpu_update_control_state ( hwd_control_state_t *  ctl, NativeInfo_t *  native, int  count, hwd_context_t *  ctx  )

static

Definition at line 278 of file linux_intel_gpu_metrics.c.

{
    GPUDEBUG("Entering intel_gpu_control_state\n");
    (void)ctl;
 
    // use local maintained context,
    if (!count ||!native)  {
        return PAPI_OK;
    }
 
    MetricContext *mContext = (MetricContext *)ctx;
 
#if defined(_DEBUG)
    for (int i=0; i<count; i++) {
         GPUDEBUG("\t i=%d, ni_event 0x%x,  ni_papi_code 0x%x, ni_position %d, ni_owners %d   \n", 
                i, native[i].ni_event, native[i].ni_papi_code, 
                native[i].ni_position, native[i].ni_owners);
    }
#endif
 
    uint32_t nmetrics = mContext->num_metrics;
    uint32_t midx = 0;
    int ni = 0;
    for (ni = 0; ni < count; ni++) {
       uint32_t index = native[ni].ni_event;
       // check whether this metric is in the list
       for (midx=0; midx<nmetrics; midx++) {
           if (mContext->metric_idx[midx] == index) {
               GPUDEBUG("metric code %d: already in the list, ignore\n", index); 
               break;
           }
       }
       if (midx < nmetrics) {
            //  already in the list
            continue;
       }
       // whether use root device or subdevice
       char *envStr = NULL;
       int useRootDevice = 1;
       envStr =  getenv(ENABLE_SUB_DEVICE);
       if (envStr != NULL) {
           useRootDevice = 0;
       }
       int idx = addMetricToDevice(index, useRootDevice);
       if (idx<0) {
           return PAPI_ENOSUPP;
       }
       mContext->metric_idx[nmetrics] = index;
       mContext->dev_ctx_idx[nmetrics] = idx;
       mContext->subdev_idx[nmetrics] = GetSDev(index);
       GPUDEBUG("add metric[%d] code 0x%x, in device[%d] (event subdev[%d])\n",
          nmetrics, mContext->metric_idx[nmetrics],
          mContext->dev_ctx_idx[nmetrics], mContext->subdev_idx[nmetrics]);
 
       uint32_t i = 0;
       for (i=0; i<mContext->num_devices; i++) {
           if (mContext->active_devices[i] == (uint32_t)idx) {
                // already in the list
                break;
           }
       }
       if (i == mContext->num_devices) {
           mContext->active_devices[i] = idx;
           mContext->num_devices++;
       }
       native[ni].ni_position = nmetrics;
       nmetrics++;
    }
    // add this metric
    mContext->num_metrics = nmetrics;
    return PAPI_OK;
}

Here is the call graph for this function:

parseMetricName()

void parseMetricName	(	const char *	metricName,
		int *	devnum,
		int *	tilenum
	)

Parameters

IN	metricName – metric name in the above format
OUT	devnum – device id
OUT	tilenum – tile id

Definition at line 66 of file linux_intel_gpu_metrics.c.

                                                                   {
    char     *name    = strdup(metricName);
    char     *ptr     = name;
    char     *param   = name;
    uint32_t  dnum    = 0;
    uint32_t  tnum    = 0;
 
    if ((*param != '\0') && (ptr=strstr(param, ":"))) {
        if ((ptr=strstr(param, ":device="))) {
            ptr += 8;
            dnum = atoi(ptr)+1;
        }
        if ((ptr=strstr(param, ":tile="))) {
            ptr += 6;
            tnum = atoi(ptr)+1;
        }
    }
    *devnum = (dnum)?dnum:1;
    *tilenum = (tnum)?tnum:0;  // default tile is 0 for root device
    free(name);
}

Here is the caller graph for this function:

Variable Documentation

_intel_gpu_vector

papi_vector_t _intel_gpu_vector

Definition at line 54 of file linux_intel_gpu_metrics.c.

active_devices

DeviceContext* active_devices

Definition at line 48 of file linux_intel_gpu_metrics.c.

avail_devices

DEVICE_HANDLE* avail_devices

static

Definition at line 44 of file linux_intel_gpu_metrics.c.

global_metrics_type

int global_metrics_type = TIME_BASED

static

Definition at line 52 of file linux_intel_gpu_metrics.c.

metricInfoList

MetricInfo metricInfoList

static

Definition at line 50 of file linux_intel_gpu_metrics.c.

num_active_devices

uint32_t num_active_devices = 0

static

Definition at line 47 of file linux_intel_gpu_metrics.c.

num_avail_devices

uint32_t num_avail_devices = 0

static

Definition at line 43 of file linux_intel_gpu_metrics.c.

total_metrics

int total_metrics = 0

static

Definition at line 51 of file linux_intel_gpu_metrics.c.