rocm.c

Go to the documentation of this file.

 
#include <string.h>
#include "papi.h"
#include "papi_internal.h"
#include "papi_memory.h"
#include "papi_vector.h"
#include "extras.h"
#include "roc_dispatch.h"
 
/* Init and finalize */
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);
 
/* set and update component state */
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);
 
/* start and stop monitoring of hardware counters */
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);
 
/* event conversion utilities */
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);
 
typedef struct {
    int initialized;
    int state;
    int component_id;
} rocm_context_t;
 
typedef struct {
    int num_events;
    unsigned int domain;
    unsigned int granularity;
    unsigned int overflow;
    unsigned int overflow_signal;
    unsigned int attached;
    int component_id;
    uint64_t *events_id;
    rocd_ctx_t rocd_ctx;
} rocm_control_t;
 
papi_vector_t _rocm_vector = {
    .cmp_info = {
        .name = "rocm",
        .short_name = "rocm",
        .version = "2.0",
        .description = "GPU events and metrics via AMD ROCm-PL API",
        .num_mpx_cntrs = PAPI_ROCM_MAX_COUNTERS,
        .num_cntrs = PAPI_ROCM_MAX_COUNTERS,
        .default_domain = PAPI_DOM_USER,
        .default_granularity = PAPI_GRN_THR,
        .available_granularities = PAPI_GRN_THR,
        .hardware_intr_sig = PAPI_INT_SIGNAL,
        .fast_real_timer = 0,
        .fast_virtual_timer = 0,
        .attach = 0,
        .attach_must_ptrace = 0,
        .available_domains = PAPI_DOM_USER | PAPI_DOM_KERNEL,
        .initialized = 0,
    },
 
    .size = {
        .context = sizeof(rocm_context_t),
        .control_state = sizeof(rocm_control_t),
        .reg_value = 1,
        .reg_alloc = 1,
    },
 
    .init_component = rocm_init_component,
    .init_thread = rocm_init_thread,
    .init_control_state = rocm_init_control_state,
    .shutdown_component = rocm_shutdown_component,
    .shutdown_thread = rocm_shutdown_thread,
    .cleanup_eventset = rocm_cleanup_eventset,
    .dispatch_timer = rocm_dispatch_timer,
 
    .update_control_state = rocm_update_control_state,
    .set_domain = rocm_set_domain,
    .ctl = rocm_ctrl,
 
    .start = rocm_start,
    .stop = rocm_stop,
    .read = rocm_read,
    .reset = rocm_reset,
 
    .ntv_enum_events = rocm_ntv_enum_events,
    .ntv_code_to_name = rocm_ntv_code_to_name,
    .ntv_name_to_code = rocm_ntv_name_to_code,
    .ntv_code_to_descr = rocm_ntv_code_to_descr,
    .ntv_code_to_info = rocm_ntv_code_to_info,
};
 
static int check_n_initialize(void);
 
int
rocm_init_component(int cid)
{
    _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;
}
 
int
rocm_init_thread(hwd_context_t *ctx)
{
    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;
}
 
int
rocm_init_control_state(hwd_control_state_t *ctl __attribute__((unused)))
{
    return check_n_initialize();
}
 
static int
evt_get_count(int *count)
{
    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;
}
 
int
rocm_init_private(void)
{
    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;
}
 
int
rocm_shutdown_component(void)
{
    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;
}
 
int
rocm_shutdown_thread(hwd_context_t *ctx)
{
    rocm_context_t *rocm_ctx = (rocm_context_t *) ctx;
    rocm_ctx->initialized = 0;
    rocm_ctx->state = 0;
    return PAPI_OK;
}
 
int
rocm_cleanup_eventset(hwd_control_state_t *ctl)
{
    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;
}
 
static int
counter_sampling_compatible_with_prof_mode(void)
{
    return (rocm_prof_mode == ROCM_PROFILE_SAMPLING_MODE);
}
 
void
rocm_dispatch_timer(int n __attribute__((unused)), hwd_siginfo_t *info, void *uc)
{
    _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;
}
 
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)))
{
    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;
}
 
struct event_map_item {
    int event_id;
    int frontend_idx;
};
 
static int
compare(const void *a, const void *b)
{
    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;
}
 
int
update_native_events(rocm_control_t *ctl, NativeInfo_t *ntv_info,
                     int ntv_count)
{
    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;
}
 
int
try_open_events(rocm_control_t *rocm_ctl)
{
    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);
}
 
int
rocm_set_domain(hwd_control_state_t *ctl __attribute__((unused)),
                int domain __attribute__((unused)))
{
    return PAPI_OK;
}
 
int
rocm_ctrl(hwd_context_t *ctx __attribute__((unused)),
          int code __attribute__((unused)),
          _papi_int_option_t *option __attribute__((unused)))
{
    return PAPI_OK;
}
 
int
rocm_start(hwd_context_t *ctx, hwd_control_state_t *ctl)
{
    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;
}
 
int
rocm_read(hwd_context_t *ctx __attribute__((unused)), hwd_control_state_t *ctl,
          long long **val, int flags __attribute__((unused)))
{
    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;
}
 
int
rocm_stop(hwd_context_t *ctx, hwd_control_state_t *ctl)
{
    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;
}
 
int
rocm_reset(hwd_context_t *ctx __attribute__((unused)), hwd_control_state_t *ctl)
{
    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);
}
 
int
rocm_ntv_enum_events(unsigned int *event_code, int modifier)
{
    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;
}
 
int
rocm_ntv_code_to_name(unsigned int event_code, char *name, int len)
{
    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;
}
 
int
rocm_ntv_name_to_code(const char *name, unsigned int *code)
{
    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;
}
 
int
rocm_ntv_code_to_descr(unsigned int event_code, char *descr, int len)
{
    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;
}
 
int
rocm_ntv_code_to_info(unsigned int event_code, PAPI_event_info_t *info)
{
    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;
}
 
int
check_n_initialize(void)
{
    if (!_rocm_vector.cmp_info.initialized) {
        return rocm_init_private();
    }
    return _rocm_vector.cmp_info.disabled;
}