cupti_profiler.h File Reference

Include dependency graph for cupti_profiler.h:

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

Go to the source code of this file.

Functions
int	cuptip_init (void)
int	cuptip_control_create (cuptiu_event_table_t *event_names, cuptic_info_t thr_info, cuptip_control_t *pstate)
int	cuptip_control_destroy (cuptip_control_t *pstate)
int	cuptip_control_start (cuptip_control_t state)
int	cuptip_control_stop (cuptip_control_t state)
int	cuptip_control_read (cuptip_control_t state, long long *values)
int	cuptip_control_reset (cuptip_control_t state)
int	cuptip_event_enum (cuptiu_event_table_t *all_evt_names)
int	cuptip_event_name_to_descr (const char *evt_name, char *description)
int	cuptip_shutdown (void)

Detailed Description

Author

Anustuv Pal anust.nosp@m.uv@i.nosp@m.cl.ut.nosp@m.k.ed.nosp@m.u

Definition in file cupti_profiler.h.

Function Documentation

cuptip_control_create()

int cuptip_control_create	(	cuptiu_event_table_t *	event_names,
		cuptic_info_t	thr_info,
		cuptip_control_t *	pstate
	)

Definition at line 1425 of file cupti_profiler.c.

{
    COMPDBG("Entering.\n");
    int papi_errno = PAPI_OK, gpu_id;
    cuptip_control_t state = (cuptip_control_t) papi_calloc (1, sizeof(struct cuptip_control_s));
    if (state == NULL) {
        return PAPI_ENOMEM;
    }
    state->gpu_ctl = (cuptip_gpu_state_t *) papi_calloc(num_gpus, sizeof(cuptip_gpu_state_t));
    if (state->gpu_ctl == NULL) {
        return PAPI_ENOMEM;
    }
    for (gpu_id = 0; gpu_id < num_gpus; gpu_id++) {
        state->gpu_ctl[gpu_id].gpu_id = gpu_id;
    }
 
    /* Register the user created cuda context for the current gpu if not already known */
    papi_errno = cuptic_ctxarr_update_current(thr_info);
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
    papi_errno = nvpw_cuda_metricscontext_create(state);
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
    papi_errno = add_events_per_gpu(state, event_names);
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
    papi_errno = control_state_validate(state);
    state->info = thr_info;
 
fn_exit:
    *pstate = state;
    return papi_errno;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cuptip_control_destroy()

int cuptip_control_destroy

(

cuptip_control_t *

pstate

)

Definition at line 1462 of file cupti_profiler.c.

{
    COMPDBG("Entering.\n");
    cuptip_control_t state = *pstate;
    int i, j;
    int papi_errno = nvpw_cuda_metricscontext_destroy(state);
    for (i = 0; i < num_gpus; i++) {
        reset_cupti_prof_config_images( &(state->gpu_ctl[i]) );
        cuptiu_event_table_destroy( &(state->gpu_ctl[i].event_names) );
        for (j = 0; j < state->gpu_ctl[i].rmr_count; j++) {
            papi_free((void *) state->gpu_ctl[i].rmr[j].pMetricName);
        }
        papi_free(state->gpu_ctl[i].rmr);
    }
    papi_free(state->gpu_ctl);
    papi_free(state);
    *pstate = NULL;
    return papi_errno;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cuptip_control_read()

int cuptip_control_read	(	cuptip_control_t	state,
		long long *	values
	)

Definition at line 1599 of file cupti_profiler.c.

{
    COMPDBG("Entering.\n");
    int papi_errno, gpu_id, i;
    cuptip_gpu_state_t *gpu_ctl = NULL;
    CUcontext userCtx = NULL, ctx = NULL;
    CUDA_CALL( cuCtxGetCurrentPtr(&userCtx), goto fn_fail_misc);
    if (userCtx == NULL) {
        CUDART_CALL( cudaFreePtr(NULL), goto fn_fail_misc );
        CUDART_CALL( cuCtxGetCurrentPtr(&userCtx), goto fn_fail_misc );
    }
    unsigned int evt_pos;
    long long val;
    cuptiu_event_t *evt_rec = NULL;
    for (gpu_id = 0; gpu_id < num_gpus; gpu_id++) {
        gpu_ctl = &(state->gpu_ctl[gpu_id]);
        if (gpu_ctl->event_names->count == 0) {
            continue;
        }
 
        papi_errno = cuptic_ctxarr_get_ctx(state->info, gpu_id, &ctx);
        CUDA_CALL( cuCtxSetCurrentPtr(ctx), goto fn_fail_misc );
 
        CUpti_Profiler_PopRange_Params popRangeParams = {
            .structSize = CUpti_Profiler_PopRange_Params_STRUCT_SIZE,
            .pPriv = NULL,
            .ctx = NULL,
        };
        CUPTI_CALL( cuptiProfilerPopRangePtr(&popRangeParams), goto fn_fail_misc );
 
        CUpti_Profiler_EndPass_Params endPassParams = {
            .structSize = CUpti_Profiler_EndPass_Params_STRUCT_SIZE,
            .pPriv = NULL,
            .ctx = NULL,
        };
        CUPTI_CALL( cuptiProfilerEndPassPtr(&endPassParams), goto fn_fail_misc );
 
        CUpti_Profiler_FlushCounterData_Params flushCounterDataParams = {
            .structSize = CUpti_Profiler_FlushCounterData_Params_STRUCT_SIZE,
            .pPriv = NULL,
            .ctx = NULL,
        };
        CUPTI_CALL( cuptiProfilerFlushCounterDataPtr(&flushCounterDataParams), goto fn_fail_misc );
 
        papi_errno = get_measured_values(gpu_ctl);
        if (papi_errno != PAPI_OK) {
            goto fn_exit;
        }
        for (i = 0; i < (int) gpu_ctl->event_names->count; i++) {
            papi_errno = cuptiu_event_table_get_item(gpu_ctl->event_names, i, &evt_rec);
            if (papi_errno != PAPI_OK) {
                goto fn_exit;
            }
            evt_pos = evt_rec->evt_pos;
            val = (long long) evt_rec->value;
 
            if (state->read_count == 0) {
                values[evt_pos] = val;
            }
            else {
                switch (get_event_collection_method(evt_rec->name)) {
                    case RunningSum:
                        values[evt_pos] += val;
                        break;
                    case RunningMin:
                        values[evt_pos] = values[evt_pos] < val ? values[evt_pos] : val;
                        break;
                    case RunningMax:
                        values[evt_pos] = values[evt_pos] > val ? values[evt_pos] : val;
                        break;
                    default:
                        values[evt_pos] = val;
                        break;
                }
            }
        }
 
        CUPTI_CALL( cuptiProfilerCounterDataImageInitializePtr(&gpu_ctl->initializeParams), goto fn_fail_misc );
        CUPTI_CALL( cuptiProfilerCounterDataImageInitializeScratchBufferPtr(&gpu_ctl->initScratchBufferParams), goto fn_fail_misc );
 
        CUpti_Profiler_BeginPass_Params beginPassParams = {
            .structSize = CUpti_Profiler_BeginPass_Params_STRUCT_SIZE,
            .pPriv = NULL,
            .ctx = NULL,
        };
        CUPTI_CALL( cuptiProfilerBeginPassPtr(&beginPassParams), goto fn_fail_misc );
 
        char rangeName[64];
        sprintf(rangeName, "PAPI_Range_%d", gpu_ctl->gpu_id);
        CUpti_Profiler_PushRange_Params pushRangeParams = {
            .structSize = CUpti_Profiler_PushRange_Params_STRUCT_SIZE,
            .pPriv = NULL,
            .ctx = NULL,
            .pRangeName = (const char*) &rangeName,
            .rangeNameLength = 100,
        };
        CUPTI_CALL( cuptiProfilerPushRangePtr(&pushRangeParams), goto fn_fail_misc );
 
    }
    state->read_count++;
fn_exit:
    CUDA_CALL( cuCtxSetCurrentPtr(userCtx), );
    return papi_errno;
fn_fail_misc:
    papi_errno = PAPI_EMISC;
    goto fn_exit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cuptip_control_reset()

int cuptip_control_reset

(

cuptip_control_t

state

)

Definition at line 1707 of file cupti_profiler.c.

{
    COMPDBG("Entering.\n");
    state->read_count = 0;
    return PAPI_OK;
}

Here is the caller graph for this function:

cuptip_control_start()

int cuptip_control_start

(

cuptip_control_t

state

)

Definition at line 1482 of file cupti_profiler.c.

{
    COMPDBG("Entering.\n");
    cuptip_gpu_state_t *gpu_ctl;
    CUcontext userCtx, ctx;
    CUDA_CALL( cuCtxGetCurrentPtr(&userCtx), goto fn_fail_misc );
    if (userCtx == NULL) {
        CUDART_CALL( cudaFreePtr(NULL), goto fn_fail_misc );
        CUDA_CALL( cuCtxGetCurrentPtr(&userCtx), goto fn_fail_misc );
    }
    int gpu_id;
    int papi_errno = PAPI_OK;
    for (gpu_id = 0; gpu_id < num_gpus; gpu_id++) {
        gpu_ctl = &(state->gpu_ctl[gpu_id]);
        if (gpu_ctl->event_names->count == 0) {
            continue;
        }
        LOGDBG("Device num %d: event_count %d, rmr count %d\n", gpu_id, gpu_ctl->event_names->count, gpu_ctl->rmr_count);
        papi_errno = cuptic_device_acquire(state->gpu_ctl[gpu_id].event_names);
        if (papi_errno != PAPI_OK) {
            ERRDBG("Profiling same gpu from multiple event sets not allowed.\n");
            return papi_errno;
        }
        papi_errno = cuptic_ctxarr_get_ctx(state->info, gpu_id, &ctx);
        CUDA_CALL( cuCtxSetCurrentPtr(ctx), goto fn_fail_misc );
        papi_errno = get_counter_availability(gpu_ctl);
        if (papi_errno != PAPI_OK) {
            ERRDBG("Error getting counter availability image.\n");
            return papi_errno;
        }
        /* CUPTI profiler host configuration */
        papi_errno = metric_get_config_image(gpu_ctl);
        papi_errno += metric_get_counter_data_prefix_image(gpu_ctl);
        papi_errno += create_counter_data_image(gpu_ctl);
        if (papi_errno != PAPI_OK) {
            ERRDBG("Failed to create CUPTI profiler state for gpu %d\n", gpu_id);
            goto fn_fail;
        }
        papi_errno = begin_profiling(gpu_ctl);
        if (papi_errno != PAPI_OK) {
            ERRDBG("Failed to start profiling for gpu %d\n", gpu_id);
            goto fn_fail;
        }
    }
    state->running = True;
fn_exit:
    CUDA_CALL( cuCtxSetCurrentPtr(userCtx), goto fn_fail_misc );
    return papi_errno;
fn_fail:
    papi_errno = PAPI_ECMP;
    goto fn_exit;
fn_fail_misc:
    papi_errno = PAPI_EMISC;
    goto fn_exit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cuptip_control_stop()

int cuptip_control_stop

(

cuptip_control_t

state

)

Definition at line 1538 of file cupti_profiler.c.

{
    COMPDBG("Entering.\n");
    cuptip_gpu_state_t *gpu_ctl;
    CUcontext userCtx = NULL, ctx = NULL;
    CUDA_CALL( cuCtxGetCurrentPtr(&userCtx), goto fn_fail_misc );
    if (userCtx == NULL) {
        CUDART_CALL( cudaFreePtr(NULL), goto fn_fail_misc );
        CUDA_CALL( cuCtxGetCurrentPtr(&userCtx), goto fn_fail_misc );
    }
    int gpu_id;
    int papi_errno = PAPI_OK;
    if (state->running == False) {
        ERRDBG("Profiler is already stopped.\n");
        papi_errno = PAPI_EINVAL;
        goto fn_fail;
    }
    for (gpu_id=0; gpu_id<num_gpus; gpu_id++) {
        gpu_ctl = &(state->gpu_ctl[gpu_id]);
        if (gpu_ctl->event_names->count == 0) {
            continue;
        }
        papi_errno = cuptic_ctxarr_get_ctx(state->info, gpu_id, &ctx);
        CUDA_CALL( cuCtxSetCurrentPtr(ctx), goto fn_fail_misc );
        papi_errno = end_profiling(gpu_ctl);
        if (papi_errno != PAPI_OK) {
            ERRDBG("Failed to stop profiling on gpu %d\n", gpu_id);
            goto fn_fail;
        }
        papi_errno = cuptic_device_release(state->gpu_ctl[gpu_id].event_names);
        if (papi_errno != PAPI_OK) {
            goto fn_fail;
        }
    }
    state->running = False;
fn_exit:
    CUDA_CALL( cuCtxSetCurrentPtr(userCtx), goto fn_fail_misc );
    return papi_errno;
fn_fail:
    goto fn_exit;
fn_fail_misc:
    papi_errno = PAPI_EMISC;
    goto fn_exit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cuptip_event_enum()

int cuptip_event_enum

(

cuptiu_event_table_t *

all_evt_names

)

Definition at line 1206 of file cupti_profiler.c.

{
    int gpu_id, i, found, listsubmetrics = 1, papi_errno = PAPI_OK;
    if (avail_events[0].nv_metrics != NULL) {
        /* Already eumerated for 1st device? Then exit... */
        goto fn_exit;
    }
    for (gpu_id = 0; gpu_id < num_gpus; gpu_id++) {
        LOGDBG("Getting metric names for gpu %d\n", gpu_id);
        found = find_same_chipname(gpu_id);
        if (found > -1) {
            avail_events[gpu_id].num_metrics = avail_events[found].num_metrics;
            avail_events[gpu_id].nv_metrics = avail_events[found].nv_metrics;
            continue;
        }
        /* If same chip_name not found, get all the details for this gpu */
 
        NVPW_MetricsContext_GetMetricNames_Begin_Params getMetricNameBeginParams = {
            .structSize = NVPW_MetricsContext_GetMetricNames_Begin_Params_STRUCT_SIZE,
            .pPriv = NULL,
            .pMetricsContext = avail_events[gpu_id].pmetricsContextCreateParams->pMetricsContext,
            .hidePeakSubMetrics = !listsubmetrics,
            .hidePerCycleSubMetrics = !listsubmetrics,
            .hidePctOfPeakSubMetrics = !listsubmetrics,
        };
        NVPW_CALL( NVPW_MetricsContext_GetMetricNames_BeginPtr(&getMetricNameBeginParams), goto fn_fail );
 
        avail_events[gpu_id].num_metrics = getMetricNameBeginParams.numMetrics;
 
        papi_errno = cuptiu_event_table_create_init_capacity(avail_events[gpu_id].num_metrics, sizeof(cuptiu_event_t), &(avail_events[gpu_id].nv_metrics));
        if (papi_errno != PAPI_OK) {
            goto fn_exit;
        }
        for (i = 0; i < avail_events[gpu_id].num_metrics; i++) {
            papi_errno = cuptiu_event_table_insert_record(avail_events[gpu_id].nv_metrics,
                                      getMetricNameBeginParams.ppMetricNames[i],
                                      i, 0);
            if (papi_errno != PAPI_OK) {
                goto fn_exit;
            }
        }
 
        NVPW_MetricsContext_GetMetricNames_End_Params getMetricNameEndParams = {
            .structSize = NVPW_MetricsContext_GetMetricNames_End_Params_STRUCT_SIZE,
            .pPriv = NULL,
            .pMetricsContext = avail_events[gpu_id].pmetricsContextCreateParams->pMetricsContext,
        };
        NVPW_CALL( NVPW_MetricsContext_GetMetricNames_EndPtr((NVPW_MetricsContext_GetMetricNames_End_Params *) &getMetricNameEndParams), goto fn_fail );
 
    }
    char evt_name[PAPI_2MAX_STR_LEN];
    cuptiu_event_t *find = NULL;
    cuptiu_event_t *evt_rec = NULL;
    int len;
    unsigned int curr = all_evt_names->count;
    for (gpu_id = 0; gpu_id < num_gpus; gpu_id++) {
        for (i = 0; i < avail_events[gpu_id].num_metrics; i++) {
            papi_errno = cuptiu_event_table_get_item(avail_events[gpu_id].nv_metrics, i, &evt_rec);
            if (papi_errno != PAPI_OK) {
                goto fn_exit;
            }
            len = snprintf(evt_name, PAPI_2MAX_STR_LEN, "%s:device=%d", evt_rec->name, gpu_id);
            if (len > PAPI_2MAX_STR_LEN) {
                ERRDBG("String formatting exceeded maximum length.\n");
                papi_errno = PAPI_ENOMEM;
                goto fn_exit;
            }
            if (cuptiu_event_table_find_name(all_evt_names, evt_name, &find) == PAPI_ENOEVNT) {
                papi_errno = cuptiu_event_table_insert_record(all_evt_names, evt_name, curr, 0);
                if (papi_errno != PAPI_OK) {
                    goto fn_exit;
                }
                ++curr;
            }
        }
    }
fn_exit:
    return papi_errno;
fn_fail:
    papi_errno = PAPI_EMISC;
    goto fn_exit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cuptip_event_name_to_descr()

int cuptip_event_name_to_descr	(	const char *	evt_name,
		char *	description
	)

Definition at line 1289 of file cupti_profiler.c.

{
    int papi_errno, numdep, gpu_id, passes;
    char nv_name[PAPI_MAX_STR_LEN];
    cuptiu_event_t *evt_rec = NULL;
    NVPA_RawMetricRequest *temp;
    papi_errno = event_name_tokenize(evt_name, nv_name, &gpu_id);
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
    papi_errno = cuptiu_event_table_find_name(avail_events[gpu_id].nv_metrics, nv_name, &evt_rec);
    if (papi_errno != PAPI_OK) {
        ERRDBG("Event name not found in avail_events array.\n");
        goto fn_exit;
    }
    char *desc = evt_rec->desc;
    if (desc[0] == '\0') {
        papi_errno = retrieve_metric_details(avail_events[gpu_id].pmetricsContextCreateParams->pMetricsContext,
                                             nv_name, desc, &numdep, &temp);
        if (papi_errno == PAPI_OK) {
            NVPW_CUDA_RawMetricsConfig_Create_Params nvpw_metricsConfigCreateParams = {
                .structSize = NVPW_CUDA_RawMetricsConfig_Create_Params_STRUCT_SIZE,
                .pPriv = NULL,
                .activityKind = NVPA_ACTIVITY_KIND_PROFILER,
                .pChipName = avail_events[gpu_id].chip_name,
            };
            NVPW_CALL( NVPW_CUDA_RawMetricsConfig_CreatePtr(&nvpw_metricsConfigCreateParams), goto fn_fail );
 
            papi_errno = check_num_passes(nvpw_metricsConfigCreateParams.pRawMetricsConfig,
                                   numdep, temp, &passes);
 
            NVPW_RawMetricsConfig_Destroy_Params rawMetricsConfigDestroyParams = {
                .structSize = NVPW_RawMetricsConfig_Destroy_Params_STRUCT_SIZE,
                .pPriv = NULL,
                .pRawMetricsConfig = nvpw_metricsConfigCreateParams.pRawMetricsConfig,
            };
            NVPW_CALL( NVPW_RawMetricsConfig_DestroyPtr((NVPW_RawMetricsConfig_Destroy_Params *) &rawMetricsConfigDestroyParams), goto fn_fail );
 
            snprintf(desc + strlen(desc), PAPI_2MAX_STR_LEN - strlen(desc), " Numpass=%d", passes);
            if (passes > 1) {
                snprintf(desc + strlen(desc), PAPI_2MAX_STR_LEN - strlen(desc), " (multi-pass not supported)");
            }
 
            const char *token_sw_evt = "sass";
            if (strstr(nv_name, token_sw_evt) != NULL) {
                snprintf(desc + strlen(desc), PAPI_2MAX_STR_LEN - strlen(desc), " (SW event)");
            }
        }
        papi_free(temp);
    }
    strcpy(description, desc);
fn_exit:
    return papi_errno;
fn_fail:
    papi_errno = PAPI_EMISC;
    goto fn_exit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cuptip_init()

int cuptip_init

(

void

)

Definition at line 1383 of file cupti_profiler.c.

{
    COMPDBG("Entering.\n");
    int papi_errno = PAPI_OK;
 
    papi_errno = load_cupti_perf_sym();
    papi_errno += load_nvpw_sym();
    if (papi_errno != PAPI_OK) {
        cuptic_disabled_reason_set("Unable to load CUDA library functions.");
        goto fn_fail;
    }
 
    papi_errno = cuptic_device_get_count(&num_gpus);
    if (papi_errno != PAPI_OK) {
        goto fn_fail;
    }
 
    if (num_gpus <= 0) {
        cuptic_disabled_reason_set("No GPUs found on system.");
        goto fn_fail;
    }
 
    papi_errno = initialize_cupti_profiler_api();
    papi_errno += initialize_perfworks_api();
    if (papi_errno != PAPI_OK) {
        cuptic_disabled_reason_set("Unable to initialize CUPTI profiler libraries.");
        goto fn_fail;
    }
    papi_errno = init_all_metrics();
    if (papi_errno != PAPI_OK) {
        goto fn_fail;
    }
    papi_errno = cuInitPtr(0);
    if (papi_errno != CUDA_SUCCESS) {
        cuptic_disabled_reason_set("Failed to initialize CUDA driver API.");
        goto fn_fail;
    }
    return PAPI_OK;
fn_fail:
    return PAPI_EMISC;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cuptip_shutdown()

int cuptip_shutdown

(

void

)

Definition at line 1714 of file cupti_profiler.c.

{
    COMPDBG("Entering.\n");
    free_all_enumerated_metrics();
    finalize_cupti_profiler_api();
    unload_nvpw_sym();
    unload_cupti_perf_sym();
    return PAPI_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function: