linux-cuda.c File Reference

This file implements a PAPI component that enables PAPI-C to access hardware monitoring counters for NVIDIA GPU devices through the CuPTI library. More...

Include dependency graph for linux-cuda.c:

Go to the source code of this file.

Data Structures
struct	cuda_ctl_t

Macros
#define	PAPI_CUDA_MPX_COUNTERS   512
#define	PAPI_CUDA_MAX_COUNTERS   30

Functions
static int	cuda_init_component (int cidx)
static int	cuda_shutdown_component (void)
static int	cuda_init_thread (hwd_context_t *ctx)
static int	cuda_shutdown_thread (hwd_context_t *ctx)
static int	cuda_ntv_enum_events (unsigned int *event_code, int modifier)
static int	cuda_ntv_code_to_name (unsigned int event_code, char *name, int len)
static int	cuda_ntv_name_to_code (const char *name, unsigned int *event_code)
static int	cuda_ntv_code_to_descr (unsigned int event_code, char *descr, int len)
static int	cuda_init_control_state (hwd_control_state_t *ctl)
static int	cuda_set_domain (hwd_control_state_t *ctrl, int domain)
static int	cuda_update_control_state (hwd_control_state_t *ctl, NativeInfo_t *ntv_info, int ntv_count, hwd_context_t *ctx)
static int	cuda_cleanup_eventset (hwd_control_state_t *ctl)
static int	cuda_start (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	cuda_stop (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	cuda_read (hwd_context_t *ctx, hwd_control_state_t *ctl, long long **val, int flags)
static int	cuda_reset (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	cuda_init_private (void)
static int	check_n_initialize (void)
static int	cuda_ntv_code_to_descr (unsigned int event_code, char *descr, int __attribute__((unused)) len)
static int	cuda_init_thread (hwd_context_t __attribute__((unused)) *ctx)
static int	cuda_shutdown_thread (hwd_context_t __attribute__((unused)) *ctx)
static int	cuda_init_control_state (hwd_control_state_t __attribute__((unused)) *ctl)
static int	cuda_set_domain (hwd_control_state_t __attribute__((unused)) *ctrl, int domain)
static int	cuda_update_control_state (hwd_control_state_t *ctl, NativeInfo_t *ntv_info, int ntv_count, __attribute__((unused)) hwd_context_t *ctx)
static int	cuda_start (hwd_context_t __attribute__((unused)) *ctx, hwd_control_state_t *ctl)
int	cuda_stop (hwd_context_t __attribute__((unused)) *ctx, hwd_control_state_t *ctl)
static int	cuda_read (hwd_context_t __attribute__((unused)) *ctx, hwd_control_state_t *ctl, long long **val, int __attribute__((unused)) flags)
static int	cuda_reset (hwd_context_t __attribute__((unused)) *ctx, hwd_control_state_t *ctl)

Variables
papi_vector_t	_cuda_vector
ntv_event_table_t	global_event_names

Detailed Description

Author

Anustuv Pal anust.nosp@m.uv@i.nosp@m.cl.ut.nosp@m.k.ed.nosp@m.u (updated in 2023, redesigned with multi-threading support.)

Tony Castaldo tonyc.nosp@m.asta.nosp@m.ldo@i.nosp@m.cl.u.nosp@m.tk.ed.nosp@m.u (updated in 08/2019, to make counters accumulate.)

Tony Castaldo tonyc.nosp@m.asta.nosp@m.ldo@i.nosp@m.cl.u.nosp@m.tk.ed.nosp@m.u (updated in 2018, to use batch reads and support nvlink metrics.

Asim YarKhan yarkh.nosp@m.an@i.nosp@m.cl.ut.nosp@m.k.ed.nosp@m.u (updated in 2017 to support CUDA metrics)

Asim YarKhan yarkh.nosp@m.an@i.nosp@m.cl.ut.nosp@m.k.ed.nosp@m.u (updated in 2015 for multiple CUDA contexts/devices)

Heike Jagode (First version, in collaboration with Robert Dietrich, TU Dresden) jagod.nosp@m.e@ic.nosp@m.l.utk.nosp@m..edu

The open source software license for PAPI conforms to the BSD License template.

Definition in file linux-cuda.c.

Macro Definition Documentation

PAPI_CUDA_MAX_COUNTERS

#define PAPI_CUDA_MAX_COUNTERS   30

Definition at line 58 of file linux-cuda.c.

PAPI_CUDA_MPX_COUNTERS

#define PAPI_CUDA_MPX_COUNTERS   512

Definition at line 57 of file linux-cuda.c.

Function Documentation

check_n_initialize()

static int check_n_initialize ( void  )

static

Definition at line 170 of file linux-cuda.c.

{
    _papi_hwi_lock(COMPONENT_LOCK);
    int papi_errno = PAPI_OK;
    if (_cuda_vector.cmp_info.initialized
        && _cuda_vector.cmp_info.disabled == PAPI_EDELAY_INIT
    ) {
        papi_errno = cuda_init_private();
    }
 
    _papi_hwi_unlock(COMPONENT_LOCK);
    return papi_errno;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cuda_cleanup_eventset()

static int cuda_cleanup_eventset ( hwd_control_state_t *  ctl )

static

Definition at line 360 of file linux-cuda.c.

{
    COMPDBG("Entering.\n");
    cuda_ctl_t *control = (cuda_ctl_t *) ctl;
    int papi_errno = PAPI_OK;
    if (control->cupti_ctl) {
        papi_errno += cuptid_control_destroy(&(control->cupti_ctl));
    }
    if (control->info) {
        papi_errno += cuptid_thread_info_destroy(&(control->info));
    }
    if (papi_errno != PAPI_OK) {
        return PAPI_ECMP;
    }
    return PAPI_OK;
}

Here is the call graph for this function:

cuda_init_component()

static int cuda_init_component ( int  cidx )

static

Definition at line 114 of file linux-cuda.c.

{
    COMPDBG("Entering with component idx: %d\n", cidx);
 
    _cuda_vector.cmp_info.CmpIdx = cidx;
    _cuda_vector.cmp_info.num_native_events = -1;
    _cuda_lock = PAPI_NUM_LOCK + NUM_INNER_LOCK + cidx;
 
    _cuda_vector.cmp_info.initialized = 1;
    _cuda_vector.cmp_info.disabled = PAPI_EDELAY_INIT;
    sprintf(_cuda_vector.cmp_info.disabled_reason,
        "Not initialized. Access component events to initialize it.");
    return PAPI_EDELAY_INIT;
}

cuda_init_control_state() [1/2]

static int cuda_init_control_state ( hwd_control_state_t *  ctl )

static

cuda_init_control_state() [2/2]

static int cuda_init_control_state ( hwd_control_state_t __attribute__((unused)) *  ctl )

static

Definition at line 294 of file linux-cuda.c.

{
    COMPDBG("Entering.\n");
    return PAPI_OK;
}

cuda_init_private()

static int cuda_init_private ( void  )

static

Definition at line 144 of file linux-cuda.c.

{
    int papi_errno = PAPI_OK;
    const char *disabled_reason;
    COMPDBG("Entering.\n");
 
    papi_errno = cuptid_event_table_create(&global_event_names);
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
 
    papi_errno = cuptid_init();
    if (papi_errno != PAPI_OK) {
        cuptid_disabled_reason_get(&disabled_reason);
        sprintf(_cuda_vector.cmp_info.disabled_reason, disabled_reason);
        _cuda_vector.cmp_info.disabled = papi_errno;
        goto fn_exit;
    }
 
    _cuda_vector.cmp_info.disabled = PAPI_OK;
    strcpy(_cuda_vector.cmp_info.disabled_reason, "");
 
fn_exit:
    return papi_errno;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cuda_init_thread() [1/2]

static int cuda_init_thread ( hwd_context_t *  ctx )

static

cuda_init_thread() [2/2]

static int cuda_init_thread ( hwd_context_t __attribute__((unused)) *  ctx )

static

Definition at line 284 of file linux-cuda.c.

{
    return PAPI_OK;
}

cuda_ntv_code_to_descr() [1/2]

static int cuda_ntv_code_to_descr ( unsigned int  event_code, char *  descr, int __attribute__((unused))  len  )

static

Definition at line 259 of file linux-cuda.c.

{
    char evt_name[PAPI_2MAX_STR_LEN];
    int papi_errno;
    papi_errno = check_n_initialize();
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
 
    _papi_hwi_lock(COMPONENT_LOCK);
    papi_errno = cuptid_event_enum(global_event_names);
    _papi_hwi_unlock(COMPONENT_LOCK);
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
 
    papi_errno = cuda_ntv_code_to_name(event_code, evt_name, PAPI_2MAX_STR_LEN);
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
    papi_errno = cuptid_event_name_to_descr(evt_name, descr);
fn_exit:
    return papi_errno;
}

Here is the call graph for this function:

cuda_ntv_code_to_descr() [2/2]

static int cuda_ntv_code_to_descr ( unsigned int  event_code, char *  descr, int  len  )

static

cuda_ntv_code_to_name()

static int cuda_ntv_code_to_name ( unsigned int  event_code, char *  name, int  len  )

static

Definition at line 244 of file linux-cuda.c.

{
    int papi_errno = check_n_initialize();
    if (papi_errno != PAPI_OK) {
        return papi_errno;
    }
    ntv_event_t evt_rec;
    papi_errno = cuptid_event_table_get_item(global_event_names, event_code, &evt_rec);
    if (papi_errno != PAPI_OK) {
        return PAPI_ENOEVNT;
    }
    strncpy(name, evt_rec->name, len);
    return PAPI_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cuda_ntv_enum_events()

static int cuda_ntv_enum_events ( unsigned int *  event_code, int  modifier  )

static

Definition at line 184 of file linux-cuda.c.

{
    int papi_errno = check_n_initialize();
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
 
    _papi_hwi_lock(COMPONENT_LOCK);
    LOCKDBG("Locked COMPONENT_LOCK to enumerate all events.\n");
    papi_errno = cuptid_event_enum(global_event_names);
    _papi_hwi_unlock(COMPONENT_LOCK);
    LOCKDBG("Unlocked COMPONENT_LOCK.\n");
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
 
    _cuda_vector.cmp_info.num_native_events = global_event_names->count;
    switch (modifier) {
        case PAPI_ENUM_FIRST:
            *event_code = 0;
            papi_errno = PAPI_OK;
            break;
        case PAPI_ENUM_EVENTS:
            if (global_event_names->count == 0) {
                papi_errno = PAPI_ENOEVNT;
            } else if (*event_code < global_event_names->count - 1) {
                *event_code = *event_code + 1;
                papi_errno = PAPI_OK;
            } else {
                papi_errno = PAPI_ENOEVNT;
            }
            break;
        default:
            papi_errno = PAPI_EINVAL;
    }
fn_exit:
    return papi_errno;
}

Here is the call graph for this function:

cuda_ntv_name_to_code()

static int cuda_ntv_name_to_code ( const char *  name, unsigned int *  event_code  )

static

Definition at line 223 of file linux-cuda.c.

{
    int papi_errno = check_n_initialize();
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
    ntv_event_t evt_rec;
    papi_errno = cuptid_event_table_find_name(global_event_names, name, &evt_rec);
    if (papi_errno == PAPI_OK) {
        *event_code = evt_rec->evt_code;
    }
    else {
        _papi_hwi_lock(COMPONENT_LOCK);
        *event_code = global_event_names->count;
        papi_errno = cuptid_event_table_insert_record(global_event_names, name, global_event_names->count, 0);
        _papi_hwi_unlock(COMPONENT_LOCK);
    }
fn_exit:
    return papi_errno;
}

Here is the call graph for this function:

cuda_read() [1/2]

static int cuda_read ( hwd_context_t *  ctx, hwd_control_state_t *  ctl, long long **  val, int  flags  )

static

cuda_read() [2/2]

static int cuda_read ( hwd_context_t __attribute__((unused)) *  ctx, hwd_control_state_t *  ctl, long long **  val, int __attribute__((unused))  flags  )

static

Definition at line 417 of file linux-cuda.c.

{
    COMPDBG("Entering.\n");
    cuda_ctl_t *control = (cuda_ctl_t *) ctl;
    int papi_errno;
 
    papi_errno = cuptid_control_read( control->cupti_ctl, (long long *) &(control->values) );
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
    *val = control->values;
 
fn_exit:
    return papi_errno;
}

Here is the call graph for this function:

cuda_reset() [1/2]

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

static

cuda_reset() [2/2]

static int cuda_reset ( hwd_context_t __attribute__((unused)) *  ctx, hwd_control_state_t *  ctl  )

static

Definition at line 433 of file linux-cuda.c.

{
    cuda_ctl_t *control = (cuda_ctl_t *) ctl;
    int i;
    for (i = 0; i < control->events_count; i++) {
        control->values[i] = 0;
    }
    return cuptid_control_reset( control->cupti_ctl );
}

Here is the call graph for this function:

cuda_set_domain() [1/2]

static int cuda_set_domain ( hwd_control_state_t *  ctrl, int  domain  )

static

cuda_set_domain() [2/2]

static int cuda_set_domain ( hwd_control_state_t __attribute__((unused)) *  ctrl, int  domain  )

static

Definition at line 300 of file linux-cuda.c.

{
    COMPDBG("Entering\n");
    if((PAPI_DOM_USER & domain) || (PAPI_DOM_KERNEL & domain) || (PAPI_DOM_OTHER & domain) || (PAPI_DOM_ALL & domain))
        return (PAPI_OK);
    else
        return (PAPI_EINVAL);
}

cuda_shutdown_component()

static int cuda_shutdown_component ( void  )

static

Definition at line 129 of file linux-cuda.c.

{
    COMPDBG("Entering.\n");
    cuptid_event_table_destroy(&global_event_names);
 
    if (!_cuda_vector.cmp_info.initialized ||
    _cuda_vector.cmp_info.disabled != PAPI_OK) {
        return PAPI_OK;
    }
 
    _cuda_vector.cmp_info.initialized = 0;
 
    return cuptid_shutdown();
}

Here is the call graph for this function:

cuda_shutdown_thread() [1/2]

static int cuda_shutdown_thread ( hwd_context_t *  ctx )

static

cuda_shutdown_thread() [2/2]

static int cuda_shutdown_thread ( hwd_context_t __attribute__((unused)) *  ctx )

static

Definition at line 289 of file linux-cuda.c.

{
    return PAPI_OK;
}

cuda_start() [1/2]

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

static

cuda_start() [2/2]

static int cuda_start ( hwd_context_t __attribute__((unused)) *  ctx, hwd_control_state_t *  ctl  )

static

Definition at line 377 of file linux-cuda.c.

{
    COMPDBG("Entering.\n");
    int papi_errno, i;
 
    cuda_ctl_t *control = (cuda_ctl_t *) ctl;
    for (i = 0; i < control->events_count; i++) {
        control->values[i] = 0;
    }
    ntv_event_table_t select_names;
    papi_errno = cuptid_event_table_select_by_idx(global_event_names, control->events_count, control->events_id, &select_names);
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
    papi_errno = cuptid_control_create(select_names, control->info, &(control->cupti_ctl));
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
 
    papi_errno = cuptid_control_start( control->cupti_ctl );
 
fn_exit:
    cuptid_event_table_destroy(&select_names);
    return papi_errno;
}

Here is the call graph for this function:

cuda_stop() [1/2]

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

static

cuda_stop() [2/2]

int cuda_stop	(	hwd_context_t __attribute__((unused)) *	ctx,
		hwd_control_state_t *	ctl
	)

Definition at line 403 of file linux-cuda.c.

{
    COMPDBG("Entering.\n");
    cuda_ctl_t *control = (cuda_ctl_t *) ctl;
    int papi_errno;
    papi_errno = cuptid_control_stop( control->cupti_ctl );
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
    papi_errno = cuptid_control_destroy( &(control->cupti_ctl) );
fn_exit:
    return papi_errno;
}

Here is the call graph for this function:

cuda_update_control_state() [1/2]

static int cuda_update_control_state ( hwd_control_state_t *  ctl, NativeInfo_t *  ntv_info, int  ntv_count, __attribute__((unused)) hwd_context_t *  ctx  )

static

Definition at line 309 of file linux-cuda.c.

  {
    COMPDBG("Entering with events_count %d.\n", ntv_count);
    int i, papi_errno;
    papi_errno = check_n_initialize();
    if (papi_errno != PAPI_OK) {
        return papi_errno;
    }
    if (ntv_count == 0) {
        return PAPI_OK;
    }
 
    cuda_ctl_t *control = (cuda_ctl_t *) ctl;
    if (control->info == NULL) {
        papi_errno = cuptid_thread_info_create(&(control->info));
        if (papi_errno != PAPI_OK) {
            goto fn_exit;
        }
    }
    control->events_count = ntv_count;
 
    if (ntv_count > PAPI_CUDA_MAX_COUNTERS) {
        ERRDBG("Too many events added.\n");
        papi_errno = PAPI_ECMP;
        goto fn_exit;
    }
    for (i=0; i<ntv_count; i++) {
        control->events_id[i] = ntv_info[i].ni_event;
        ntv_info[i].ni_position = i;
    }
 
    void *tmp_context = NULL;
    ntv_event_table_t select_names;
    papi_errno = cuptid_event_table_select_by_idx(global_event_names, control->events_count, control->events_id, &select_names);
    if (papi_errno != PAPI_OK) {
        goto fn_exit;
    }
    papi_errno = cuptid_control_create(select_names, control->info, &tmp_context);
    if (papi_errno != PAPI_OK) {
        cuptid_control_destroy(&tmp_context);
        goto fn_exit;
    }
    papi_errno = cuptid_control_destroy(&tmp_context);
 
fn_exit:
    cuptid_event_table_destroy(&select_names);
    return papi_errno;
}

Here is the call graph for this function:

cuda_update_control_state() [2/2]

static int cuda_update_control_state ( hwd_control_state_t *  ctl, NativeInfo_t *  ntv_info, int  ntv_count, hwd_context_t *  ctx  )

static

Variable Documentation

_cuda_vector

papi_vector_t _cuda_vector

Definition at line 30 of file linux-cuda.c.

global_event_names

ntv_event_table_t global_event_names

Definition at line 32 of file linux-cuda.c.