Loading...
Searching...
No Matches
rocs.c File Reference
Include dependency graph for rocs.c:
Go to the source code of this file.
Data Structures | |
| struct | ntv_event_t |
| struct | ntv_event_table_t |
| struct | rocs_ctx_t |
Macros | |
| #define | PAPI_ROCMSMI_MAX_DEV_COUNT (32) |
| #define | PAPI_ROCMSMI_MAX_SUBVAR (32) |
| #define | ROCMSMI_NUM_INFO_EVENTS (3) |
Typedefs | |
| typedef int(* | open_function_f) (void *arg) |
| typedef int(* | close_function_f) (void *arg) |
| typedef int(* | start_function_f) (void *arg) |
| typedef int(* | stop_function_f) (void *arg) |
| typedef int(* | access_function_f) (rocs_access_mode_e mode, void *arg) |
Variables | |
| unsigned int | _rocm_smi_lock |
| static rsmi_status_t(* | rsmi_num_monitor_dev_p )(uint32_t *) |
| static rsmi_status_t(* | rsmi_func_iter_value_get_p )(rsmi_func_id_iter_handle_t, rsmi_func_id_value_t *) |
| static rsmi_status_t(* | rsmi_func_iter_next_p )(rsmi_func_id_iter_handle_t) |
| static rsmi_status_t(* | rsmi_dev_supported_func_iterator_open_p )(uint32_t, rsmi_func_id_iter_handle_t *) |
| static rsmi_status_t(* | rsmi_dev_supported_func_iterator_close_p )(rsmi_func_id_iter_handle_t *) |
| static rsmi_status_t(* | rsmi_dev_supported_variant_iterator_open_p )(rsmi_func_id_iter_handle_t, rsmi_func_id_iter_handle_t *) |
| static rsmi_status_t(* | rsmi_dev_id_get_p )(uint32_t, uint16_t *) |
| static rsmi_status_t(* | rsmi_dev_unique_id_get_p )(uint32_t, uint64_t *) |
| static rsmi_status_t(* | rsmi_dev_brand_get_p )(uint32_t, char *, uint32_t) |
| static rsmi_status_t(* | rsmi_dev_name_get_p )(uint32_t, char *, size_t) |
| static rsmi_status_t(* | rsmi_dev_serial_number_get_p )(uint32_t, char *, uint32_t) |
| static rsmi_status_t(* | rsmi_dev_vbios_version_get_p )(uint32_t, char *, uint32_t) |
| static rsmi_status_t(* | rsmi_dev_vendor_name_get_p )(uint32_t, char *, size_t) |
| static rsmi_status_t(* | rsmi_dev_vendor_id_get_p )(uint32_t, uint16_t *) |
| static rsmi_status_t(* | rsmi_dev_subsystem_id_get_p )(uint32_t, uint16_t *) |
| static rsmi_status_t(* | rsmi_dev_subsystem_vendor_id_get_p )(uint32_t, uint16_t *) |
| static rsmi_status_t(* | rsmi_dev_subsystem_name_get_p )(uint32_t, char *, size_t) |
| static rsmi_status_t(* | rsmi_dev_drm_render_minor_get_p )(uint32_t, uint32_t *) |
| static rsmi_status_t(* | rsmi_dev_overdrive_level_get_p )(uint32_t, uint32_t *) |
| static rsmi_status_t(* | rsmi_dev_overdrive_level_set_p )(uint32_t, uint32_t) |
| static rsmi_status_t(* | rsmi_dev_memory_busy_percent_get_p )(uint32_t, uint32_t *) |
| static rsmi_status_t(* | rsmi_dev_memory_reserved_pages_get_p )(uint32_t, uint32_t *, rsmi_retired_page_record_t *) |
| static rsmi_status_t(* | rsmi_dev_memory_total_get_p )(uint32_t, rsmi_memory_type_t, uint64_t *) |
| static rsmi_status_t(* | rsmi_dev_memory_usage_get_p )(uint32_t, rsmi_memory_type_t, uint64_t *) |
| static rsmi_status_t(* | rsmi_dev_perf_level_get_p )(uint32_t, rsmi_dev_perf_level_t *) |
| static rsmi_status_t(* | rsmi_dev_perf_level_set_p )(int32_t, rsmi_dev_perf_level_t) |
| static rsmi_status_t(* | rsmi_dev_busy_percent_get_p )(uint32_t, uint32_t *) |
| static rsmi_status_t(* | rsmi_dev_firmware_version_get_p )(uint32_t, rsmi_fw_block_t, uint64_t *) |
| static rsmi_status_t(* | rsmi_dev_ecc_count_get_p )(uint32_t, rsmi_gpu_block_t, rsmi_error_count_t *) |
| static rsmi_status_t(* | rsmi_dev_ecc_enabled_get_p )(uint32_t, uint64_t *) |
| static rsmi_status_t(* | rsmi_dev_ecc_status_get_p )(uint32_t, rsmi_gpu_block_t, rsmi_ras_err_state_t *) |
| static rsmi_status_t(* | rsmi_dev_fan_reset_p )(uint32_t, uint32_t) |
| static rsmi_status_t(* | rsmi_dev_fan_rpms_get_p )(uint32_t, uint32_t, int64_t *) |
| static rsmi_status_t(* | rsmi_dev_fan_speed_get_p )(uint32_t, uint32_t, int64_t *) |
| static rsmi_status_t(* | rsmi_dev_fan_speed_max_get_p )(uint32_t, uint32_t, uint64_t *) |
| static rsmi_status_t(* | rsmi_dev_fan_speed_set_p )(uint32_t, uint32_t, uint64_t) |
| static rsmi_status_t(* | rsmi_dev_power_avg_get_p )(uint32_t, uint32_t, uint64_t *) |
| static rsmi_status_t(* | rsmi_dev_power_cap_get_p )(uint32_t, uint32_t, uint64_t *) |
| static rsmi_status_t(* | rsmi_dev_power_cap_set_p )(uint32_t, uint32_t, uint64_t) |
| static rsmi_status_t(* | rsmi_dev_power_cap_range_get_p )(uint32_t, uint32_t, uint64_t *, uint64_t *) |
| static rsmi_status_t(* | rsmi_dev_power_profile_presets_get_p )(uint32_t, uint32_t, rsmi_power_profile_status_t *) |
| static rsmi_status_t(* | rsmi_dev_power_profile_set_p )(uint32_t, uint32_t, rsmi_power_profile_preset_masks_t) |
| static rsmi_status_t(* | rsmi_dev_temp_metric_get_p )(uint32_t, uint32_t, rsmi_temperature_metric_t, int64_t *) |
| static rsmi_status_t(* | rsmi_dev_pci_id_get_p )(uint32_t, uint64_t *) |
| static rsmi_status_t(* | rsmi_dev_pci_throughput_get_p )(uint32_t, uint64_t *, uint64_t *, uint64_t *) |
| static rsmi_status_t(* | rsmi_dev_pci_replay_counter_get_p )(uint32_t, uint64_t *) |
| static rsmi_status_t(* | rsmi_dev_pci_bandwidth_get_p )(uint32_t, rsmi_pcie_bandwidth_t *) |
| static rsmi_status_t(* | rsmi_dev_pci_bandwidth_set_p )(uint32_t, uint64_t) |
| static rsmi_status_t(* | rsmi_dev_gpu_clk_freq_get_p )(uint32_t, rsmi_clk_type_t, rsmi_frequencies_t *) |
| static rsmi_status_t(* | rsmi_dev_gpu_clk_freq_set_p )(uint32_t, rsmi_clk_type_t, uint64_t) |
| static rsmi_status_t(* | rsmi_dev_od_volt_curve_regions_get_p )(uint32_t, uint32_t *, rsmi_freq_volt_region_t *) |
| static rsmi_status_t(* | rsmi_dev_od_volt_info_get_p )(uint32_t, rsmi_od_volt_freq_data_t *) |
| static rsmi_status_t(* | rsmi_init_p )(uint64_t) |
| static rsmi_status_t(* | rsmi_shut_down_p )(void) |
| static rsmi_status_t(* | rsmi_version_get_p )(rsmi_version_t *) |
| static rsmi_status_t(* | rsmi_version_str_get_p )(rsmi_sw_component_t, char *, size_t) |
| static rsmi_status_t(* | rsmi_status_string_p )(rsmi_status_t, const char **) |
| static rsmi_status_t(* | rsmi_dev_counter_group_supported_p )(uint32_t, rsmi_event_group_t) |
| static rsmi_status_t(* | rsmi_dev_counter_create_p )(uint32_t, rsmi_event_type_t, rsmi_event_handle_t *) |
| static rsmi_status_t(* | rsmi_dev_counter_destroy_p )(rsmi_event_handle_t) |
| static rsmi_status_t(* | rsmi_counter_control_p )(rsmi_event_handle_t, rsmi_counter_command_t, void *) |
| static rsmi_status_t(* | rsmi_counter_read_p )(rsmi_event_type_t, rsmi_counter_value_t *) |
| static rsmi_status_t(* | rsmi_counter_available_counters_get_p )(uint32_t, rsmi_event_group_t, uint32_t *) |
| static rsmi_status_t(* | rsmi_is_P2P_accessible_p )(uint32_t, uint32_t, int *) |
| static rsmi_status_t(* | rsmi_minmax_bandwidth_get_p )(uint32_t, uint32_t, uint64_t *, uint64_t *) |
| struct { | |
| const char * name | |
| open_function_f open_func_p | |
| close_function_f close_func_p | |
| start_function_f start_func_p | |
| stop_function_f stop_func_p | |
| access_function_f access_func_p | |
| } | event_function_table [] |
| static void * | rsmi_dlp |
| static ntv_event_table_t | ntv_table |
| static ntv_event_table_t * | ntv_table_p |
| static void * | htable |
| static char | error_string [PAPI_MAX_STR_LEN+1] |
| static int32_t | device_count |
| static rsmi_frequencies_t * | freq_table |
| static rsmi_pcie_bandwidth_t * | pcie_table |
| static int32_t | device_mask |
Macro Definition Documentation
◆ PAPI_ROCMSMI_MAX_DEV_COUNT
◆ PAPI_ROCMSMI_MAX_SUBVAR
◆ ROCMSMI_NUM_INFO_EVENTS
Typedef Documentation
◆ access_function_f
| typedef int(* access_function_f) (rocs_access_mode_e mode, void *arg) |
◆ close_function_f
◆ open_function_f
◆ start_function_f
◆ stop_function_f
Enumeration Type Documentation
◆ rocs_access_mode_e
| enum rocs_access_mode_e |
| Enumerator | |
|---|---|
| ROCS_ACCESS_MODE__READ | |
| ROCS_ACCESS_MODE__WRITE | |
| ROCS_ACCESS_MODE__RDWR | |
◆ rocs_ecc_count_subvariant_e
| Enumerator | |
|---|---|
| ROCS_ECC_COUNT_SUBVARIANT__CORRECTABLE | |
| ROCS_ECC_COUNT_SUBVARIANT__UNCORRECTABLE | |
| ROCS_ECC_COUNT_SUBVARIANT__NUM | |
Definition at line 113 of file rocs.c.
113 {
@ ROCS_ECC_COUNT_SUBVARIANT__CORRECTABLE
Definition: rocs.c:114
@ ROCS_ECC_COUNT_SUBVARIANT__UNCORRECTABLE
Definition: rocs.c:115
◆ rocs_event_type_e
| enum rocs_event_type_e |
| Enumerator | |
|---|---|
| ROCS_EVENT_TYPE__NORMAL | |
| ROCS_EVENT_TYPE__SPECIAL | |
◆ rocs_gpu_clk_freq_subvariant_e
◆ rocs_gpu_clk_freq_variant_e
Definition at line 119 of file rocs.c.
119 {
120 ROCS_GPU_CLK_FREQ_VARIANT__SYSTEM = RSMI_CLK_TYPE_SYS,
121 ROCS_GPU_CLK_FREQ_VARIANT__DATA_FABRIC = RSMI_CLK_TYPE_DF,
122 ROCS_GPU_CLK_FREQ_VARIANT__DISPLAY_ENGINE = RSMI_CLK_TYPE_DCEF,
123 ROCS_GPU_CLK_FREQ_VARIANT__SOC = RSMI_CLK_TYPE_SOC,
124 ROCS_GPU_CLK_FREQ_VARIANT__MEMORY = RSMI_CLK_TYPE_MEM,
@ ROCS_GPU_CLK_FREQ_VARIANT__DATA_FABRIC
Definition: rocs.c:121
@ ROCS_GPU_CLK_FREQ_VARIANT__DISPLAY_ENGINE
Definition: rocs.c:122
◆ rocs_pci_bw_variant_e
| Enumerator | |
|---|---|
| ROCS_PCI_BW_VARIANT__COUNT | |
| ROCS_PCI_BW_VARIANT__CURRENT | |
| ROCS_PCI_BW_VARIANT__RATE_IDX | |
| ROCS_PCI_BW_VARIANT__LANE_IDX | |
| ROCS_PCI_BW_VARIANT__NUM | |
Definition at line 134 of file rocs.c.
134 {
140} rocs_pci_bw_variant_e;
◆ rocs_pci_throughput_variant_e
◆ rocs_power_cap_range_variant_e
◆ rocs_power_presets_variant_e
| Enumerator | |
|---|---|
| ROCS_POWER_PRESETS_VARIANT__COUNT | |
| ROCS_POWER_PRESETS_VARIANT__AVAIL_PROFILES | |
| ROCS_POWER_PRESETS_VARIANT__CURRENT | |
| ROCS_POWER_PRESETS_VARIANT__NUM | |
Definition at line 100 of file rocs.c.
100 {
@ ROCS_POWER_PRESETS_VARIANT__AVAIL_PROFILES
Definition: rocs.c:102
◆ rocs_xgmi_bw_variant_e
| Enumerator | |
|---|---|
| ROCS_XGMI_BW_VARIANT__MIN | |
| ROCS_XGMI_BW_VARIANT__MAX | |
| ROCS_XGMI_BW_VARIANT__NUM | |
Definition at line 161 of file rocs.c.
161 {
165} rocs_xgmi_bw_variant_e;
◆ rocs_xgmi_variant_e
| enum rocs_xgmi_variant_e |
Definition at line 142 of file rocs.c.
142 {
143 /* XXX: the following events (variants) and the corresponding logic
144 are not tested */
145 ROCS_XGMI_VARIANT__MI50_0_NOP_TX = RSMI_EVNT_XGMI_0_NOP_TX,
146 ROCS_XGMI_VARIANT__MI50_0_REQUEST_TX = RSMI_EVNT_XGMI_0_REQUEST_TX,
147 ROCS_XGMI_VARIANT__MI50_0_RESPONSE_TX = RSMI_EVNT_XGMI_0_RESPONSE_TX,
148 ROCS_XGMI_VARIANT__MI50_0_BEATS_TX = RSMI_EVNT_XGMI_0_BEATS_TX,
149 ROCS_XGMI_VARIANT__MI50_1_NOP_TX = RSMI_EVNT_XGMI_1_NOP_TX,
150 ROCS_XGMI_VARIANT__MI50_1_REQUEST_TX = RSMI_EVNT_XGMI_1_REQUEST_TX,
151 ROCS_XGMI_VARIANT__MI50_1_RESPONSE_TX = RSMI_EVNT_XGMI_1_RESPONSE_TX,
152 ROCS_XGMI_VARIANT__MI50_1_BEATS_TX = RSMI_EVNT_XGMI_1_BEATS_TX,
153 ROCS_XGMI_VARIANT__MI100_DATA_OUT_0 = RSMI_EVNT_XGMI_DATA_OUT_0,
154 ROCS_XGMI_VARIANT__MI100_DATA_OUT_1 = RSMI_EVNT_XGMI_DATA_OUT_1,
155 ROCS_XGMI_VARIANT__MI100_DATA_OUT_2 = RSMI_EVNT_XGMI_DATA_OUT_2,
156 ROCS_XGMI_VARIANT__MI100_DATA_OUT_3 = RSMI_EVNT_XGMI_DATA_OUT_3,
157 ROCS_XGMI_VARIANT__MI100_DATA_OUT_4 = RSMI_EVNT_XGMI_DATA_OUT_4,
158 ROCS_XGMI_VARIANT__MI100_DATA_OUT_5 = RSMI_EVNT_XGMI_DATA_OUT_5,
159} rocs_xgmi_variant_e;
Function Documentation
◆ access_rsmi_dev_brand()
|
static |
Definition at line 3846 of file rocs.c.
3847{
3849
3852 }
3853
3854 rsmi_status_t status;
3856 if (status != RSMI_STATUS_SUCCESS) {
3858 }
3860 event->value = (int64_t) event->scratch;
3862}
static rsmi_status_t(* rsmi_dev_brand_get_p)(uint32_t, char *, uint32_t)
Definition: rocs.c:21
Definition: perfctr-ppc64.h:165
◆ access_rsmi_dev_busy_percent()
|
static |
Definition at line 3349 of file rocs.c.
3350{
3352
3355 }
3356
3357 rsmi_status_t status;
3358 uint32_t data;
3359 status = rsmi_dev_busy_percent_get_p(event->device, &data);
3360 if (status != RSMI_STATUS_SUCCESS) {
3362 }
3363 event->value = (int64_t) data;
3365}
static rsmi_status_t(* rsmi_dev_busy_percent_get_p)(uint32_t, uint32_t *)
Definition: rocs.c:39
◆ access_rsmi_dev_count()
|
static |
◆ access_rsmi_dev_driver_version_str()
|
static |
◆ access_rsmi_dev_drm_render_minor()
|
static |
Definition at line 3213 of file rocs.c.
3214{
3216
3219 }
3220
3221 rsmi_status_t status;
3222 uint32_t data;
3223 status = rsmi_dev_drm_render_minor_get_p(event->device, &data);
3224 if (status != RSMI_STATUS_SUCCESS) {
3226 }
3227 event->value = (int64_t) data;
3229}
static rsmi_status_t(* rsmi_dev_drm_render_minor_get_p)(uint32_t, uint32_t *)
Definition: rocs.c:30
◆ access_rsmi_dev_ecc_count()
|
static |
Definition at line 3682 of file rocs.c.
3683{
3685
3688 }
3689
3690 rsmi_status_t status;
3691 rsmi_error_count_t data;
3692 status = rsmi_dev_ecc_count_get_p(event->device, event->variant, &data);
3693 if (status != RSMI_STATUS_SUCCESS) {
3695 }
3696
3697 switch (event->subvariant) {
3699 event->value = (int64_t) data.correctable_err;
3700 break;
3702 event->value = (int64_t) data.uncorrectable_err;
3703 break;
3704 default:
3706 }
3708}
static rsmi_status_t(* rsmi_dev_ecc_count_get_p)(uint32_t, rsmi_gpu_block_t, rsmi_error_count_t *)
Definition: rocs.c:41
◆ access_rsmi_dev_ecc_enabled()
|
static |
Definition at line 3711 of file rocs.c.
3712{
3714
3717 }
3718
3719 rsmi_status_t status;
3720 uint64_t data;
3721 status = rsmi_dev_ecc_enabled_get_p(event->device, &data);
3722 if (status != RSMI_STATUS_SUCCESS) {
3724 }
3725 event->value = (int64_t) data;
3727}
static rsmi_status_t(* rsmi_dev_ecc_enabled_get_p)(uint32_t, uint64_t *)
Definition: rocs.c:42
◆ access_rsmi_dev_ecc_status()
|
static |
Definition at line 3730 of file rocs.c.
3731{
3733
3736 }
3737
3738 rsmi_status_t status;
3739 rsmi_ras_err_state_t data;
3740 status = rsmi_dev_ecc_status_get_p(event->device, event->variant, &data);
3741 if (status != RSMI_STATUS_SUCCESS) {
3743 }
3744 event->value = (int64_t) data;
3746}
static rsmi_status_t(* rsmi_dev_ecc_status_get_p)(uint32_t, rsmi_gpu_block_t, rsmi_ras_err_state_t *)
Definition: rocs.c:43
◆ access_rsmi_dev_fan_reset()
|
static |
Definition at line 3492 of file rocs.c.
3493{
3495
3497 /* Return error code as counter value to distinguish
3498 * this case from a successful read */
3501 }
3502
3503 rsmi_status_t status;
3504 status = rsmi_dev_fan_reset_p(event->device, event->subvariant);
3505 if (status != RSMI_STATUS_SUCCESS) {
3507 }
3509}
static rsmi_status_t(* rsmi_dev_fan_reset_p)(uint32_t, uint32_t)
Definition: rocs.c:44
◆ access_rsmi_dev_fan_rpms()
|
static |
Definition at line 3512 of file rocs.c.
3513{
3515
3518 }
3519
3520 rsmi_status_t status;
3521 status = rsmi_dev_fan_rpms_get_p(event->device, event->subvariant, &event->value);
3522 if (status != RSMI_STATUS_SUCCESS) {
3524 }
3526}
static rsmi_status_t(* rsmi_dev_fan_rpms_get_p)(uint32_t, uint32_t, int64_t *)
Definition: rocs.c:45
◆ access_rsmi_dev_fan_speed()
|
static |
Definition at line 3548 of file rocs.c.
3549{
3551
3553 /* Return error code as counter value to distinguish
3554 * this case from a successful read */
3557 }
3558
3559 rsmi_status_t status;
3560 status = rsmi_dev_fan_speed_get_p(event->device, event->subvariant, &event->value);
3561 if (status != RSMI_STATUS_SUCCESS) {
3563 }
3565}
static rsmi_status_t(* rsmi_dev_fan_speed_get_p)(uint32_t, uint32_t, int64_t *)
Definition: rocs.c:46
◆ access_rsmi_dev_fan_speed_max()
|
static |
Definition at line 3529 of file rocs.c.
3530{
3532
3535 }
3536
3537 rsmi_status_t status;
3538 uint64_t data;
3539 status = rsmi_dev_fan_speed_max_get_p(event->device, event->subvariant, &data);
3540 if (status != RSMI_STATUS_SUCCESS) {
3542 }
3543 event->value = (int64_t) data;
3545}
static rsmi_status_t(* rsmi_dev_fan_speed_max_get_p)(uint32_t, uint32_t, uint64_t *)
Definition: rocs.c:47
◆ access_rsmi_dev_firmware_version()
|
static |
Definition at line 3663 of file rocs.c.
3664{
3666
3669 }
3670
3671 rsmi_status_t status;
3672 uint64_t data;
3673 status = rsmi_dev_firmware_version_get_p(event->device, event->variant, &data);
3674 if (status != RSMI_STATUS_SUCCESS) {
3676 }
3677 event->value = (int64_t) data;
3679}
static rsmi_status_t(* rsmi_dev_firmware_version_get_p)(uint32_t, rsmi_fw_block_t, uint64_t *)
Definition: rocs.c:40
◆ access_rsmi_dev_gpu_clk_freq()
|
static |
Definition at line 3749 of file rocs.c.
3750{
3752
3753 if (!(mode & event->mode)) {
3754 /* Return error code as counter value to distinguish
3755 * this case from a successful read */
3758 }
3759
3760 rsmi_status_t status;
3764 if (status != RSMI_STATUS_SUCCESS) {
3766 }
3767 uint32_t current, freq_id;
3768 switch (event->subvariant) {
3771 break;
3773 current = freq_table[table_id].current;
3775 break;
3776 default:
3779 }
3780 } else {
3781 uint64_t data = (uint64_t) event->value;
3782 uint32_t freq_id = (uint32_t) (event->device * ROCS_GPU_CLK_FREQ_VARIANT__NUM + event->variant);
3783 uint64_t mask = (1 << freq_table[freq_id].num_supported) - 1;
3784 if ((data & mask) == 0) {
3786 }
3787 status = rsmi_dev_gpu_clk_freq_set_p(event->device, event->variant, data & mask);
3788 if (status != RSMI_STATUS_SUCCESS) {
3790 }
3791 }
3793}
static rsmi_status_t(* rsmi_dev_gpu_clk_freq_set_p)(uint32_t, rsmi_clk_type_t, uint64_t)
Definition: rocs.c:62
static rsmi_status_t(* rsmi_dev_gpu_clk_freq_get_p)(uint32_t, rsmi_clk_type_t, rsmi_frequencies_t *)
Definition: rocs.c:61
◆ access_rsmi_dev_id()
|
static |
Definition at line 3118 of file rocs.c.
3119{
3121
3124 }
3125
3126 rsmi_status_t status;
3127 uint16_t data;
3128 status = rsmi_dev_id_get_p(event->device, &data);
3129 if (status != RSMI_STATUS_SUCCESS) {
3131 }
3132 event->value = (int64_t) data;
3134}
static rsmi_status_t(* rsmi_dev_id_get_p)(uint32_t, uint16_t *)
Definition: rocs.c:19
◆ access_rsmi_dev_memory_busy_percent()
|
static |
Definition at line 3330 of file rocs.c.
3331{
3333
3336 }
3337
3338 rsmi_status_t status;
3339 uint32_t data;
3340 status = rsmi_dev_memory_busy_percent_get_p(event->device, &data);
3341 if (status != RSMI_STATUS_SUCCESS) {
3343 }
3344 event->value = (int64_t) data;
3346}
static rsmi_status_t(* rsmi_dev_memory_busy_percent_get_p)(uint32_t, uint32_t *)
Definition: rocs.c:33
◆ access_rsmi_dev_memory_total()
|
static |
Definition at line 3292 of file rocs.c.
3293{
3295
3298 }
3299
3300 rsmi_status_t status;
3301 uint64_t data;
3302 status = rsmi_dev_memory_total_get_p(event->device, event->variant, &data);
3303 if (status != RSMI_STATUS_SUCCESS) {
3305 }
3306 event->value = (int64_t) data;
3308}
static rsmi_status_t(* rsmi_dev_memory_total_get_p)(uint32_t, rsmi_memory_type_t, uint64_t *)
Definition: rocs.c:35
◆ access_rsmi_dev_memory_usage()
|
static |
Definition at line 3311 of file rocs.c.
3312{
3314
3317 }
3318
3319 rsmi_status_t status;
3320 uint64_t data;
3321 status = rsmi_dev_memory_usage_get_p(event->device, event->variant, &data);
3322 if (status != RSMI_STATUS_SUCCESS) {
3324 }
3325 event->value = (int64_t) data;
3327}
static rsmi_status_t(* rsmi_dev_memory_usage_get_p)(uint32_t, rsmi_memory_type_t, uint64_t *)
Definition: rocs.c:36
◆ access_rsmi_dev_name()
|
static |
◆ access_rsmi_dev_overdrive_level()
|
static |
Definition at line 3232 of file rocs.c.
3233{
3235
3236 if (!(mode & event->mode)) {
3237 /* Return error code as counter value to distinguish
3238 * this case from a successful read */
3241 }
3242
3243 rsmi_status_t status;
3244 uint32_t data;
3246 status = rsmi_dev_overdrive_level_get_p(event->device, &data);
3247 if (status != RSMI_STATUS_SUCCESS) {
3249 }
3250 event->value = (int64_t) data;
3251 } else {
3252 data = (uint32_t) event->value;
3253 status = rsmi_dev_overdrive_level_set_p(event->device, data);
3254 if (status != RSMI_STATUS_SUCCESS) {
3256 }
3257 }
3259}
static rsmi_status_t(* rsmi_dev_overdrive_level_get_p)(uint32_t, uint32_t *)
Definition: rocs.c:31
static rsmi_status_t(* rsmi_dev_overdrive_level_set_p)(uint32_t, uint32_t)
Definition: rocs.c:32
◆ access_rsmi_dev_pci_bandwidth()
|
static |
Definition at line 3796 of file rocs.c.
3797{
3799
3800 if (!(mode & event->mode)) {
3801 /* Return error code as counter value to distinguish
3802 * this case from a successful read */
3805 }
3806
3807 rsmi_status_t status;
3809 uint32_t current;
3811 if (status != RSMI_STATUS_SUCCESS) {
3813 }
3814
3815 switch (event->variant) {
3818 break;
3820 current = pcie_table[event->device].transfer_rate.current;
3822 break;
3825 current = event->subvariant;
3827 break;
3828 default:
3830 }
3831 } else {
3832 uint64_t data = (uint64_t) event->value;
3833 uint64_t mask = (1 << pcie_table[event->device].transfer_rate.num_supported) - 1;
3834 if ((data & mask) == 0) {
3836 }
3837 status = rsmi_dev_pci_bandwidth_set_p(event->device, data & mask);
3838 if (status != RSMI_STATUS_SUCCESS) {
3840 }
3841 }
3843}
static rsmi_status_t(* rsmi_dev_pci_bandwidth_set_p)(uint32_t, uint64_t)
Definition: rocs.c:60
static rsmi_status_t(* rsmi_dev_pci_bandwidth_get_p)(uint32_t, rsmi_pcie_bandwidth_t *)
Definition: rocs.c:59
◆ access_rsmi_dev_pci_id()
|
static |
Definition at line 3368 of file rocs.c.
3369{
3371
3374 }
3375
3376 rsmi_status_t status;
3377 uint64_t data;
3378 status = rsmi_dev_pci_id_get_p(event->device, &data);
3379 if (status != RSMI_STATUS_SUCCESS) {
3381 }
3382 event->value = (int64_t) data;
3384}
static rsmi_status_t(* rsmi_dev_pci_id_get_p)(uint32_t, uint64_t *)
Definition: rocs.c:56
◆ access_rsmi_dev_pci_replay_counter()
|
static |
Definition at line 3387 of file rocs.c.
3388{
3390
3393 }
3394
3395 rsmi_status_t status;
3396 uint64_t data;
3397 status = rsmi_dev_pci_replay_counter_get_p(event->device, &data);
3398 if (status != RSMI_STATUS_SUCCESS) {
3400 }
3401 event->value = (int64_t) data;
3403}
static rsmi_status_t(* rsmi_dev_pci_replay_counter_get_p)(uint32_t, uint64_t *)
Definition: rocs.c:58
◆ access_rsmi_dev_pci_throughput()
|
static |
Definition at line 3406 of file rocs.c.
3407{
3409
3412 }
3413
3414 rsmi_status_t status;
3415 uint64_t data[3];
3416 status = rsmi_dev_pci_throughput_get_p(event->device, &data[0], &data[1], &data[2]);
3417 if (status != RSMI_STATUS_SUCCESS) {
3419 }
3420
3421 switch (event->variant) {
3423 event->value = (int64_t) data[0];
3424 break;
3426 event->value = (int64_t) data[1];
3427 break;
3429 event->value = (int64_t) data[2];
3430 break;
3431 default:
3433 }
3434
3436}
static rsmi_status_t(* rsmi_dev_pci_throughput_get_p)(uint32_t, uint64_t *, uint64_t *, uint64_t *)
Definition: rocs.c:57
◆ access_rsmi_dev_perf_level()
|
static |
Definition at line 3262 of file rocs.c.
3263{
3265
3266 if (!(mode & event->mode)) {
3267 /* Return error code as counter value to distinguish
3268 * this case from a successful read */
3271 }
3272
3273 rsmi_status_t status;
3274 rsmi_dev_perf_level_t data;
3276 status = rsmi_dev_perf_level_get_p(event->device, &data);
3277 if (status != RSMI_STATUS_SUCCESS) {
3279 }
3280 event->value = (int64_t) data;
3281 } else {
3282 data = (rsmi_dev_perf_level_t) event->value;
3283 status = rsmi_dev_perf_level_set_p(event->device, data);
3284 if (status != RSMI_STATUS_SUCCESS) {
3286 }
3287 }
3289}
static rsmi_status_t(* rsmi_dev_perf_level_get_p)(uint32_t, rsmi_dev_perf_level_t *)
Definition: rocs.c:37
static rsmi_status_t(* rsmi_dev_perf_level_set_p)(int32_t, rsmi_dev_perf_level_t)
Definition: rocs.c:38
◆ access_rsmi_dev_power_ave()
|
static |
Definition at line 3568 of file rocs.c.
3569{
3571
3574 }
3575
3576 rsmi_status_t status;
3577 uint64_t data;
3578 status = rsmi_dev_power_avg_get_p(event->device, event->subvariant, &data);
3579 if (status != RSMI_STATUS_SUCCESS) {
3581 }
3582 event->value = (int64_t) data;
3584}
static rsmi_status_t(* rsmi_dev_power_avg_get_p)(uint32_t, uint32_t, uint64_t *)
Definition: rocs.c:49
◆ access_rsmi_dev_power_cap()
|
static |
Definition at line 3587 of file rocs.c.
3588{
3590
3591 if (!(mode & event->mode)) {
3592 /* Return error code as counter value to distinguish
3593 * this case from a successful read */
3596 }
3597
3598 rsmi_status_t status;
3599 uint64_t data;
3601 status = rsmi_dev_power_cap_get_p(event->device, event->subvariant, &data);
3602 if (status != RSMI_STATUS_SUCCESS) {
3604 }
3605 event->value = (int64_t) data;
3606 } else {
3607 data = (uint64_t) event->value;
3608 status = rsmi_dev_power_cap_set_p(event->device, event->subvariant, data);
3609 if (status != RSMI_STATUS_SUCCESS) {
3611 }
3612 }
3614}
static rsmi_status_t(* rsmi_dev_power_cap_set_p)(uint32_t, uint32_t, uint64_t)
Definition: rocs.c:51
static rsmi_status_t(* rsmi_dev_power_cap_get_p)(uint32_t, uint32_t, uint64_t *)
Definition: rocs.c:50
◆ access_rsmi_dev_power_cap_range()
|
static |
Definition at line 3617 of file rocs.c.
3618{
3620
3623 }
3624
3625 rsmi_status_t status;
3626 uint64_t data[2];
3627 status = rsmi_dev_power_cap_range_get_p(event->device, event->subvariant, &data[0], &data[1]);
3628 if (status != RSMI_STATUS_SUCCESS) {
3630 }
3631
3632 switch (event->variant) {
3634 event->value = (int64_t) data[1];
3635 break;
3637 event->value = (int64_t) data[0];
3638 break;
3639 default:
3641 }
3643}
static rsmi_status_t(* rsmi_dev_power_cap_range_get_p)(uint32_t, uint32_t, uint64_t *, uint64_t *)
Definition: rocs.c:52
◆ access_rsmi_dev_power_profile_presets()
|
static |
Definition at line 3439 of file rocs.c.
3440{
3442
3445 }
3446
3447 rsmi_status_t status;
3448 rsmi_power_profile_status_t profile;
3449 status = rsmi_dev_power_profile_presets_get_p(event->device, event->variant, &profile);
3450 if (status != RSMI_STATUS_SUCCESS) {
3452 }
3453
3454 switch (event->variant) {
3456 event->value = (int64_t) profile.num_profiles;
3457 break;
3459 event->value = (int64_t) profile.available_profiles;
3460 break;
3462 event->value = (int64_t) profile.current;
3463 break;
3464 default:
3466 }
3468}
static rsmi_status_t(* rsmi_dev_power_profile_presets_get_p)(uint32_t, uint32_t, rsmi_power_profile_status_t *)
Definition: rocs.c:53
◆ access_rsmi_dev_power_profile_set()
|
static |
Definition at line 3471 of file rocs.c.
3472{
3474
3476 /* Return error code as counter value to distinguish
3477 * this case from a successful read */
3480 }
3481
3482 rsmi_status_t status;
3483 rsmi_power_profile_preset_masks_t mask = (rsmi_power_profile_preset_masks_t) event->value;
3484 status = rsmi_dev_power_profile_set_p(event->device, event->variant, mask);
3485 if (status != RSMI_STATUS_SUCCESS) {
3487 }
3489}
static rsmi_status_t(* rsmi_dev_power_profile_set_p)(uint32_t, uint32_t, rsmi_power_profile_preset_masks_t)
Definition: rocs.c:54
◆ access_rsmi_dev_serial_number()
|
static |
◆ access_rsmi_dev_subsystem_id()
|
static |
Definition at line 3194 of file rocs.c.
3195{
3197
3200 }
3201
3202 rsmi_status_t status;
3203 uint16_t data;
3204 status = rsmi_dev_subsystem_id_get_p(event->device, &data);
3205 if (status != RSMI_STATUS_SUCCESS) {
3207 }
3208 event->value = (int64_t) data;
3210}
static rsmi_status_t(* rsmi_dev_subsystem_id_get_p)(uint32_t, uint16_t *)
Definition: rocs.c:27
◆ access_rsmi_dev_subsystem_name()
|
static |
◆ access_rsmi_dev_subsystem_vendor_id()
|
static |
Definition at line 3137 of file rocs.c.
3138{
3140
3143 }
3144
3145 rsmi_status_t status;
3146 uint16_t data;
3147 status = rsmi_dev_subsystem_vendor_id_get_p(event->device, &data);
3148 if (status != RSMI_STATUS_SUCCESS) {
3150 }
3151 event->value = (int64_t) data;
3153}
static rsmi_status_t(* rsmi_dev_subsystem_vendor_id_get_p)(uint32_t, uint16_t *)
Definition: rocs.c:28
◆ access_rsmi_dev_temp_metric()
|
static |
Definition at line 3646 of file rocs.c.
3647{
3649
3652 }
3653
3654 rsmi_status_t status;
3655 status = rsmi_dev_temp_metric_get_p(event->device, event->subvariant, event->variant, &event->value);
3656 if (status != RSMI_STATUS_SUCCESS) {
3658 }
3660}
static rsmi_status_t(* rsmi_dev_temp_metric_get_p)(uint32_t, uint32_t, rsmi_temperature_metric_t, int64_t *)
Definition: rocs.c:55
◆ access_rsmi_dev_unique_id()
|
static |
Definition at line 3175 of file rocs.c.
3176{
3178
3181 }
3182
3183 rsmi_status_t status;
3184 uint64_t data;
3185 status = rsmi_dev_unique_id_get_p(event->device, &data);
3186 if (status != RSMI_STATUS_SUCCESS) {
3188 }
3189 event->value = (int64_t) data;
3191}
static rsmi_status_t(* rsmi_dev_unique_id_get_p)(uint32_t, uint64_t *)
Definition: rocs.c:20
◆ access_rsmi_dev_vbios_version()
|
static |
◆ access_rsmi_dev_vendor_id()
|
static |
Definition at line 3156 of file rocs.c.
3157{
3159
3162 }
3163
3164 rsmi_status_t status;
3165 uint16_t data;
3166 status = rsmi_dev_vendor_id_get_p(event->device, &data);
3167 if (status != RSMI_STATUS_SUCCESS) {
3169 }
3170 event->value = (int64_t) data;
3172}
static rsmi_status_t(* rsmi_dev_vendor_id_get_p)(uint32_t, uint16_t *)
Definition: rocs.c:26
◆ access_rsmi_dev_vendor_name()
|
static |
◆ access_rsmi_lib_version()
|
static |
◆ access_xgmi_bw()
|
static |
Definition at line 3035 of file rocs.c.
3036{
3038
3041 }
3042
3043 rsmi_status_t status;
3044 uint64_t min, max;
3046 if (status != RSMI_STATUS_SUCCESS) {
3048 }
3049
3050 switch (event->variant) {
3053 break;
3055 event->value = (int64_t) max;
3056 break;
3057 default:
3059 }
3060
3062}
static rsmi_status_t(* rsmi_minmax_bandwidth_get_p)(uint32_t, uint32_t, uint64_t *, uint64_t *)
Definition: rocs.c:77
◆ access_xgmi_evt()
|
static |
Definition at line 3014 of file rocs.c.
3015{
3018 rsmi_status_t status;
3019 rsmi_counter_value_t value;
3020
3023 }
3024
3025 status = rsmi_counter_read_p(*(rsmi_event_handle_t *) event->scratch, &value);
3026 if (status != RSMI_STATUS_SUCCESS) {
3027 papi_errno = PAPI_EMISC;
3028 }
3029
3030 event->value = (int64_t) value.value;
3031 return papi_errno;
3032}
static rsmi_status_t(* rsmi_counter_read_p)(rsmi_event_type_t, rsmi_counter_value_t *)
Definition: rocs.c:74
◆ acquire_devices()
Definition at line 955 of file rocs.c.
956{
958 int32_t device_mask_acq = 0;
959
962 if (device_id < 0) {
963 continue;
964 }
965 device_mask_acq |= (1 << device_id);
966 }
967
970 }
971
972 device_mask |= device_mask_acq;
973 *bitmask = device_mask_acq;
974
976}
Here is the caller graph for this function:
◆ close_simple() [1/2]
|
static |
◆ close_simple() [2/2]
| int close_simple | ( | void *arg | __attribute__(unused) | ) |
◆ close_xgmi_evt()
|
static |
Definition at line 2969 of file rocs.c.
2970{
2973 rsmi_status_t status;
2974
2975 status = rsmi_dev_counter_destroy_p(*(rsmi_event_handle_t *) event->scratch);
2976 if (status != RSMI_STATUS_SUCCESS) {
2977 papi_errno = PAPI_EMISC;
2978 }
2979
2980 return papi_errno;
2981}
static rsmi_status_t(* rsmi_dev_counter_destroy_p)(rsmi_event_handle_t)
Definition: rocs.c:72
◆ get_access_func()
|
static |
◆ get_access_mode()
|
static |
◆ get_close_func()
|
static |
◆ get_event_descr()
|
static |
Definition at line 2365 of file rocs.c.
2366{
2368
2370 return strdup("Number of Devices which have monitors, accessible by rocm_smi.");
2372 return strdup("Version of RSMI lib; 0x0000MMMMmmmmpppp Major, Minor, Patch.");
2374 return strdup("Returns char* to z-terminated driver version string; do not free().");
2376 return strdup("Vendor supplied device id number. May be shared by same model devices; see pci_id for a unique identifier.");
2378 return strdup("System vendor id number.");
2380 return strdup("Vendor id number.");
2382 return strdup("Unique id for device.");
2384 return strdup("Subsystem id number.");
2386 return strdup("DRM Minor Number associated with this device.");
2388 return strdup("Overdriver Level \% for device, 0 to 20, max overclocked permitted. Read Only.");
2390 sprintf(event_descr_str, "PowerPlay Performance Level; Read Only, enum rsmi_dev_perf_level_t [0-%i], see ROCm_SMI_Manual for details.",
2391 RSMI_DEV_PERF_LEVEL_LAST);
2393 sprintf(event_descr_str, "PowerPlay Performance Level; Read/Write, enum rsmi_dev_perf_level_t [0-%i], see ROCm_SMI_Manual for details.",
2394 RSMI_DEV_PERF_LEVEL_LAST);
2396 switch (variant) {
2397 case RSMI_MEM_TYPE_VRAM:
2398 sprintf(event_descr_str, "Total VRAM memory.");
2399 break;
2400 case RSMI_MEM_TYPE_VIS_VRAM:
2401 sprintf(event_descr_str, "Total Visible VRAM memory.");
2402 break;
2403 case RSMI_MEM_TYPE_GTT:
2404 sprintf(event_descr_str, "Total Visible GTT (Graphics Translation Table) memory, aka GART memory.");
2405 break;
2406 default:
2407 return NULL;
2408 }
2410 switch (variant) {
2411 case RSMI_MEM_TYPE_VRAM:
2412 sprintf(event_descr_str, "VRAM memory in use.");
2413 break;
2414 case RSMI_MEM_TYPE_VIS_VRAM:
2415 sprintf(event_descr_str, "Visible VRAM memory in use.");
2416 break;
2417 case RSMI_MEM_TYPE_GTT:
2418 sprintf(event_descr_str, "(Graphic Translation Table) memory in use (aka GART memory).");
2419 break;
2420 default:
2421 return NULL;
2422 }
2424 return strdup("Percentage of time the device was busy doing any processing.");
2426 return strdup("Percentage_of time any device memory is being used.");
2428 return strdup("BDF (Bus/Device/Function) ID, unique per device.");
2430 return strdup("Sum of the number of NAK's received by the GPU and the NAK's generated by the GPU.");
2432 switch (variant) {
2434 return strdup("Throughput on PCIe traffic, bytes/second sent.");
2436 return strdup("Throughput on PCIe traffic, bytes/second received.");
2438 return strdup("Maximum PCIe packet size.");
2439 default:
2440 return NULL;
2441 }
2443 switch (variant) {
2445 return strdup("Number of power profile presets available. See ROCM_SMI Manual for details.");
2447 return strdup("Bit mask for available power profile presets. See ROCM_SMI Manual for details.");
2449 return strdup("Bit mask for current power profile preset. Read/Write. See ROCM_SMI Manual for details.");
2450 default:
2451 return NULL;
2452 }
2454 return strdup("Write Only, set the power profile to one of the available masks. See ROCM_SMI Manual for details.");
2456 return strdup("Fan Reset. Write Only, data value is ignored.");
2458 return strdup("Current fan speed in RPMs (Rotations Per Minute).");
2460 return strdup("Maximum possible fan speed in RPMs (Rotations Per Minute).");
2462 return strdup("Current fan speed in RPMs (Rotations Per Minute), Read Only, result [0-255].");
2464 return strdup("Current fan speed in RPMs (Rotations Per Minute), Read/Write, Write must be <= MAX (see fan_speed_max event), arg in [0-255].");
2466 return strdup("Current Average Power consumption in microwatts. Requires root privileges.");
2468 return strdup("Power cap in microwatts. Read Only. Between min/max (see power_cap_range_min/max). May require root privileges.");
2470 return strdup("Power cap in microwatts. Read/Write. Between min/max (see power_cap_range_min/max). May require root privileges.");
2472 switch (variant) {
2474 return strdup("Power cap Minimum settable value, in microwatts.");
2476 return strdup("Power cap Maximim settable value, in microwatts.");
2477 default:
2478 return NULL;
2479 }
2481 switch (variant) {
2482 case RSMI_TEMP_CURRENT:
2483 return strdup("Temperature current value, millidegrees Celsius.");
2484 case RSMI_TEMP_MAX:
2485 return strdup("Temperature maximum value, millidegrees Celsius.");
2486 case RSMI_TEMP_MIN:
2487 return strdup("Temperature minimum value, millidegrees Celsius.");
2488 case RSMI_TEMP_MAX_HYST:
2489 return strdup("Temperature hysteresis value for max limit, millidegrees Celsius.");
2490 case RSMI_TEMP_MIN_HYST:
2491 return strdup("Temperature hysteresis value for min limit, millidegrees Celsius.");
2492 case RSMI_TEMP_CRITICAL:
2493 return strdup("Temperature critical max value, typical > temp_max, millidegrees Celsius.");
2494 case RSMI_TEMP_CRITICAL_HYST:
2495 return strdup("Temperature hysteresis value for critical limit, millidegrees Celsius.");
2496 case RSMI_TEMP_EMERGENCY:
2497 return strdup("Temperature emergency max for chips supporting more than two upper temp limits, millidegrees Celsius.");
2498 case RSMI_TEMP_EMERGENCY_HYST:
2499 return strdup("Temperature hysteresis value for emergency limit, millidegrees Celsius.");
2500 case RSMI_TEMP_CRIT_MIN:
2501 return strdup("Temperature critical min value, typical < temp_min, millidegrees Celsius.");
2502 case RSMI_TEMP_CRIT_MIN_HYST:
2503 return strdup("Temperature hysteresis value for critical min limit, millidegrees Celsius.");
2504 case RSMI_TEMP_OFFSET:
2505 return strdup("Temperature offset added to temp reading by the chip, millidegrees Celsius.");
2506 case RSMI_TEMP_LOWEST:
2507 return strdup("Temperature historical minimum, millidegrees Celsius.");
2508 case RSMI_TEMP_HIGHEST:
2509 return strdup("Temperature historical maximum, millidegrees Celsius.");
2510 default:
2511 return NULL;
2512 }
2514 switch (variant) {
2515 case RSMI_FW_BLOCK_ASD:
2516 return strdup("Firmware Version Block ASD.");
2517 case RSMI_FW_BLOCK_CE:
2518 return strdup("Firmware Version Block CE.");
2519 case RSMI_FW_BLOCK_DMCU:
2520 return strdup("Firmware Version Block DMCU.");
2521 case RSMI_FW_BLOCK_MC:
2522 return strdup("Firmware Version Block MC.");
2523 case RSMI_FW_BLOCK_ME:
2524 return strdup("Firmware Version Block ME.");
2525 case RSMI_FW_BLOCK_MEC:
2526 return strdup("Firmware Version Block MEC.");
2527 case RSMI_FW_BLOCK_MEC2:
2528 return strdup("Firmware Version Block MEC2.");
2529 case RSMI_FW_BLOCK_PFP:
2530 return strdup("Firmware Version Block PFP.");
2531 case RSMI_FW_BLOCK_RLC:
2532 return strdup("Firmware Version Block RLC.");
2533 case RSMI_FW_BLOCK_RLC_SRLC:
2534 return strdup("Firmware Version Block SRLC.");
2535 case RSMI_FW_BLOCK_RLC_SRLG:
2536 return strdup("Firmware Version Block SRLG.");
2537 case RSMI_FW_BLOCK_RLC_SRLS:
2538 return strdup("Firmware Version Block SRLS.");
2539 case RSMI_FW_BLOCK_SDMA:
2540 return strdup("Firmware Version Block SDMA.");
2541 case RSMI_FW_BLOCK_SDMA2:
2542 return strdup("Firmware Version Block SDMA2.");
2543 case RSMI_FW_BLOCK_SMC:
2544 return strdup("Firmware Version Block SMC.");
2545 case RSMI_FW_BLOCK_SOS:
2546 return strdup("Firmware Version Block SOS.");
2547 case RSMI_FW_BLOCK_TA_RAS:
2548 return strdup("Firmware Version Block RAS.");
2549 case RSMI_FW_BLOCK_TA_XGMI:
2550 return strdup("Firmware Version Block XGMI.");
2551 case RSMI_FW_BLOCK_UVD:
2552 return strdup("Firmware Version Block UVD.");
2553 case RSMI_FW_BLOCK_VCE:
2554 return strdup("Firmware Version Block VCE.");
2555 case RSMI_FW_BLOCK_VCN:
2556 return strdup("Firmware Version Block VCN.");
2557 default:
2558 return NULL;
2559 }
2561 const char *block = NULL;
2562 switch (variant) {
2563 case RSMI_GPU_BLOCK_UMC:
2564 block = "UMC";
2565 break;
2566 case RSMI_GPU_BLOCK_SDMA:
2567 block = "SDMA";
2568 break;
2569 case RSMI_GPU_BLOCK_GFX:
2570 block = "GFX";
2571 break;
2572 case RSMI_GPU_BLOCK_MMHUB:
2573 block = "MMHUB";
2574 break;
2575 case RSMI_GPU_BLOCK_ATHUB:
2576 block = "ATHUB";
2577 break;
2578 case RSMI_GPU_BLOCK_PCIE_BIF:
2579 block = "PCIE_BIF";
2580 break;
2581 case RSMI_GPU_BLOCK_HDP:
2582 block = "HDP";
2583 break;
2584 case RSMI_GPU_BLOCK_XGMI_WAFL:
2585 block = "XGMI_WAFL";
2586 break;
2587 case RSMI_GPU_BLOCK_DF:
2588 block = "DF";
2589 break;
2590 case RSMI_GPU_BLOCK_SMN:
2591 block = "SMN";
2592 break;
2593 case RSMI_GPU_BLOCK_SEM:
2594 block = "SEM";
2595 break;
2596 case RSMI_GPU_BLOCK_MP0:
2597 block = "MP0";
2598 break;
2599 case RSMI_GPU_BLOCK_MP1:
2600 block = "MP1";
2601 break;
2602 case RSMI_GPU_BLOCK_FUSE:
2603 block = "FUSE";
2604 break;
2605 default:
2606 return NULL;
2607 }
2608
2609 switch (subvariant) {
2611 sprintf(event_descr_str, "Correctable error count for the GPU Block %s.", block);
2612 break;
2614 sprintf(event_descr_str, "Uncorrectable error count for the GPU Block %s.", block);
2615 break;
2616 default:
2617 return NULL;
2618 }
2620 return strdup("Bit mask of GPU blocks with ecc error counting enabled.");
2622 switch (variant) {
2623 case RSMI_GPU_BLOCK_UMC:
2624 return strdup("ECC Error Status for the GPU Block UMC.");
2625 case RSMI_GPU_BLOCK_SDMA:
2626 return strdup("ECC Error Status for the GPU Block SDMA.");
2627 case RSMI_GPU_BLOCK_GFX:
2628 return strdup("ECC Error Status for the GPU Block GFX.");
2629 case RSMI_GPU_BLOCK_MMHUB:
2630 return strdup("ECC Error Status for the GPU Block MMHUB.");
2631 case RSMI_GPU_BLOCK_ATHUB:
2632 return strdup("ECC Error Status for the GPU Block ATHUB.");
2633 case RSMI_GPU_BLOCK_PCIE_BIF:
2634 return strdup("ECC Error Status for the GPU Block BIF.");
2635 case RSMI_GPU_BLOCK_HDP:
2636 return strdup("ECC Error Status for the GPU Block HDP.");
2637 case RSMI_GPU_BLOCK_XGMI_WAFL:
2638 return strdup("ECC Error Status for the GPU Block WAFL.");
2639 case RSMI_GPU_BLOCK_DF:
2640 return strdup("ECC Error Status for the GPU Block DF.");
2641 case RSMI_GPU_BLOCK_SMN:
2642 return strdup("ECC Error Status for the GPU Block SMN.");
2643 case RSMI_GPU_BLOCK_SEM:
2644 return strdup("ECC Error Status for the GPU Block SEM.");
2645 case RSMI_GPU_BLOCK_MP0:
2646 return strdup("ECC Error Status for the GPU Block MP0.");
2647 case RSMI_GPU_BLOCK_MP1:
2648 return strdup("ECC Error Status for the GPU Block MP1.");
2649 case RSMI_GPU_BLOCK_FUSE:
2650 return strdup("ECC Error Status for the GPU Block FUSE.");
2651 default:
2652 return NULL;
2653 }
2655 const char *variant_str = NULL;
2656 switch (variant) {
2658 variant_str = "System";
2659 break;
2661 variant_str = "DataFabric";
2662 break;
2664 variant_str = "DisplayEngine";
2665 break;
2667 variant_str = "SOC";
2668 break;
2670 variant_str = "Memory";
2671 break;
2672 default:
2673 return NULL;
2674 }
2675
2676 int idx;
2677 switch (subvariant) {
2679 return strdup("Number of frequencies available.");
2681 return strdup("Current operating frequency.");
2682 default:
2683 idx = subvariant - ROCS_GPU_CLK_FREQ_SUBVARIANT__NUM;
2684 }
2685
2686 sprintf(event_descr_str, "Returns %s frequency value for supported_table[%u].", variant_str, idx);
2688 const char *variant_str = NULL;
2689 switch (variant) {
2691 variant_str = "System";
2692 break;
2694 variant_str = "DataFabric";
2695 break;
2697 variant_str = "DisplayEngine";
2698 break;
2700 variant_str = "SOC";
2701 break;
2703 variant_str = "Memory";
2704 break;
2705 default:
2706 return NULL;
2707 }
2708 sprintf(event_descr_str, "Write Only. Sets bit mask, 1's for %s frequency value in support table permitted. All 0 mask prohibited.",
2709 variant_str);
2711 switch (variant) {
2713 return strdup("Number of PCI transfers rates available.");
2715 return strdup("Current PCI transfer rate.");
2717 sprintf(event_descr_str, "Returns PCI bandwidth rate value from supported_table[%i].", (int) subvariant);
2718 break;
2720 sprintf(event_descr_str, "Returns PCI bandwidth rate corresponding lane count from supported_table[%i].", (int) subvariant);
2721 break;
2722 default:
2723 return NULL;
2724 }
2726 return strdup("Write Only. Sets bit mask, 1's for PCI transfer rates in supported_table permitted. All 0 mask prohibited");
2728 return strdup("Returns char* to z-terminated brand string; do not free().");
2730 return strdup("Returns char* to z-terminated name string; do not free().");
2732 return strdup("Returns char* to z-terminated serial number string; do not free().");
2734 return strdup("Returns char* to z-terminated subsystem name string; do not free().");
2736 return strdup("Returns char* to z-terminated vbios version string; do not free().");
2738 return strdup("Returns char* to z-terminated vendor name string; do not free().");
2740 const char *variant_str = NULL;
2741 switch (variant) {
2743 variant_str = "NOP operations sent to neightbor 0.";
2744 break;
2746 variant_str = "Outgoing requests to neighbor 0.";
2747 break;
2749 variant_str = "Outgoing responses sent to neighbor 0.";
2750 break;
2752 variant_str = "Data beats sent to neighbor 0.";
2753 break;
2755 variant_str = "NOP operations sent to neightbor 1.";
2756 break;
2758 variant_str = "Outgoing requests to neighbor 1.";
2759 break;
2761 variant_str = "Outgoing responses sent to neighbor 1.";
2762 break;
2764 variant_str = "Data beats sent to neighbor 1.";
2765 break;
2767 variant_str = "Data beats sent to neighbor 0.";
2768 break;
2770 variant_str = "Data beats sent to neighbor 1.";
2771 break;
2773 variant_str = "Data beats sent to neighbor 2.";
2774 break;
2776 variant_str = "Data beats sent to neighbor 3.";
2777 break;
2779 variant_str = "Data beats sent to neighbor 4.";
2780 break;
2782 variant_str = "Data beats sent to neighbor 5.";
2783 break;
2784 default:
2785 return NULL;
2786 }
2787 sprintf(event_descr_str, "%s", variant_str);
2789 switch (variant) {
2791 sprintf(event_descr_str, "%s.", "Minimum bandwidth between devices");
2792 break;
2794 sprintf(event_descr_str, "%s.", "Maximum bandwidth between devices");
2795 break;
2796 default:
2797 return NULL;
2798 }
2799 } else {
2800 return NULL;
2801 }
2802
2803 return strdup(event_descr_str);
2804}
Here is the caller graph for this function:
◆ get_event_name()
|
static |
Definition at line 1856 of file rocs.c.
1857{
1859
1861 return strdup("NUMDevices");
1863 return strdup("rsmi_version");
1865 return strdup("driver_version_str");
1867 sprintf(event_name_str, "device_id:device=%i", dev);
1869 sprintf(event_name_str, "subsystem_vendor_id:device=%i", dev);
1871 sprintf(event_name_str, "vendor_id:device=%i", dev);
1873 sprintf(event_name_str, "unique_id:device=%i", dev);
1875 sprintf(event_name_str, "subsystem_id:device=%i", dev);
1877 sprintf(event_name_str, "drm_render_minor:device=%i", dev);
1879 sprintf(event_name_str, "overdrive_level:device=%i", dev);
1881 sprintf(event_name_str, "perf_level:device=%i", dev);
1883 switch (variant) {
1884 case RSMI_MEM_TYPE_VRAM:
1885 sprintf(event_name_str, "mem_total_VRAM:device=%i", dev);
1886 break;
1887 case RSMI_MEM_TYPE_VIS_VRAM:
1888 sprintf(event_name_str, "mem_total_VIS_VRAM:device=%i", dev);
1889 break;
1890 case RSMI_MEM_TYPE_GTT:
1891 sprintf(event_name_str, "mem_total_GTT:device=%i", dev);
1892 break;
1893 default:
1894 return NULL;
1895 }
1897 switch (variant) {
1898 case RSMI_MEM_TYPE_VRAM:
1899 sprintf(event_name_str, "mem_usage_VRAM:device=%i", dev);
1900 break;
1901 case RSMI_MEM_TYPE_VIS_VRAM:
1902 sprintf(event_name_str, "mem_usage_VIS_VRAM:device=%i", dev);
1903 break;
1904 case RSMI_MEM_TYPE_GTT:
1905 sprintf(event_name_str, "mem_usage_GTT:device=%i", dev);
1906 break;
1907 default:
1908 return NULL;
1909 }
1911 sprintf(event_name_str, "busy_percent:device=%i", dev);
1913 sprintf(event_name_str, "memory_busy_percent:device=%i", dev);
1915 sprintf(event_name_str, "pci_id:device=%i", dev);
1917 sprintf(event_name_str, "pci_replay_counter:device=%i", dev);
1919 switch (variant) {
1921 sprintf(event_name_str, "pci_throughput_sent:device=%i", dev);
1922 break;
1924 sprintf(event_name_str, "pci_throughput_received:device=%i", dev);
1925 break;
1927 sprintf(event_name_str, "pci_max_packet_size:device=%i", dev);
1928 break;
1929 default:
1930 return NULL;
1931 }
1933 switch (variant) {
1935 sprintf(event_name_str, "power_profiler_presets:device=%i:count", dev);
1936 break;
1938 sprintf(event_name_str, "power_profiler_presets:device=%i:avail_profiles", dev);
1939 break;
1941 sprintf(event_name_str, "power_profiler_presets:device=%i:current", dev);
1942 break;
1943 default:
1944 return NULL;
1945 }
1947 sprintf(event_name_str, "power_profile_set:device=%i", dev);
1949 sprintf(event_name_str, "fan_reset:device=%i:sensor=%i", dev, (int) subvariant);
1951 sprintf(event_name_str, "fan_rpms:device=%i:sensor=%i", dev, (int) subvariant);
1953 sprintf(event_name_str, "fan_speed_max:device=%i:sensor=%i", dev, (int) subvariant);
1954 } else if (strcmp(name, "rsmi_dev_fan_speed_get") == 0 || strcmp(name, "rsmi_dev_fan_speed_set") == 0) {
1955 sprintf(event_name_str, "fan_speed:device=%i:sensor=%i", dev, (int) subvariant);
1957 sprintf(event_name_str, "power_average:device=%i:sensor=%i", dev, (int) subvariant);
1958 } else if (strcmp(name, "rsmi_dev_power_cap_get") == 0 || strcmp(name, "rsmi_dev_power_cap_set") == 0) {
1959 sprintf(event_name_str, "power_cap:device=%i:sensor=%i", dev, (int) subvariant);
1961 switch (variant) {
1963 sprintf(event_name_str, "power_cap_range_min:device=%i:sensor=%i", dev, (int) subvariant);
1964 break;
1966 sprintf(event_name_str, "power_cap_range_max:device=%i:sensor=%i", dev, (int) subvariant);
1967 break;
1968 default:
1969 return NULL;
1970 }
1972 switch (variant) {
1973 case RSMI_TEMP_CURRENT:
1974 sprintf(event_name_str, "temp_current:device=%i:sensor=%i", dev, (int) subvariant);
1975 break;
1976 case RSMI_TEMP_MAX:
1977 sprintf(event_name_str, "temp_max:device=%i:sensor=%i", dev, (int) subvariant);
1978 break;
1979 case RSMI_TEMP_MIN:
1980 sprintf(event_name_str, "temp_min:device=%i:sensor=%i", dev, (int) subvariant);
1981 break;
1982 case RSMI_TEMP_MAX_HYST:
1983 sprintf(event_name_str, "temp_max_hyst:device=%i:sensor=%i", dev, (int) subvariant);
1984 break;
1985 case RSMI_TEMP_MIN_HYST:
1986 sprintf(event_name_str, "temp_min_hyst:device=%i:sensor=%i", dev, (int) subvariant);
1987 break;
1988 case RSMI_TEMP_CRITICAL:
1989 sprintf(event_name_str, "temp_critical:device=%i:sensor=%i", dev, (int) subvariant);
1990 break;
1991 case RSMI_TEMP_CRITICAL_HYST:
1992 sprintf(event_name_str, "temp_critical_hyst:device=%i:sensor=%i", dev, (int) subvariant);
1993 break;
1994 case RSMI_TEMP_EMERGENCY:
1995 sprintf(event_name_str, "temp_emergency:device=%i:sensor=%i", dev, (int) subvariant);
1996 break;
1997 case RSMI_TEMP_EMERGENCY_HYST:
1998 sprintf(event_name_str, "temp_emergency_hyst:device=%i:sensor=%i", dev, (int) subvariant);
1999 break;
2000 case RSMI_TEMP_CRIT_MIN:
2001 sprintf(event_name_str, "temp_crit_min:device=%i:sensor=%i", dev, (int) subvariant);
2002 break;
2003 case RSMI_TEMP_CRIT_MIN_HYST:
2004 sprintf(event_name_str, "temp_crit_min_hyst:device=%i:sensor=%i", dev, (int) subvariant);
2005 break;
2006 case RSMI_TEMP_OFFSET:
2007 sprintf(event_name_str, "temp_offset:device=%i:sensor=%i", dev, (int) subvariant);
2008 break;
2009 case RSMI_TEMP_LOWEST:
2010 sprintf(event_name_str, "temp_lowest:device=%i:sensor=%i", dev, (int) subvariant);
2011 break;
2012 case RSMI_TEMP_HIGHEST:
2013 sprintf(event_name_str, "temp_highest:device=%i:sensor=%i", dev, (int) subvariant);
2014 break;
2015 default:
2016 return NULL;
2017 }
2019 switch (variant) {
2020 case RSMI_FW_BLOCK_ASD:
2021 sprintf(event_name_str, "firmware_version:device=%i:block=ASD", dev);
2022 break;
2023 case RSMI_FW_BLOCK_CE:
2024 sprintf(event_name_str, "firmware_version:device=%i:block=CE", dev);
2025 break;
2026 case RSMI_FW_BLOCK_DMCU:
2027 sprintf(event_name_str, "firmware_version:device=%i:block=DMCU", dev);
2028 break;
2029 case RSMI_FW_BLOCK_MC:
2030 sprintf(event_name_str, "firmware_version:device=%i:block=MC", dev);
2031 break;
2032 case RSMI_FW_BLOCK_ME:
2033 sprintf(event_name_str, "firmware_version:device=%i:block=ME", dev);
2034 break;
2035 case RSMI_FW_BLOCK_MEC:
2036 sprintf(event_name_str, "firmware_version:device=%i:block=MEC", dev);
2037 break;
2038 case RSMI_FW_BLOCK_MEC2:
2039 sprintf(event_name_str, "firmware_version:device=%i:block=MEC2", dev);
2040 break;
2041 case RSMI_FW_BLOCK_PFP:
2042 sprintf(event_name_str, "firmware_version:device=%i:block=PFP", dev);
2043 break;
2044 case RSMI_FW_BLOCK_RLC:
2045 sprintf(event_name_str, "firmware_version:device=%i:block=RLC", dev);
2046 break;
2047 case RSMI_FW_BLOCK_RLC_SRLC:
2048 sprintf(event_name_str, "firmware_version:device=%i:block=SRLC", dev);
2049 break;
2050 case RSMI_FW_BLOCK_RLC_SRLG:
2051 sprintf(event_name_str, "firmware_version:device=%i:block=SRLG", dev);
2052 break;
2053 case RSMI_FW_BLOCK_RLC_SRLS:
2054 sprintf(event_name_str, "firmware_version:device=%i:block=SRLS", dev);
2055 break;
2056 case RSMI_FW_BLOCK_SDMA:
2057 sprintf(event_name_str, "firmware_version:device=%i:block=SDMA", dev);
2058 break;
2059 case RSMI_FW_BLOCK_SDMA2:
2060 sprintf(event_name_str, "firmware_version:device=%i:block=SDMA2", dev);
2061 break;
2062 case RSMI_FW_BLOCK_SMC:
2063 sprintf(event_name_str, "firmware_version:device=%i:block=SMC", dev);
2064 break;
2065 case RSMI_FW_BLOCK_SOS:
2066 sprintf(event_name_str, "firmware_version:device=%i:block=SOS", dev);
2067 break;
2068 case RSMI_FW_BLOCK_TA_RAS:
2069 sprintf(event_name_str, "firmware_version:device=%i:block=RAS", dev);
2070 break;
2071 case RSMI_FW_BLOCK_TA_XGMI:
2072 sprintf(event_name_str, "firmware_version:device=%i:block=XGMI", dev);
2073 break;
2074 case RSMI_FW_BLOCK_UVD:
2075 sprintf(event_name_str, "firmware_version:device=%i:block=UVD", dev);
2076 break;
2077 case RSMI_FW_BLOCK_VCE:
2078 sprintf(event_name_str, "firmware_version:device=%i:block=VCE", dev);
2079 break;
2080 case RSMI_FW_BLOCK_VCN:
2081 sprintf(event_name_str, "firmware_version:device=%i:block=VCN", dev);
2082 break;
2083 default:
2084 return NULL;
2085 }
2087 const char *block = NULL;
2088 switch (variant) {
2089 case RSMI_GPU_BLOCK_UMC:
2090 block = "UMC";
2091 break;
2092 case RSMI_GPU_BLOCK_SDMA:
2093 block = "SDMA";
2094 break;
2095 case RSMI_GPU_BLOCK_GFX:
2096 block = "GFX";
2097 break;
2098 case RSMI_GPU_BLOCK_MMHUB:
2099 block = "MMHUB";
2100 break;
2101 case RSMI_GPU_BLOCK_ATHUB:
2102 block = "ATHUB";
2103 break;
2104 case RSMI_GPU_BLOCK_PCIE_BIF:
2105 block = "PCIE_BIF";
2106 break;
2107 case RSMI_GPU_BLOCK_HDP:
2108 block = "HDP";
2109 break;
2110 case RSMI_GPU_BLOCK_XGMI_WAFL:
2111 block = "XGMI_WAFL";
2112 break;
2113 case RSMI_GPU_BLOCK_DF:
2114 block = "DF";
2115 break;
2116 case RSMI_GPU_BLOCK_SMN:
2117 block = "SMN";
2118 break;
2119 case RSMI_GPU_BLOCK_SEM:
2120 block = "SEM";
2121 break;
2122 case RSMI_GPU_BLOCK_MP0:
2123 block = "MP0";
2124 break;
2125 case RSMI_GPU_BLOCK_MP1:
2126 block = "MP1";
2127 break;
2128 case RSMI_GPU_BLOCK_FUSE:
2129 block = "FUSE";
2130 break;
2131 default:
2132 return NULL;
2133 }
2134
2135 switch (subvariant) {
2137 sprintf(event_name_str, "ecc_count_correctable:device=%i:block=%s", dev, block);
2138 break;
2140 sprintf(event_name_str, "ecc_count_uncorrectable:device=%i:block=%s", dev, block);
2141 break;
2142 default:
2143 return NULL;
2144 }
2146 sprintf(event_name_str, "ecc_enabled_get:device=%i", dev);
2148 const char *block = NULL;
2149 switch (variant) {
2150 case RSMI_GPU_BLOCK_UMC:
2151 block = "UMC";
2152 break;
2153 case RSMI_GPU_BLOCK_SDMA:
2154 block = "SDMA";
2155 break;
2156 case RSMI_GPU_BLOCK_GFX:
2157 block = "GFX";
2158 break;
2159 case RSMI_GPU_BLOCK_MMHUB:
2160 block = "MMHUB";
2161 break;
2162 case RSMI_GPU_BLOCK_ATHUB:
2163 block = "ATHUB";
2164 break;
2165 case RSMI_GPU_BLOCK_PCIE_BIF:
2166 block = "PCIE_BIF";
2167 break;
2168 case RSMI_GPU_BLOCK_HDP:
2169 block = "HDP";
2170 break;
2171 case RSMI_GPU_BLOCK_XGMI_WAFL:
2172 block = "XGMI_WAFL";
2173 break;
2174 case RSMI_GPU_BLOCK_DF:
2175 block = "DF";
2176 break;
2177 case RSMI_GPU_BLOCK_SMN:
2178 block = "SMN";
2179 break;
2180 case RSMI_GPU_BLOCK_SEM:
2181 block = "SEM";
2182 break;
2183 case RSMI_GPU_BLOCK_MP0:
2184 block = "MP0";
2185 break;
2186 case RSMI_GPU_BLOCK_MP1:
2187 block = "MP1";
2188 break;
2189 case RSMI_GPU_BLOCK_FUSE:
2190 block = "FUSE";
2191 break;
2192 default:
2193 return NULL;
2194 }
2195 sprintf(event_name_str, "ecc_status:device=%i:block=%s", dev, block);
2197 const char *variant_str = NULL;
2198 switch (variant) {
2200 variant_str = "System";
2201 break;
2203 variant_str = "DataFabric";
2204 break;
2206 variant_str = "DisplayEngine";
2207 break;
2209 variant_str = "SOC";
2210 break;
2212 variant_str = "Memory";
2213 break;
2214 default:
2215 return NULL;
2216 }
2217
2218 int idx;
2219 const char *subvariant_str = NULL;
2220 switch (subvariant) {
2222 subvariant_str = "count";
2223 break;
2225 subvariant_str = "current";
2226 break;
2227 default:
2228 idx = subvariant - ROCS_GPU_CLK_FREQ_SUBVARIANT__NUM;
2229 }
2230
2232 sprintf(event_name_str, "gpu_clk_freq_%s:device=%i:%s", variant_str, dev, subvariant_str);
2233 } else {
2234 sprintf(event_name_str, "gpu_clk_freq_%s:device=%i:idx=%i", variant_str, dev, idx);
2235 }
2237 const char *variant_str = NULL;
2238 switch (variant) {
2240 variant_str = "System";
2241 break;
2243 variant_str = "DataFabric";
2244 break;
2246 variant_str = "DisplayEngine";
2247 break;
2249 variant_str = "SOC";
2250 break;
2252 variant_str = "Memory";
2253 break;
2254 default:
2255 return NULL;
2256 }
2257
2258 sprintf(event_name_str, "gpu_clk_freq_%s:device=%i:mask", variant_str, dev);
2260 const char *variant_str = NULL;
2261 switch (variant) {
2263 variant_str = "count";
2264 break;
2266 variant_str = "current";
2267 break;
2269 variant_str = "rate_idx";
2270 break;
2272 variant_str = "lane_idx";
2273 break;
2274 default:
2275 return NULL;
2276 }
2277
2279 sprintf(event_name_str, "pci_bandwidth_rate:device=%i:%s", dev, variant_str);
2280 } else {
2281 sprintf(event_name_str, "pci_bandwidth_rate:device=%i:%s=%i", dev, variant_str, (int) subvariant);
2282 }
2284 sprintf(event_name_str, "pci_bandwidth_rate:device=%i:mask", dev);
2286 sprintf(event_name_str, "device_brand:device=%i", dev);
2288 sprintf(event_name_str, "device_name:device=%i", dev);
2290 sprintf(event_name_str, "device_serial_number:device=%i", dev);
2292 sprintf(event_name_str, "device_subsystem_name:device=%i", dev);
2294 sprintf(event_name_str, "vbios_version:device=%i", dev);
2296 sprintf(event_name_str, "vendor_name:device=%i", dev);
2298 const char *variant_str = NULL;
2299 switch (variant) {
2301 variant_str = "nop_sent_to_neighbor0";
2302 break;
2304 variant_str = "req_sent_to_neighbor0";
2305 break;
2307 variant_str = "res_sent_to_neighbor0";
2308 break;
2310 variant_str = "data_beats_sent_to_neighbor0";
2311 break;
2313 variant_str = "nop_sent_to_neighbor1";
2314 break;
2316 variant_str = "req_sent_to_neighbor1";
2317 break;
2319 variant_str = "res_sent_to_neighbor1";
2320 break;
2322 variant_str = "data_beats_sent_to_neighbor1";
2323 break;
2325 variant_str = "data_beats_sent_to_neighbor0";
2326 break;
2328 variant_str = "data_beats_sent_to_neighbor1";
2329 break;
2331 variant_str = "data_beats_sent_to_neighbor2";
2332 break;
2334 variant_str = "data_beats_sent_to_neighbor3";
2335 break;
2337 variant_str = "data_beats_sent_to_neighbor4";
2338 break;
2340 variant_str = "data_beats_sent_to_neighbor5";
2341 break;
2342 default:
2343 return NULL;
2344 }
2345 sprintf(event_name_str, "xgmi_%s:device=%i", variant_str, dev);
2347 switch (variant) {
2349 sprintf(event_name_str, "min_xgmi_internode_bw:device=%i:target=%i", dev, (int) subvariant);
2350 break;
2352 sprintf(event_name_str, "max_xgmi_internode_bw:device=%i:target=%i", dev, (int) subvariant);
2353 break;
2354 default:
2355 return NULL;
2356 }
2357 } else {
2358 return NULL;
2359 }
2360
2361 return strdup(event_name_str);
2362}
Here is the caller graph for this function:
◆ get_ntv_events()
|
static |
Definition at line 1183 of file rocs.c.
1184{
1186 rsmi_func_id_iter_handle_t iter;
1187 rsmi_func_id_iter_handle_t var_iter;
1188 rsmi_func_id_iter_handle_t subvar_iter;
1189 rsmi_func_id_value_t v_name;
1190 rsmi_func_id_value_t v_variant;
1191 rsmi_func_id_value_t v_subvariant;
1192 rsmi_status_t status;
1193 int events_count = 0;
1194
1195 const char *first_events[] = {
1196 "rsmi_dev_count",
1197 "rsmi_lib_version",
1198 "rsmi_dev_driver_version_str_get",
1199 };
1200
1203 events[events_count].id = events_count;
1206 events[events_count].device = -1;
1207 events[events_count].variant = -1;
1208 events[events_count].subvariant = -1;
1216 ++events_count;
1217 }
1218
1219 int32_t dev;
1222 if (status != RSMI_STATUS_SUCCESS) {
1223 continue;
1224 }
1225 while (1) {
1227 if (status != RSMI_STATUS_SUCCESS) {
1228 continue;
1229 }
1231 if (status == RSMI_STATUS_NO_DATA) {
1232 if (handle_special_events(v_name.name, dev, -1, -1, &events_count, events) == ROCS_EVENT_TYPE__NORMAL) {
1235 /* add known events */
1236 events[events_count].id = events_count;
1239 events[events_count].device = dev;
1240 events[events_count].variant = -1;
1241 events[events_count].subvariant = -1;
1249 ++events_count;
1250 }
1251 }
1252 } else {
1253 while (status != RSMI_STATUS_NO_DATA) {
1254 status = rsmi_func_iter_value_get_p(var_iter, &v_variant);
1255 if (status != RSMI_STATUS_SUCCESS) {
1256 continue;
1257 }
1258 status = rsmi_dev_supported_variant_iterator_open_p(var_iter, &subvar_iter);
1259 if (status == RSMI_STATUS_NO_DATA) {
1260 if (handle_special_events(v_name.name, dev, v_variant.id, -1, &events_count, events) == ROCS_EVENT_TYPE__NORMAL) {
1263 /* add known events */
1264 events[events_count].id = events_count;
1267 events[events_count].device = dev;
1268 events[events_count].variant = v_variant.id;
1269 events[events_count].subvariant = -1;
1277 ++events_count;
1278 }
1279 }
1280 } else {
1281 while (status != RSMI_STATUS_NO_DATA) {
1282 status = rsmi_func_iter_value_get_p(subvar_iter, &v_subvariant);
1283 if (status != RSMI_STATUS_SUCCESS) {
1284 continue;
1285 }
1286 if (handle_special_events(v_name.name, dev, v_variant.id, v_subvariant.id, &events_count, events) == ROCS_EVENT_TYPE__NORMAL) {
1289 /* add known events */
1290 events[events_count].id = events_count;
1293 events[events_count].device = dev;
1294 events[events_count].variant = v_variant.id;
1295 events[events_count].subvariant = v_subvariant.id;
1303 ++events_count;
1304 }
1305 }
1306 status = rsmi_func_iter_next_p(subvar_iter);
1307 }
1308 status = rsmi_dev_supported_func_iterator_close_p(&subvar_iter);
1309 if (status != RSMI_STATUS_SUCCESS) {
1310 papi_errno = PAPI_EMISC;
1311 goto fn_fail;
1312 }
1313 }
1314 status = rsmi_func_iter_next_p(var_iter);
1315 }
1316 status = rsmi_dev_supported_func_iterator_close_p(&var_iter);
1317 if (status != RSMI_STATUS_SUCCESS) {
1318 papi_errno = PAPI_EMISC;
1319 goto fn_fail;
1320 }
1321 }
1323 if (status == RSMI_STATUS_NO_DATA) {
1324 break;
1325 }
1326 }
1328 if (status != RSMI_STATUS_SUCCESS) {
1329 papi_errno = PAPI_EMISC;
1330 goto fn_fail;
1331 }
1332
1334 }
1335
1337
1338 fn_exit:
1339 return papi_errno;
1340 fn_fail:
1341 goto fn_exit;
1342}
static int htable_insert(void *handle, const char *key, void *in)
Definition: cuda/htable.h:92
static int handle_xgmi_events(int32_t dev, int *count, ntv_event_t *events)
Definition: rocs.c:1770
static int handle_special_events(const char *name, int32_t dev, int64_t variant, int64_t subvariant, int *count, ntv_event_t *events)
Definition: rocs.c:1485
static rsmi_status_t(* rsmi_dev_supported_variant_iterator_open_p)(rsmi_func_id_iter_handle_t, rsmi_func_id_iter_handle_t *)
Definition: rocs.c:18
static char * get_event_name(const char *name, int32_t dev, int64_t variant, int64_t subvariant)
Definition: rocs.c:1856
static rsmi_status_t(* rsmi_func_iter_next_p)(rsmi_func_id_iter_handle_t)
Definition: rocs.c:15
static rsmi_status_t(* rsmi_dev_supported_func_iterator_open_p)(uint32_t, rsmi_func_id_iter_handle_t *)
Definition: rocs.c:16
static char * get_event_descr(const char *name, int64_t variant, int64_t subvariant)
Definition: rocs.c:2365
static rsmi_status_t(* rsmi_func_iter_value_get_p)(rsmi_func_id_iter_handle_t, rsmi_func_id_value_t *)
Definition: rocs.c:14
static rsmi_status_t(* rsmi_dev_supported_func_iterator_close_p)(rsmi_func_id_iter_handle_t *)
Definition: rocs.c:17
Here is the call graph for this function:
Here is the caller graph for this function:
◆ get_ntv_events_count()
Definition at line 1071 of file rocs.c.
1072{
1075 rsmi_func_id_iter_handle_t iter;
1076 rsmi_func_id_iter_handle_t var_iter;
1077 rsmi_func_id_iter_handle_t subvar_iter;
1078 rsmi_func_id_value_t v_name;
1079 rsmi_func_id_value_t v_variant;
1080 rsmi_func_id_value_t v_subvariant;
1081 rsmi_status_t status;
1082
1083 int32_t dev;
1086 if (status != RSMI_STATUS_SUCCESS) {
1087 continue;
1088 }
1089 while (1) {
1091 if (status != RSMI_STATUS_SUCCESS) {
1092 continue;
1093 }
1095 if (status == RSMI_STATUS_NO_DATA) {
1096 if (handle_special_events_count(v_name.name, dev, -1, -1, &events_count) == ROCS_EVENT_TYPE__NORMAL) {
1099 /* count known events */
1100 ++events_count;
1102 }
1103 }
1104 } else {
1105 while (status != RSMI_STATUS_NO_DATA) {
1106 status = rsmi_func_iter_value_get_p(var_iter, &v_variant);
1107 if (status != RSMI_STATUS_SUCCESS) {
1108 continue;
1109 }
1110 status = rsmi_dev_supported_variant_iterator_open_p(var_iter, &subvar_iter);
1111 if (status == RSMI_STATUS_NO_DATA) {
1112 if (handle_special_events_count(v_name.name, dev, v_variant.id, -1, &events_count) == ROCS_EVENT_TYPE__NORMAL) {
1115 /* count known events */
1116 ++events_count;
1118 }
1119 }
1120 } else {
1121 while (status != RSMI_STATUS_NO_DATA) {
1122 status = rsmi_func_iter_value_get_p(subvar_iter, &v_subvariant);
1123 if (status != RSMI_STATUS_SUCCESS) {
1124 continue;
1125 }
1126 if (handle_special_events_count(v_name.name, dev, v_variant.id, v_subvariant.id, &events_count) == ROCS_EVENT_TYPE__NORMAL) {
1129 /* count known events */
1130 ++events_count;
1132 }
1133 }
1134 status = rsmi_func_iter_next_p(subvar_iter);
1135 }
1136 status = rsmi_dev_supported_func_iterator_close_p(&subvar_iter);
1137 if (status != RSMI_STATUS_SUCCESS) {
1138 papi_errno = PAPI_EMISC;
1139 goto fn_fail;
1140 }
1141 }
1142 status = rsmi_func_iter_next_p(var_iter);
1143 }
1144 status = rsmi_dev_supported_func_iterator_close_p(&var_iter);
1145 if (status != RSMI_STATUS_SUCCESS) {
1146 papi_errno = PAPI_EMISC;
1147 goto fn_fail;
1148 }
1149 }
1151 if (status == RSMI_STATUS_NO_DATA) {
1152 break;
1153 }
1154 }
1156 if (status != RSMI_STATUS_SUCCESS) {
1157 papi_errno = PAPI_EMISC;
1158 goto fn_fail;
1159 }
1160
1161 handle_xgmi_events_count(dev, &events_count);
1162 }
1163
1164 *count = events_count;
1165
1166 fn_exit:
1167 return papi_errno;
1168 fn_fail:
1169 goto fn_exit;
1170}
static int handle_xgmi_events_count(int32_t dev, int *count)
Definition: rocs.c:1446
static int handle_special_events_count(const char *v_name, int32_t dev, int64_t v_variant, int64_t v_subvariant, int *count)
Definition: rocs.c:1345
Here is the call graph for this function:
Here is the caller graph for this function:
◆ get_open_func()
|
static |
◆ get_start_func()
|
static |
◆ get_stop_func()
|
static |
◆ handle_special_events()
|
static |
Definition at line 1485 of file rocs.c.
1486{
1487 /* NOTE: special cases are two:
1488 * (a) one rsmi event contains aggregated pieces of data and is thus
1489 * split into separate events in the rocm smicomponent;
1490 * (b) two rsmi events are merged into a single one in the rocm smi
1491 * component. An example is the variants set/get which are
1492 * both represented by the same native event in PAPI.
1493 */
1494
1495 if (strcmp(v_name, "rsmi_dev_pci_throughput_get") == 0) {
1496 int64_t i;
1498 events[*events_count].id = *events_count;
1501 events[*events_count].device = dev;
1503 events[*events_count].subvariant = -1;
1511 ++(*events_count);
1512 }
1513
1515 }
1516
1517 if (strcmp(v_name, "rsmi_dev_power_profile_presets_get") == 0) {
1518 int64_t i;
1520 events[*events_count].id = *events_count;
1523 events[*events_count].device = dev;
1525 events[*events_count].subvariant = -1;
1533 ++(*events_count);
1534 }
1535
1537 }
1538
1539 if (strcmp(v_name, "rsmi_dev_power_cap_range_get") == 0) {
1540 int64_t i;
1542 events[*events_count].id = *events_count;
1545 events[*events_count].device = dev;
1547 events[*events_count].subvariant = v_subvariant;
1555 ++(*events_count);
1556 }
1557
1559 }
1560
1561 if (strcmp(v_name, "rsmi_dev_ecc_count_get") == 0) {
1562 int64_t i;
1564 events[*events_count].id = *events_count;
1567 events[*events_count].device = dev;
1568 events[*events_count].variant = v_variant;
1577 ++(*events_count);
1578 }
1579
1581 }
1582
1583 if (strcmp(v_name, "rsmi_dev_pci_bandwidth_get") == 0) {
1586 }
1587
1588 int64_t i;
1590 events[*events_count].id = *events_count;
1593 events[*events_count].device = dev;
1595 events[*events_count].subvariant = -1;
1603 ++(*events_count);
1604 }
1605
1606 int64_t j;
1609 events[*events_count].id = *events_count;
1612 events[*events_count].device = dev;
1614 events[*events_count].subvariant = j;
1622 ++(*events_count);
1623 }
1624 }
1625
1627 }
1628
1629 if (strcmp(v_name, "rsmi_dev_pci_bandwidth_set") == 0) {
1631 events[*events_count].id = *events_count;
1634 events[*events_count].device = dev;
1635 events[*events_count].variant = v_variant;
1636 events[*events_count].subvariant = v_subvariant;
1644 ++(*events_count);
1645 }
1646
1648 }
1649
1650 if (strcmp(v_name, "rsmi_dev_gpu_clk_freq_get") == 0) {
1651 int64_t i;
1655 events[*events_count].id = *events_count;
1658 events[*events_count].device = dev;
1659 events[*events_count].variant = v_variant;
1668 ++(*events_count);
1669 }
1670 }
1671
1674 events[*events_count].id = *events_count;
1677 events[*events_count].device = dev;
1678 events[*events_count].variant = v_variant;
1679 events[*events_count].subvariant = idx;
1687 ++(*events_count);
1688 }
1689
1691 }
1692
1693 if (strcmp(v_name, "rsmi_dev_gpu_clk_freq_set") == 0) {
1696 events[*events_count].id = *events_count;
1699 events[*events_count].device = dev;
1700 events[*events_count].variant = v_variant;
1701 events[*events_count].subvariant = -1;
1709 ++(*events_count);
1710 }
1711
1713 }
1714
1716 if (strcmp(v_name, "rsmi_dev_fan_speed_get") == 0 || strcmp(v_name, "rsmi_dev_fan_speed_set") == 0) {
1717 if (rsmi_dev_fan_speed_count[dev] == 0) {
1718 rsmi_dev_fan_speed_count[dev] = *events_count;
1720 }
1721
1722 if (strcmp(v_name, "rsmi_dev_fan_speed_set") == 0) {
1723 /* Set overwrites Get, update event description */
1727 }
1728
1730 }
1731
1733 if (strcmp(v_name, "rsmi_dev_power_cap_get") == 0 || strcmp(v_name, "rsmi_dev_power_cap_set") == 0) {
1734 if (rsmi_dev_power_cap_count[dev][v_subvariant] == 0) {
1735 rsmi_dev_power_cap_count[dev][v_subvariant] = *events_count;
1737 }
1738
1739 if (strcmp(v_name, "rsmi_dev_power_cap_set") == 0) {
1740 /* Set overwrites Get, update event description */
1744 }
1745
1747 }
1748
1750 if (strncmp(v_name, "rsmi_dev_perf_level", strlen("rsmi_dev_perf_level")) == 0) {
1751 if (rsmi_dev_perf_level_count[dev] == 0) {
1752 rsmi_dev_perf_level_count[dev] = *events_count;
1754 }
1755
1756 if (strcmp(v_name, "rsmi_dev_perf_level_set") == 0) {
1757 /* Set overwrites Get, update event description */
1761 }
1762
1764 }
1765
1767}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ handle_special_events_count()
|
static |
Definition at line 1345 of file rocs.c.
1346{
1347 /* NOTE: special cases are two:
1348 * (a) one rsmi event contains aggregated pieces of data and is thus
1349 * split into separate events in the rocm smi component;
1350 * (b) two rsmi events are merged into a single one in the rocm smi
1351 * component. An example is the variants set/get which are
1352 * both represented by the same native event in PAPI.
1353 */
1354
1355 if (strcmp(v_name, "rsmi_dev_pci_throughput_get") == 0) {
1356 (*events_count) += ROCS_PCI_THROUGHPUT_VARIANT__NUM;
1358 }
1359
1360 if (strcmp(v_name, "rsmi_dev_power_profile_presets_get") == 0) {
1361 (*events_count) += ROCS_POWER_PRESETS_VARIANT__NUM;
1363 }
1364
1365 if (strcmp(v_name, "rsmi_dev_power_cap_range_get") == 0) {
1366 (*events_count) += ROCS_POWER_CAP_RANGE_VARIANT__NUM;
1368 }
1369
1370 if (strcmp(v_name, "rsmi_dev_ecc_count_get") == 0) {
1371 (*events_count) += ROCS_ECC_COUNT_SUBVARIANT__NUM;
1373 }
1374
1375 if (strcmp(v_name, "rsmi_dev_pci_bandwidth_get") == 0) {
1377 (*events_count) += ROCS_PCI_BW_VARIANT__CURRENT + 1;
1378 }
1381 (*events_count) += pcie_table[dev].transfer_rate.num_supported;
1382 }
1383
1385 }
1386
1387 if (strcmp(v_name, "rsmi_dev_pci_bandwidth_set") == 0) {
1389 ++(*events_count);
1390 }
1392 }
1393
1394 if (strcmp(v_name, "rsmi_dev_gpu_clk_freq_get") == 0) {
1396 (*events_count) += freq_table[table_id].num_supported;
1398 (*events_count) += ROCS_GPU_CLK_FREQ_SUBVARIANT__NUM;
1399 }
1401 }
1402
1403 if (strcmp(v_name, "rsmi_dev_gpu_clk_freq_set") == 0) {
1406 ++(*events_count);
1407 }
1409 }
1410
1412 if (strcmp(v_name, "rsmi_dev_fan_speed_get") == 0 || strcmp(v_name, "rsmi_dev_fan_speed_set") == 0) {
1413 if (rsmi_dev_fan_speed_count[dev] == 0) {
1414 rsmi_dev_fan_speed_count[dev] = *events_count;
1416 }
1417
1419 }
1420
1422 if (strcmp(v_name, "rsmi_dev_power_cap_get") == 0 || strcmp(v_name, "rsmi_dev_power_cap_set") == 0) {
1423 if (rsmi_dev_power_cap_count[dev][v_subvariant] == 0) {
1424 rsmi_dev_power_cap_count[dev][v_subvariant] = *events_count;
1426 }
1427
1429 }
1430
1432 if (strncmp(v_name, "rsmi_dev_perf_level", strlen("rsmi_dev_perf_level")) == 0) {
1433 if (rsmi_dev_perf_level_count[dev] == 0) {
1434 rsmi_dev_perf_level_count[dev] = *events_count;
1436 }
1437
1439 }
1440
1441
1443}
Here is the caller graph for this function:
◆ handle_xgmi_events()
|
static |
Definition at line 1770 of file rocs.c.
1771{
1773 rsmi_status_t status;
1774
1775 status = rsmi_dev_counter_group_supported_p(dev, RSMI_EVNT_GRP_XGMI);
1776 if (status == RSMI_STATUS_SUCCESS) {
1778 events[*events_count].id = *events_count;
1781 events[*events_count].device = dev;
1783 events[*events_count].subvariant = -1;
1791 ++(*events_count);
1792 }
1793 }
1794
1795 status = rsmi_dev_counter_group_supported_p(dev, RSMI_EVNT_GRP_XGMI_DATA_OUT);
1796 if (status == RSMI_STATUS_SUCCESS) {
1798 events[*events_count].id = *events_count;
1801 events[*events_count].device = dev;
1803 events[*events_count].subvariant = -1;
1811 ++(*events_count);
1812 }
1813 }
1814
1815 int j;
1818 continue;
1819 }
1820 rsmi_status_t status;
1821 int res = 0;
1823 if (status != RSMI_STATUS_SUCCESS) {
1824 break;
1825 }
1826 if (res == 0) {
1827 continue;
1828 }
1829 uint64_t min, max;
1831 if (status != RSMI_STATUS_SUCCESS) {
1832 break;
1833 }
1835 events[*events_count].id = *events_count;
1836 events[*events_count].name = get_event_name("rsmi_dev_xgmi_bw_get", dev, (int64_t) j, (int64_t) i);
1838 events[*events_count].device = dev;
1839 events[*events_count].variant = j;
1848 ++(*events_count);
1849 }
1850 }
1851
1853}
static rsmi_status_t(* rsmi_dev_counter_group_supported_p)(uint32_t, rsmi_event_group_t)
Definition: rocs.c:70
static rsmi_status_t(* rsmi_is_P2P_accessible_p)(uint32_t, uint32_t, int *)
Definition: rocs.c:76
Here is the call graph for this function:
Here is the caller graph for this function:
◆ handle_xgmi_events_count()
Definition at line 1446 of file rocs.c.
1447{
1448 rsmi_status_t status;
1449
1450 status = rsmi_dev_counter_group_supported_p(dev, RSMI_EVNT_GRP_XGMI);
1451 if (status == RSMI_STATUS_SUCCESS) {
1452 *events_count += RSMI_EVNT_XGMI_LAST - RSMI_EVNT_XGMI_FIRST;
1453 }
1454
1455 status = rsmi_dev_counter_group_supported_p(dev, RSMI_EVNT_GRP_XGMI_DATA_OUT);
1456 if (status == RSMI_STATUS_SUCCESS) {
1457 *events_count += RSMI_EVNT_XGMI_DATA_OUT_LAST - RSMI_EVNT_XGMI_DATA_OUT_FIRST;
1458 }
1459
1460 uint32_t i;
1463 continue;
1464 }
1465 rsmi_status_t status;
1466 int res = 0;
1468 if (status != RSMI_STATUS_SUCCESS) {
1469 break;
1470 }
1471 uint64_t min, max;
1473 if (status != RSMI_STATUS_SUCCESS) {
1474 break;
1475 }
1476 if (res == 1) {
1477 (*events_count) += ROCS_XGMI_BW_VARIANT__NUM;
1478 }
1479 }
1480
1482}
Here is the caller graph for this function:
◆ init_device_table()
|
static |
Definition at line 994 of file rocs.c.
995{
998 rsmi_status_t status;
999
1000 freq_table = calloc(device_count * ROCS_GPU_CLK_FREQ_VARIANT__NUM, sizeof(rsmi_frequencies_t));
1002 papi_errno = PAPI_ENOMEM;
1003 goto fn_fail;
1004 }
1005
1008 papi_errno = PAPI_ENOMEM;
1009 goto fn_fail;
1010 }
1011
1016 if (status != RSMI_STATUS_SUCCESS && status != RSMI_STATUS_NOT_SUPPORTED) {
1017 papi_errno = PAPI_EMISC;
1018 goto fn_fail;
1019 }
1020 }
1021 }
1022
1025 if (status != RSMI_STATUS_SUCCESS && status != RSMI_STATUS_NOT_YET_IMPLEMENTED) {
1026 papi_errno = PAPI_EMISC;
1027 goto fn_fail;
1028 }
1029 }
1030
1031 fn_exit:
1032 return papi_errno;
1033 fn_fail:
1036 freq_table = NULL;
1037 }
1040 pcie_table = NULL;
1041 }
1042 goto fn_exit;
1043}
Here is the caller graph for this function:
◆ init_event_table()
|
static |
Definition at line 906 of file rocs.c.
907{
909
910 int ntv_events_count;
911 papi_errno = get_ntv_events_count(&ntv_events_count);
913 return papi_errno;
914 }
915
917 if (ntv_events == NULL) {
918 papi_errno = PAPI_ENOMEM;
919 goto fn_fail;
920 }
921
922 papi_errno = get_ntv_events(ntv_events, ntv_events_count);
924 goto fn_fail;
925 }
926
929
930 fn_exit:
931 return papi_errno;
932 fn_fail:
933 if (ntv_events) {
934 papi_free(ntv_events);
935 }
936 goto fn_exit;
937}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ load_rsmi_sym()
|
static |
Definition at line 665 of file rocs.c.
666{
668
669 char pathname[PATH_MAX] = { 0 };
670 char *rocmsmi_root = getenv("PAPI_ROCMSMI_ROOT");
671 if (rocmsmi_root == NULL) {
673 goto fn_fail;
674 }
675
676 sprintf(pathname, "%s/lib/librocm_smi64.so", rocmsmi_root);
677
678 rsmi_dlp = dlopen(pathname, RTLD_NOW | RTLD_GLOBAL);
681 goto fn_fail;
682 }
683
687 rsmi_dev_supported_func_iterator_open_p = dlsym(rsmi_dlp, "rsmi_dev_supported_func_iterator_open");
688 rsmi_dev_supported_func_iterator_close_p = dlsym(rsmi_dlp, "rsmi_dev_supported_func_iterator_close");
689 rsmi_dev_supported_variant_iterator_open_p = dlsym(rsmi_dlp, "rsmi_dev_supported_variant_iterator_open");
749
751 !rsmi_func_iter_value_get_p ||
752 !rsmi_func_iter_next_p ||
756 !rsmi_dev_id_get_p ||
757 !rsmi_dev_unique_id_get_p ||
758 !rsmi_dev_brand_get_p ||
759 !rsmi_dev_name_get_p ||
760 !rsmi_dev_serial_number_get_p ||
761 !rsmi_dev_vbios_version_get_p ||
762 !rsmi_dev_vendor_name_get_p ||
763 !rsmi_dev_vendor_id_get_p ||
764 !rsmi_dev_subsystem_id_get_p ||
766 !rsmi_dev_subsystem_name_get_p ||
767 !rsmi_dev_drm_render_minor_get_p ||
768 !rsmi_dev_overdrive_level_get_p ||
769 !rsmi_dev_overdrive_level_set_p ||
772 !rsmi_dev_memory_total_get_p ||
773 !rsmi_dev_memory_usage_get_p ||
774 !rsmi_dev_perf_level_get_p ||
775 !rsmi_dev_perf_level_set_p ||
776 !rsmi_dev_busy_percent_get_p ||
777 !rsmi_dev_firmware_version_get_p ||
778 !rsmi_dev_ecc_count_get_p ||
779 !rsmi_dev_ecc_enabled_get_p ||
780 !rsmi_dev_ecc_status_get_p ||
781 !rsmi_dev_fan_reset_p ||
782 !rsmi_dev_fan_rpms_get_p ||
783 !rsmi_dev_fan_speed_get_p ||
784 !rsmi_dev_fan_speed_max_get_p ||
785 !rsmi_dev_fan_speed_set_p ||
786 !rsmi_dev_power_avg_get_p ||
787 !rsmi_dev_power_cap_get_p ||
788 !rsmi_dev_power_cap_set_p ||
789 !rsmi_dev_power_cap_range_get_p ||
791 !rsmi_dev_power_profile_set_p ||
792 !rsmi_dev_temp_metric_get_p ||
793 !rsmi_dev_pci_id_get_p ||
794 !rsmi_dev_pci_throughput_get_p ||
796 !rsmi_dev_pci_bandwidth_get_p ||
797 !rsmi_dev_pci_bandwidth_set_p ||
798 !rsmi_dev_gpu_clk_freq_get_p ||
799 !rsmi_dev_gpu_clk_freq_set_p ||
801 !rsmi_dev_od_volt_info_get_p ||
802 !rsmi_init_p ||
803 !rsmi_shut_down_p ||
804 !rsmi_version_get_p ||
805 !rsmi_version_str_get_p ||
806 !rsmi_status_string_p ||
808 !rsmi_dev_counter_create_p ||
809 !rsmi_dev_counter_destroy_p ||
810 !rsmi_counter_control_p ||
811 !rsmi_counter_read_p ||
813 !rsmi_is_P2P_accessible_p ||
814 !rsmi_minmax_bandwidth_get_p);
815
819 }
820
821 fn_exit:
822 return papi_errno;
823 fn_fail:
824 papi_errno = PAPI_ENOSUPP;
825 goto fn_exit;
826}
static rsmi_status_t(* rsmi_counter_control_p)(rsmi_event_handle_t, rsmi_counter_command_t, void *)
Definition: rocs.c:73
static rsmi_status_t(* rsmi_num_monitor_dev_p)(uint32_t *)
Definition: rocs.c:13
static rsmi_status_t(* rsmi_counter_available_counters_get_p)(uint32_t, rsmi_event_group_t, uint32_t *)
Definition: rocs.c:75
static rsmi_status_t(* rsmi_dev_counter_create_p)(uint32_t, rsmi_event_type_t, rsmi_event_handle_t *)
Definition: rocs.c:71
static rsmi_status_t(* rsmi_dev_memory_reserved_pages_get_p)(uint32_t, uint32_t *, rsmi_retired_page_record_t *)
Definition: rocs.c:34
static rsmi_status_t(* rsmi_dev_od_volt_curve_regions_get_p)(uint32_t, uint32_t *, rsmi_freq_volt_region_t *)
Definition: rocs.c:63
static rsmi_status_t(* rsmi_dev_od_volt_info_get_p)(uint32_t, rsmi_od_volt_freq_data_t *)
Definition: rocs.c:64
static rsmi_status_t(* rsmi_dev_fan_speed_set_p)(uint32_t, uint32_t, uint64_t)
Definition: rocs.c:48
static rsmi_status_t(* rsmi_status_string_p)(rsmi_status_t, const char **)
Definition: rocs.c:69
Here is the caller graph for this function:
◆ open_simple() [1/2]
|
static |
◆ open_simple() [2/2]
| int open_simple | ( | void *arg | __attribute__(unused) | ) |
◆ open_xgmi_evt()
|
static |
Definition at line 2914 of file rocs.c.
2915{
2918 rsmi_status_t status;
2919 rsmi_event_group_t grp;
2920
2921 switch (event->variant) {
2930 grp = RSMI_EVNT_GRP_XGMI;
2931 break;
2938 grp = RSMI_EVNT_GRP_XGMI_DATA_OUT;
2939 break;
2940 default:
2941 papi_errno = PAPI_ENOSUPP;
2942 goto fn_fail;
2943 }
2944
2945 uint32_t counters;
2946 status = rsmi_counter_available_counters_get_p(event->device, grp, &counters);
2947 if (status != RSMI_STATUS_SUCCESS) {
2948 papi_errno = PAPI_EMISC;
2949 goto fn_fail;
2950 }
2951
2952 if (counters < 1) {
2953 papi_errno = PAPI_ECNFLCT;
2954 goto fn_fail;
2955 }
2956
2957 status = rsmi_dev_counter_create_p(event->device, event->variant, (rsmi_event_handle_t *) event->scratch);
2958 if (status != RSMI_STATUS_SUCCESS) {
2959 papi_errno = PAPI_EMISC;
2960 }
2961
2962 fn_exit:
2963 return papi_errno;
2964 fn_fail:
2965 goto fn_exit;
2966}
◆ release_devices()
|
static |
Definition at line 979 of file rocs.c.
980{
981 int32_t device_mask_rel = *bitmask;
982
985 }
986
987 device_mask ^= device_mask_rel;
988 *bitmask ^= device_mask_rel;
989
991}
Here is the caller graph for this function:
◆ rocs_ctx_close()
| int rocs_ctx_close | ( | rocs_ctx_t | rocs_ctx | ) |
Definition at line 519 of file rocs.c.
520{
522
524
530 goto fn_fail;
531 }
532 }
533
537
538 fn_exit:
540 return papi_errno;
541 fn_fail:
542 goto fn_exit;
543}
Definition: rocs.c:305
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rocs_ctx_open()
Definition at line 461 of file rocs.c.
462{
464 int64_t *counters = NULL;
466
468
469 int32_t bitmask;
471 papi_errno = PAPI_ECNFLCT;
472 goto fn_fail;
473 }
474
477 papi_errno = PAPI_ENOMEM;
478 goto fn_fail;
479 }
480
482 if (counters == NULL) {
483 papi_errno = PAPI_ENOMEM;
484 goto fn_fail;
485 }
486
491 goto fn_fail;
492 }
493 }
494
495 (*rocs_ctx)->state |= ROCS_EVENTS_OPENED;
496 (*rocs_ctx)->events_id = events_id;
497 (*rocs_ctx)->num_events = num_events;
498 (*rocs_ctx)->counters = counters;
499 (*rocs_ctx)->device_mask = bitmask;
500
501 fn_exit:
503 return papi_errno;
504 fn_fail:
508 }
509 if (counters) {
510 papi_free(counters);
511 }
514 }
515 goto fn_exit;
516}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rocs_ctx_read()
Definition at line 605 of file rocs.c.
606{
608
612 papi_errno = ntv_table_p->events[id].access_func_p(ROCS_ACCESS_MODE__READ, &ntv_table_p->events[id]);
614 return papi_errno;
615 }
617 }
619
620 return papi_errno;
621}
Here is the caller graph for this function:
◆ rocs_ctx_reset()
| int rocs_ctx_reset | ( | rocs_ctx_t | rocs_ctx | ) |
◆ rocs_ctx_start()
| int rocs_ctx_start | ( | rocs_ctx_t | rocs_ctx | ) |
◆ rocs_ctx_stop()
| int rocs_ctx_stop | ( | rocs_ctx_t | rocs_ctx | ) |
◆ rocs_ctx_write()
Definition at line 624 of file rocs.c.
625{
627
632 papi_errno = ntv_table_p->events[id].access_func_p(ROCS_ACCESS_MODE__WRITE, &ntv_table_p->events[id]);
634 return papi_errno;
635 }
636 }
637
638 return papi_errno;
639}
Here is the caller graph for this function:
◆ rocs_err_get_last()
| int rocs_err_get_last | ( | const char ** | err_string | ) |
◆ rocs_evt_code_to_descr()
◆ rocs_evt_code_to_name()
◆ rocs_evt_enum()
Definition at line 384 of file rocs.c.
385{
387
388 switch(modifier) {
391 papi_errno = PAPI_ENOEVNT;
392 }
393 *event_code = 0;
394 break;
397 ++(*event_code);
398 } else {
399 papi_errno = PAPI_END;
400 }
401 break;
402 default:
403 papi_errno = PAPI_EINVAL;
404 }
405
406 return papi_errno;
407}
Here is the caller graph for this function:
◆ rocs_evt_name_to_code()
Definition at line 421 of file rocs.c.
422{
424 int htable_errno;
425
426 ntv_event_t *event;
429 papi_errno = (htable_errno == HTABLE_ENOVAL) ?
431 goto fn_exit;
432 }
433 *event_code = event->id;
434
435 fn_exit:
436 return papi_errno;
437}
static int htable_find(void *handle, const char *key, void **out)
Definition: cuda/htable.h:161
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rocs_init()
| int rocs_init | ( | void | ) |
Definition at line 333 of file rocs.c.
334{
335 int papi_errno;
336
337 papi_errno = load_rsmi_sym();
339 return papi_errno;
340 }
341
342 rsmi_status_t status = rsmi_init_p(0);
343 if (status != RSMI_STATUS_SUCCESS) {
344 const char *status_string = NULL;
345 rsmi_status_string_p(status, &status_string);
346 strcpy(error_string, status_string);
348 }
349
351
353 if (status != RSMI_STATUS_SUCCESS) {
355 papi_errno = PAPI_EMISC;
356 goto fn_fail;
357 }
358
359 papi_errno = init_device_table();
362 goto fn_fail;
363 }
364
365 papi_errno = init_event_table();
368 goto fn_fail;
369 }
370
372
373 fn_exit:
374 return papi_errno;
375 fn_fail:
376 shutdown_event_table();
377 shutdown_device_table();
379 rsmi_shut_down_p();
380 goto fn_exit;
381}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rocs_shutdown()
| int rocs_shutdown | ( | void | ) |
Definition at line 655 of file rocs.c.
Here is the call graph for this function:
Here is the caller graph for this function:
◆ shutdown_device_table()
|
static |
◆ shutdown_event_table()
|
static |
◆ start_simple()
◆ start_xgmi_evt()
|
static |
Definition at line 2984 of file rocs.c.
2985{
2988 rsmi_status_t status;
2989
2990 status = rsmi_counter_control_p(*(rsmi_event_handle_t *) event->scratch, RSMI_CNTR_CMD_START, NULL);
2991 if (status != RSMI_STATUS_SUCCESS) {
2992 papi_errno = PAPI_EMISC;
2993 }
2994
2995 return papi_errno;
2996}
◆ stop_simple() [1/2]
|
static |
◆ stop_simple() [2/2]
| int stop_simple | ( | void *arg | __attribute__(unused) | ) |
◆ stop_xgmi_evt()
|
static |
Definition at line 2999 of file rocs.c.
3000{
3003 rsmi_status_t status;
3004
3005 status = rsmi_counter_control_p(*(rsmi_event_handle_t *) event->scratch, RSMI_CNTR_CMD_STOP, NULL);
3006 if (status != RSMI_STATUS_SUCCESS) {
3007 papi_errno = PAPI_EMISC;
3008 }
3009
3010 return papi_errno;
3011}
◆ unload_rsmi_sym()
|
static |
Definition at line 829 of file rocs.c.
830{
831 rsmi_num_monitor_dev_p = NULL;
832 rsmi_func_iter_value_get_p = NULL;
833 rsmi_func_iter_next_p = NULL;
834 rsmi_dev_supported_func_iterator_open_p = NULL;
835 rsmi_dev_supported_func_iterator_close_p = NULL;
836 rsmi_dev_supported_variant_iterator_open_p = NULL;
837 rsmi_dev_id_get_p = NULL;
838 rsmi_dev_unique_id_get_p = NULL;
839 rsmi_dev_brand_get_p = NULL;
840 rsmi_dev_name_get_p = NULL;
841 rsmi_dev_serial_number_get_p = NULL;
842 rsmi_dev_vbios_version_get_p = NULL;
843 rsmi_dev_vendor_name_get_p = NULL;
844 rsmi_dev_vendor_id_get_p = NULL;
845 rsmi_dev_subsystem_id_get_p = NULL;
846 rsmi_dev_subsystem_vendor_id_get_p = NULL;
847 rsmi_dev_subsystem_name_get_p = NULL;
848 rsmi_dev_drm_render_minor_get_p = NULL;
849 rsmi_dev_overdrive_level_get_p = NULL;
850 rsmi_dev_overdrive_level_set_p = NULL;
851 rsmi_dev_memory_busy_percent_get_p = NULL;
852 rsmi_dev_memory_reserved_pages_get_p = NULL;
853 rsmi_dev_memory_total_get_p = NULL;
854 rsmi_dev_memory_usage_get_p = NULL;
855 rsmi_dev_perf_level_get_p = NULL;
856 rsmi_dev_perf_level_set_p = NULL;
857 rsmi_dev_busy_percent_get_p = NULL;
858 rsmi_dev_firmware_version_get_p = NULL;
859 rsmi_dev_ecc_count_get_p = NULL;
860 rsmi_dev_ecc_enabled_get_p = NULL;
861 rsmi_dev_ecc_status_get_p = NULL;
862 rsmi_dev_fan_reset_p = NULL;
863 rsmi_dev_fan_rpms_get_p = NULL;
864 rsmi_dev_fan_speed_get_p = NULL;
865 rsmi_dev_fan_speed_max_get_p = NULL;
866 rsmi_dev_fan_speed_set_p = NULL;
867 rsmi_dev_power_avg_get_p = NULL;
868 rsmi_dev_power_cap_get_p = NULL;
869 rsmi_dev_power_cap_set_p = NULL;
870 rsmi_dev_power_cap_range_get_p = NULL;
871 rsmi_dev_power_profile_presets_get_p = NULL;
872 rsmi_dev_power_profile_set_p = NULL;
873 rsmi_dev_temp_metric_get_p = NULL;
874 rsmi_dev_pci_id_get_p = NULL;
875 rsmi_dev_pci_throughput_get_p = NULL;
876 rsmi_dev_pci_replay_counter_get_p = NULL;
877 rsmi_dev_pci_bandwidth_get_p = NULL;
878 rsmi_dev_pci_bandwidth_set_p = NULL;
879 rsmi_dev_gpu_clk_freq_get_p = NULL;
880 rsmi_dev_gpu_clk_freq_set_p = NULL;
881 rsmi_dev_od_volt_curve_regions_get_p = NULL;
882 rsmi_dev_od_volt_info_get_p = NULL;
883 rsmi_init_p = NULL;
884 rsmi_shut_down_p = NULL;
885 rsmi_version_get_p = NULL;
886 rsmi_version_str_get_p = NULL;
887 rsmi_status_string_p = NULL;
888 rsmi_dev_counter_group_supported_p = NULL;
889 rsmi_dev_counter_create_p = NULL;
890 rsmi_dev_counter_destroy_p = NULL;
891 rsmi_counter_control_p = NULL;
892 rsmi_counter_read_p = NULL;
893 rsmi_counter_available_counters_get_p = NULL;
894 rsmi_is_P2P_accessible_p = NULL;
895 rsmi_minmax_bandwidth_get_p = NULL;
896
897 dlclose(rsmi_dlp);
898
900}
Here is the caller graph for this function:
Variable Documentation
◆ _rocm_smi_lock
◆ access_func_p
| access_function_f access_func_p |
◆ close_func_p
| close_function_f close_func_p |
◆ device_count
◆ device_mask
◆ error_string
|
static |
◆
| struct { ... } event_function_table[] |
◆ freq_table
◆ htable
◆ name
◆ ntv_table
|
static |
◆ ntv_table_p
|
static |
◆ open_func_p
| open_function_f open_func_p |
◆ pcie_table
◆ rsmi_counter_available_counters_get_p
|
static |
◆ rsmi_counter_control_p
|
static |
◆ rsmi_counter_read_p
|
static |
◆ rsmi_dev_brand_get_p
|
static |
◆ rsmi_dev_busy_percent_get_p
|
static |
◆ rsmi_dev_counter_create_p
|
static |
◆ rsmi_dev_counter_destroy_p
|
static |
◆ rsmi_dev_counter_group_supported_p
|
static |
◆ rsmi_dev_drm_render_minor_get_p
|
static |
◆ rsmi_dev_ecc_count_get_p
|
static |
◆ rsmi_dev_ecc_enabled_get_p
|
static |
◆ rsmi_dev_ecc_status_get_p
|
static |
◆ rsmi_dev_fan_reset_p
|
static |
◆ rsmi_dev_fan_rpms_get_p
|
static |
◆ rsmi_dev_fan_speed_get_p
|
static |
◆ rsmi_dev_fan_speed_max_get_p
|
static |
◆ rsmi_dev_fan_speed_set_p
|
static |
◆ rsmi_dev_firmware_version_get_p
|
static |
◆ rsmi_dev_gpu_clk_freq_get_p
|
static |
◆ rsmi_dev_gpu_clk_freq_set_p
|
static |
◆ rsmi_dev_id_get_p
|
static |
◆ rsmi_dev_memory_busy_percent_get_p
|
static |
◆ rsmi_dev_memory_reserved_pages_get_p
|
static |
◆ rsmi_dev_memory_total_get_p
|
static |
◆ rsmi_dev_memory_usage_get_p
|
static |
◆ rsmi_dev_name_get_p
◆ rsmi_dev_od_volt_curve_regions_get_p
|
static |
◆ rsmi_dev_od_volt_info_get_p
|
static |
◆ rsmi_dev_overdrive_level_get_p
|
static |
◆ rsmi_dev_overdrive_level_set_p
|
static |
◆ rsmi_dev_pci_bandwidth_get_p
|
static |
◆ rsmi_dev_pci_bandwidth_set_p
|
static |
◆ rsmi_dev_pci_id_get_p
|
static |
◆ rsmi_dev_pci_replay_counter_get_p
|
static |
◆ rsmi_dev_pci_throughput_get_p
|
static |
◆ rsmi_dev_perf_level_get_p
|
static |
◆ rsmi_dev_perf_level_set_p
|
static |
◆ rsmi_dev_power_avg_get_p
|
static |
◆ rsmi_dev_power_cap_get_p
|
static |
◆ rsmi_dev_power_cap_range_get_p
|
static |
◆ rsmi_dev_power_cap_set_p
|
static |
◆ rsmi_dev_power_profile_presets_get_p
|
static |
◆ rsmi_dev_power_profile_set_p
|
static |
◆ rsmi_dev_serial_number_get_p
|
static |
◆ rsmi_dev_subsystem_id_get_p
|
static |
◆ rsmi_dev_subsystem_name_get_p
◆ rsmi_dev_subsystem_vendor_id_get_p
|
static |
◆ rsmi_dev_supported_func_iterator_close_p
|
static |
◆ rsmi_dev_supported_func_iterator_open_p
|
static |
◆ rsmi_dev_supported_variant_iterator_open_p
|
static |
◆ rsmi_dev_temp_metric_get_p
|
static |
◆ rsmi_dev_unique_id_get_p
|
static |
◆ rsmi_dev_vbios_version_get_p
|
static |
◆ rsmi_dev_vendor_id_get_p
|
static |
◆ rsmi_dev_vendor_name_get_p
◆ rsmi_dlp
◆ rsmi_func_iter_next_p
|
static |
◆ rsmi_func_iter_value_get_p
|
static |
◆ rsmi_init_p
◆ rsmi_is_P2P_accessible_p
◆ rsmi_minmax_bandwidth_get_p
|
static |
◆ rsmi_num_monitor_dev_p
|
static |
◆ rsmi_shut_down_p
◆ rsmi_status_string_p
|
static |
◆ rsmi_version_get_p
|
static |
◆ rsmi_version_str_get_p
◆ start_func_p
| start_function_f start_func_p |
◆ stop_func_p
| stop_function_f stop_func_p |
