rocm.c File Reference

This implements a PAPI component that enables PAPI-C to access hardware monitoring counters for AMD ROCM GPU devices through the ROC-profiler library. More...

Include dependency graph for rocm.c:

Go to the source code of this file.

Data Structures
struct	rocm_context_t
struct	rocm_control_t
struct	event_map_item

Functions
static int	rocm_init_component (int cid)
static int	rocm_init_thread (hwd_context_t *ctx)
static int	rocm_init_control_state (hwd_control_state_t *ctl)
static int	rocm_init_private (void)
static int	rocm_shutdown_component (void)
static int	rocm_shutdown_thread (hwd_context_t *ctx)
static int	rocm_cleanup_eventset (hwd_control_state_t *ctl)
static void	rocm_dispatch_timer (int n, hwd_siginfo_t *info, void *uc)
static int	rocm_update_control_state (hwd_control_state_t *ctl, NativeInfo_t *ntv_info, int ntv_count, hwd_context_t *ctx)
static int	rocm_set_domain (hwd_control_state_t *ctl, int domain)
static int	rocm_ctrl (hwd_context_t *ctx, int code, _papi_int_option_t *option)
static int	rocm_start (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	rocm_read (hwd_context_t *ctx, hwd_control_state_t *ctl, long long **val, int flags)
static int	rocm_stop (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	rocm_reset (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	rocm_ntv_enum_events (unsigned int *event_code, int modifier)
static int	rocm_ntv_code_to_name (unsigned int event_code, char *name, int len)
static int	rocm_ntv_name_to_code (const char *name, unsigned int *event_code)
static int	rocm_ntv_code_to_descr (unsigned int event_code, char *descr, int len)
static int	rocm_ntv_code_to_info (unsigned int event_code, PAPI_event_info_t *info)
static int	check_n_initialize (void)
int	rocm_init_control_state (hwd_control_state_t *ctl __attribute__((unused)))
static int	evt_get_count (int *count)
static int	counter_sampling_compatible_with_prof_mode (void)
void	rocm_dispatch_timer (int n __attribute__((unused)), hwd_siginfo_t *info, void *uc)
static int	update_native_events (rocm_control_t *, NativeInfo_t *, int)
static int	try_open_events (rocm_control_t *)
int	rocm_update_control_state (hwd_control_state_t *ctl, NativeInfo_t *ntv_info, int ntv_count, hwd_context_t *ctx __attribute__((unused)))
static int	compare (const void *a, const void *b)
int	rocm_set_domain (hwd_control_state_t *ctl __attribute__((unused)), int domain __attribute__((unused)))
int	rocm_ctrl (hwd_context_t *ctx __attribute__((unused)), int code __attribute__((unused)), _papi_int_option_t *option __attribute__((unused)))
int	rocm_read (hwd_context_t *ctx __attribute__((unused)), hwd_control_state_t *ctl, long long **val, int flags __attribute__((unused)))
int	rocm_reset (hwd_context_t *ctx __attribute__((unused)), hwd_control_state_t *ctl)

Variables
papi_vector_t	_rocm_vector

Detailed Description

Author

Giuseppe Congiu gcong.nosp@m.iu@i.nosp@m.cl.ut.nosp@m.k.ed.nosp@m.u

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

Definition in file rocm.c.

Function Documentation

check_n_initialize()

int check_n_initialize ( void  )

static

Definition at line 676 of file rocm.c.

{
    if (!_rocm_vector.cmp_info.initialized) {
        return rocm_init_private();
    }
    return _rocm_vector.cmp_info.disabled;
}

Here is the call graph for this function:

Here is the caller graph for this function:

compare()

static int compare ( const void *  a, const void *  b  )

static

Definition at line 384 of file rocm.c.

{
    struct event_map_item *A = (struct event_map_item *) a;
    struct event_map_item *B = (struct event_map_item *) b;
    return  A->event_id - B->event_id;
}

Here is the caller graph for this function:

counter_sampling_compatible_with_prof_mode()

static int counter_sampling_compatible_with_prof_mode ( void  )

static

Definition at line 291 of file rocm.c.

{
    return (rocm_prof_mode == ROCM_PROFILE_SAMPLING_MODE);
}

Here is the caller graph for this function:

evt_get_count()

static int evt_get_count ( int *  count )

static

Definition at line 179 of file rocm.c.

{
    uint64_t event_code = 0;
 
    if (rocd_evt_enum(&event_code, PAPI_ENUM_FIRST) == PAPI_OK) {
        ++(*count);
    }
    while (rocd_evt_enum(&event_code, PAPI_ENUM_EVENTS) == PAPI_OK) {
        ++(*count);
    }
 
    return PAPI_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rocm_cleanup_eventset()

int rocm_cleanup_eventset ( hwd_control_state_t *  ctl )

static

Definition at line 274 of file rocm.c.

{
    rocm_control_t *rocm_ctl = (rocm_control_t *) ctl;
 
    if (rocm_ctl->rocd_ctx != NULL) {
        SUBDBG("Cannot cleanup an eventset that is running.");
        return PAPI_ECMP;
    }
 
    papi_free(rocm_ctl->events_id);
    rocm_ctl->events_id = NULL;
    rocm_ctl->num_events = 0;
 
    return PAPI_OK;
}

Here is the caller graph for this function:

rocm_ctrl() [1/2]

int rocm_ctrl	(	hwd_context_t *ctx	__attribute__(unused),
		int code	__attribute__(unused),
		_papi_int_option_t *option	__attribute__(unused)
	)

Definition at line 462 of file rocm.c.

{
    return PAPI_OK;
}

rocm_ctrl() [2/2]

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

static

rocm_dispatch_timer() [1/2]

void rocm_dispatch_timer	(	int n	__attribute__(unused),
		hwd_siginfo_t *	info,
		void *	uc
	)

Definition at line 297 of file rocm.c.

{
    _papi_hwi_context_t hw_context;
    vptr_t address;
    EventSetInfo_t *ESI;
    ThreadInfo_t *thread;
    int cidx;
 
    if (!counter_sampling_compatible_with_prof_mode()) {
        SUBDBG("Counter sampling is not compatible with intercept mode");
        return;
    }
 
    _papi_hwi_lock(_rocm_lock);
 
    cidx = _rocm_vector.cmp_info.CmpIdx;
    thread = _papi_hwi_lookup_thread(0);
 
    if (thread == NULL) {
        SUBDBG("thread == NULL in user_signal_handler!");
        goto fn_exit;
    }
 
    ESI = thread->running_eventset[cidx];
    rocm_control_t *rocm_ctl = (rocm_control_t *) ESI->ctl_state;
 
    if (rocm_ctl->rocd_ctx == NULL) {
        SUBDBG("ESI == NULL in user_signal_handler!");
        goto fn_exit;
    }
 
    hw_context.si = info;
    hw_context.ucontext = (hwd_ucontext_t *) uc;
 
    address = GET_OVERFLOW_ADDRESS(hw_context);
 
    _papi_hwi_dispatch_overflow_signal((void *)&hw_context, address, NULL, 0, 0,
                                       &thread, cidx);
 
  fn_exit:
    _papi_hwi_unlock(_rocm_lock);
    return;
}

Here is the call graph for this function:

rocm_dispatch_timer() [2/2]

static void rocm_dispatch_timer ( int  n, hwd_siginfo_t *  info, void *  uc  )

static

rocm_init_component()

int rocm_init_component ( int  cid )

static

Definition at line 128 of file rocm.c.

{
    _rocm_vector.cmp_info.CmpIdx = cid;
    _rocm_vector.cmp_info.num_native_events = -1;
    _rocm_vector.cmp_info.num_cntrs = -1;
    _rocm_lock = PAPI_NUM_LOCK + NUM_INNER_LOCK + cid;
    SUBDBG("ENTER: cid: %d\n", cid);
 
    int papi_errno = rocd_init_environment();
    if (papi_errno != PAPI_OK) {
        _rocm_vector.cmp_info.initialized = 1;
        _rocm_vector.cmp_info.disabled = papi_errno;
        const char *err_string;
        rocd_err_get_last(&err_string);
        int expect = snprintf(_rocm_vector.cmp_info.disabled_reason,
                              PAPI_MAX_STR_LEN, "%s", err_string);
        if (expect > PAPI_MAX_STR_LEN) {
            SUBDBG("disabled_reason truncated");
        }
        goto fn_fail;
    }
 
    sprintf(_rocm_vector.cmp_info.disabled_reason,
            "Not initialized. Access component events to initialize it.");
    papi_errno = PAPI_EDELAY_INIT;
    _rocm_vector.cmp_info.disabled = papi_errno;
 
  fn_exit:
    SUBDBG("EXIT: %s\n", PAPI_strerror(papi_errno));
    return papi_errno;
  fn_fail:
    goto fn_exit;
}

Here is the call graph for this function:

rocm_init_control_state() [1/2]

int rocm_init_control_state

(

hwd_control_state_t *ctl

__attribute__(unused)

)

Definition at line 173 of file rocm.c.

{
    return check_n_initialize();
}

Here is the call graph for this function:

rocm_init_control_state() [2/2]

static int rocm_init_control_state ( hwd_control_state_t *  ctl )

static

rocm_init_private()

int rocm_init_private ( void  )

static

Definition at line 194 of file rocm.c.

{
    int papi_errno = PAPI_OK;
 
    _papi_hwi_lock(COMPONENT_LOCK);
    SUBDBG("ENTER\n");
 
    if (_rocm_vector.cmp_info.initialized) {
        papi_errno = _rocm_vector.cmp_info.disabled;
        goto fn_exit;
    }
 
    papi_errno = rocd_init();
    if (papi_errno != PAPI_OK) {
        _rocm_vector.cmp_info.disabled = papi_errno;
        const char *err_string;
        rocd_err_get_last(&err_string);
        int expect = snprintf(_rocm_vector.cmp_info.disabled_reason,
                              PAPI_MAX_STR_LEN, "%s", err_string);
        if (expect > PAPI_MAX_STR_LEN) {
            SUBDBG("disabled_reason truncated");
        }
 
        goto fn_fail;
    }
 
    int count = 0;
    papi_errno = evt_get_count(&count);
    _rocm_vector.cmp_info.num_native_events = count;
    _rocm_vector.cmp_info.num_cntrs = count;
 
  fn_exit:
    _rocm_vector.cmp_info.initialized = 1;
    _rocm_vector.cmp_info.disabled = papi_errno;
    SUBDBG("EXIT: %s\n", PAPI_strerror(papi_errno));
    _papi_hwi_unlock(COMPONENT_LOCK);
    return papi_errno;
  fn_fail:
    goto fn_exit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rocm_init_thread()

int rocm_init_thread ( hwd_context_t *  ctx )

static

Definition at line 163 of file rocm.c.

{
    rocm_context_t *rocm_ctx = (rocm_context_t *) ctx;
    memset(rocm_ctx, 0, sizeof(*rocm_ctx));
    rocm_ctx->initialized = 1;
    rocm_ctx->component_id = _rocm_vector.cmp_info.CmpIdx;
    return PAPI_OK;
}

rocm_ntv_code_to_descr()

int rocm_ntv_code_to_descr ( unsigned int  event_code, char *  descr, int  len  )

static

Definition at line 640 of file rocm.c.

{
    SUBDBG("ENTER: event_code: %u, descr: %p, len: %d\n", event_code, descr, len);
    int papi_errno = check_n_initialize();
    if (papi_errno != PAPI_OK) {
        goto fn_fail;
    }
 
    papi_errno = rocd_evt_code_to_descr((uint64_t) event_code, descr, len);
 
  fn_exit:
    SUBDBG("EXIT: %s\n", PAPI_strerror(papi_errno));
    return papi_errno;
  fn_fail:
    goto fn_exit;
}

Here is the call graph for this function:

rocm_ntv_code_to_info()

int rocm_ntv_code_to_info ( unsigned int  event_code, PAPI_event_info_t *  info  )

static

Definition at line 658 of file rocm.c.

{
    SUBDBG("ENTER: event_code: %u, info: %p\n", event_code, info);
    int papi_errno = check_n_initialize();
    if (papi_errno != PAPI_OK) {
        goto fn_fail;
    }
 
    papi_errno = rocd_evt_code_to_info((uint64_t) event_code, info);
 
  fn_exit:
    SUBDBG("EXIT: %s\n", PAPI_strerror(papi_errno));
    return papi_errno;
  fn_fail:
    goto fn_exit;
}

Here is the call graph for this function:

rocm_ntv_code_to_name()

int rocm_ntv_code_to_name ( unsigned int  event_code, char *  name, int  len  )

static

Definition at line 602 of file rocm.c.

{
    SUBDBG("ENTER: event_code: %u, name: %p, len: %d\n", event_code, name, len);
    int papi_errno = check_n_initialize();
    if (papi_errno != PAPI_OK) {
        goto fn_fail;
    }
 
    papi_errno = rocd_evt_code_to_name((uint64_t) event_code, name, len);
 
  fn_exit:
    SUBDBG("EXIT: %s\n", PAPI_strerror(papi_errno));
    return papi_errno;
  fn_fail:
    goto fn_exit;
}

Here is the call graph for this function:

rocm_ntv_enum_events()

int rocm_ntv_enum_events ( unsigned int *  event_code, int  modifier  )

static

Definition at line 582 of file rocm.c.

{
    SUBDBG("ENTER: event_code: %u, modifier: %d\n", *event_code, modifier);
    int papi_errno = check_n_initialize();
    if (papi_errno != PAPI_OK) {
        goto fn_fail;
    }
 
    uint64_t code = *(uint64_t *) event_code;
    papi_errno = rocd_evt_enum(&code, modifier);
    *event_code = (unsigned int) code;
 
  fn_exit:
    SUBDBG("EXIT: %s\n", PAPI_strerror(papi_errno));
    return papi_errno;
  fn_fail:
    goto fn_exit;
}

Here is the call graph for this function:

rocm_ntv_name_to_code()

int rocm_ntv_name_to_code ( const char *  name, unsigned int *  event_code  )

static

Definition at line 620 of file rocm.c.

{
    SUBDBG("ENTER: name: %s, code: %p\n", name, code);
    int papi_errno = check_n_initialize();
    if (papi_errno != PAPI_OK) {
        goto fn_fail;
    }
 
    uint64_t event_code;
    papi_errno = rocd_evt_name_to_code(name, &event_code);
    *code = (unsigned int) event_code;
 
  fn_exit:
    SUBDBG("EXIT: %s\n", PAPI_strerror(papi_errno));
    return papi_errno;
  fn_fail:
    goto fn_exit;
}

Here is the call graph for this function:

rocm_read() [1/2]

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

Definition at line 510 of file rocm.c.

{
    int papi_errno = PAPI_OK;
    rocm_control_t *rocm_ctl = (rocm_control_t *) ctl;
    SUBDBG("ENTER: ctx: %p, ctl: %p, val: %p, flags: %d\n", ctx, ctl, val, flags);
 
    if (rocm_ctl->rocd_ctx == NULL) {
        SUBDBG("Error! Cannot PAPI_read counters for an eventset that has not been PAPI_start'ed.");
        papi_errno = PAPI_EMISC;
        goto fn_fail;
    }
 
    papi_errno = rocd_ctx_read(rocm_ctl->rocd_ctx, val);
 
  fn_exit:
    SUBDBG("EXIT: %s\n", PAPI_strerror(papi_errno));
    return papi_errno;
  fn_fail:
    goto fn_exit;
}

Here is the call graph for this function:

rocm_read() [2/2]

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

static

rocm_reset() [1/2]

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

Definition at line 569 of file rocm.c.

{
    rocm_control_t *rocm_ctl = (rocm_control_t *) ctl;
 
    if (rocm_ctl->rocd_ctx == NULL) {
        SUBDBG("Cannot reset counters for an eventset that has not been started.");
        return PAPI_EMISC;
    }
 
    return rocd_ctx_reset(rocm_ctl->rocd_ctx);
}

Here is the call graph for this function:

rocm_reset() [2/2]

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

static

rocm_set_domain() [1/2]

int rocm_set_domain	(	hwd_control_state_t *ctl	__attribute__(unused),
		int domain	__attribute__(unused)
	)

Definition at line 455 of file rocm.c.

{
    return PAPI_OK;
}

rocm_set_domain() [2/2]

static int rocm_set_domain ( hwd_control_state_t *  ctl, int  domain  )

static

rocm_shutdown_component()

int rocm_shutdown_component ( void  )

static

Definition at line 236 of file rocm.c.

{
    int papi_errno = PAPI_OK;
    int orig_state = _rocm_vector.cmp_info.initialized;
    _rocm_vector.cmp_info.initialized = 0;
    SUBDBG("ENTER\n");
 
    if (!_rocm_vector.cmp_info.initialized) {
        goto fn_exit;
    }
 
    if (_rocm_vector.cmp_info.disabled != PAPI_OK) {
        goto fn_exit;
    }
 
    papi_errno = rocd_shutdown();
    if (papi_errno != PAPI_OK) {
        goto fn_fail;
    }
 
  fn_exit:
    SUBDBG("EXIT: %s\n", PAPI_strerror(papi_errno));
    return papi_errno;
  fn_fail:
    _rocm_vector.cmp_info.initialized = orig_state;
    goto fn_exit;
}

Here is the call graph for this function:

rocm_shutdown_thread()

int rocm_shutdown_thread ( hwd_context_t *  ctx )

static

Definition at line 265 of file rocm.c.

{
    rocm_context_t *rocm_ctx = (rocm_context_t *) ctx;
    rocm_ctx->initialized = 0;
    rocm_ctx->state = 0;
    return PAPI_OK;
}

rocm_start()

int rocm_start ( hwd_context_t *  ctx, hwd_control_state_t *  ctl  )

static

Definition at line 470 of file rocm.c.

{
    int papi_errno = PAPI_OK;
    rocm_context_t *rocm_ctx = (rocm_context_t *) ctx;
    rocm_control_t *rocm_ctl = (rocm_control_t *) ctl;
    SUBDBG("ENTER: ctx: %p, ctl: %p\n", ctx, ctl);
 
    if (rocm_ctx->state & ROCM_EVENTS_OPENED) {
        SUBDBG("Error! Cannot PAPI_start more than one eventset at a time for every component.");
        papi_errno = PAPI_ECNFLCT;
        goto fn_fail;
    }
 
    papi_errno = rocd_ctx_open(rocm_ctl->events_id, rocm_ctl->num_events,
                               &rocm_ctl->rocd_ctx);
    if (papi_errno != PAPI_OK) {
        goto fn_fail;
    }
 
    rocm_ctx->state = ROCM_EVENTS_OPENED;
 
    papi_errno = rocd_ctx_start(rocm_ctl->rocd_ctx);
    if (papi_errno != PAPI_OK) {
        goto fn_fail;
    }
 
    rocm_ctx->state |= ROCM_EVENTS_RUNNING;
 
  fn_exit:
    SUBDBG("EXIT: %s\n", PAPI_strerror(papi_errno));
    return papi_errno;
  fn_fail:
    if (rocm_ctx->state == ROCM_EVENTS_OPENED) {
        rocd_ctx_close(rocm_ctl->rocd_ctx);
    }
    rocm_ctx->state = 0;
    goto fn_exit;
}

Here is the call graph for this function:

rocm_stop()

int rocm_stop ( hwd_context_t *  ctx, hwd_control_state_t *  ctl  )

static

Definition at line 533 of file rocm.c.

{
    int papi_errno = PAPI_OK;
    rocm_context_t *rocm_ctx = (rocm_context_t *) ctx;
    rocm_control_t *rocm_ctl = (rocm_control_t *) ctl;
    SUBDBG("ENTER: ctx: %p, ctl: %p\n", ctx, ctl);
 
    if (!(rocm_ctx->state & ROCM_EVENTS_OPENED)) {
        SUBDBG("Error! Cannot PAPI_stop counters for an eventset that has not been PAPI_start'ed.");
        papi_errno = PAPI_EMISC;
        goto fn_fail;
    }
 
    papi_errno = rocd_ctx_stop(rocm_ctl->rocd_ctx);
    if (papi_errno != PAPI_OK) {
        goto fn_fail;
    }
 
    rocm_ctx->state &= ~ROCM_EVENTS_RUNNING;
 
    papi_errno = rocd_ctx_close(rocm_ctl->rocd_ctx);
    if (papi_errno != PAPI_OK) {
        goto fn_fail;
    }
 
    rocm_ctx->state = 0;
    rocm_ctl->rocd_ctx = NULL;
 
  fn_exit:
    SUBDBG("EXIT: %s\n", PAPI_strerror(papi_errno));
    return papi_errno;
  fn_fail:
    goto fn_exit;
}

Here is the call graph for this function:

rocm_update_control_state() [1/2]

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

Definition at line 345 of file rocm.c.

{
    SUBDBG("ENTER: ctl: %p, ntv_info: %p, ntv_count: %d, ctx: %p\n", ctl, ntv_info, ntv_count, ctx);
    int papi_errno = check_n_initialize();
    if (papi_errno != PAPI_OK) {
        goto fn_fail;
    }
 
    rocm_control_t *rocm_ctl = (rocm_control_t *) ctl;
 
    if (rocm_ctl->rocd_ctx != NULL) {
        SUBDBG("Cannot update events in an eventset that has been already "
               "started.");
        papi_errno = PAPI_ECMP;
        goto fn_fail;
    }
 
    papi_errno = update_native_events(rocm_ctl, ntv_info, ntv_count);
    if (papi_errno != PAPI_OK) {
        goto fn_fail;
    }
 
    papi_errno = try_open_events(rocm_ctl);
 
  fn_exit:
    SUBDBG("EXIT: %s\n", PAPI_strerror(papi_errno));
    return papi_errno;
  fn_fail:
    goto fn_exit;
}

Here is the call graph for this function:

rocm_update_control_state() [2/2]

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

static

try_open_events()

int try_open_events ( rocm_control_t *  rocm_ctl )

static

Definition at line 430 of file rocm.c.

{
    int papi_errno = PAPI_OK;
    rocd_ctx_t rocd_ctx;
 
    if (rocm_prof_mode != ROCM_PROFILE_SAMPLING_MODE) {
        /* Do not try open for intercept mode */
        return papi_errno;
    }
 
    if (rocm_ctl->num_events <= 0) {
        return PAPI_OK;
    }
 
    papi_errno = rocd_ctx_open(rocm_ctl->events_id, rocm_ctl->num_events,
                               &rocd_ctx);
    if (papi_errno != PAPI_OK) {
        rocm_cleanup_eventset(rocm_ctl);
        return papi_errno;
    }
 
    return rocd_ctx_close(rocd_ctx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_native_events()

int update_native_events ( rocm_control_t *  ctl, NativeInfo_t *  ntv_info, int  ntv_count  )

static

Definition at line 392 of file rocm.c.

{
    int papi_errno = PAPI_OK;
    struct event_map_item sorted_events[PAPI_ROCM_MAX_COUNTERS];
 
    if (ntv_count != ctl->num_events) {
        ctl->events_id = papi_realloc(ctl->events_id,
                                      ntv_count * sizeof(*ctl->events_id));
        if (ctl->events_id == NULL) {
            papi_errno = PAPI_ENOMEM;
            goto fn_fail;
        }
 
        ctl->num_events = ntv_count;
    }
 
    int i;
    for (i = 0; i < ntv_count; ++i) {
        sorted_events[i].event_id = ntv_info[i].ni_event;
        sorted_events[i].frontend_idx = i;
    }
 
    qsort(sorted_events, ntv_count, sizeof(struct event_map_item), compare);
 
    for (i = 0; i < ntv_count; ++i) {
        ctl->events_id[i] = sorted_events[i].event_id;
        ntv_info[sorted_events[i].frontend_idx].ni_position = i;
    }
 
  fn_exit:
    return papi_errno;
  fn_fail:
    ctl->num_events = 0;
    goto fn_exit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

_rocm_vector

papi_vector_t _rocm_vector

Definition at line 74 of file rocm.c.