280 {NULL, NULL, NULL, NULL, NULL, NULL}
300typedef struct ntv_event_table {
313#define PAPI_ROCMSMI_MAX_DEV_COUNT (32)
314#define PAPI_ROCMSMI_MAX_SUBVAR (32)
343 if (status != RSMI_STATUS_SUCCESS) {
344 const char *status_string = NULL;
353 if (status != RSMI_STATUS_SUCCESS) {
354 sprintf(
error_string,
"Error while counting available devices.");
361 sprintf(
error_string,
"Error while initializing device tables.");
367 sprintf(
error_string,
"Error while initializing the native event table.");
433 *event_code =
event->id;
464 int64_t *counters = NULL;
482 if (counters == NULL) {
498 (*rocs_ctx)->counters = counters;
499 (*rocs_ctx)->device_mask = bitmask;
505 for (j = 0; j <
i; ++j) {
572 for (j = 0; j <
i; ++j) {
669 char pathname[PATH_MAX] = { 0 };
670 char *rocmsmi_root = getenv(
"PAPI_ROCMSMI_ROOT");
671 if (rocmsmi_root == NULL) {
672 sprintf(
error_string,
"Can't load librocm_smi64.so, PAPI_ROCMSMI_ROOT not set.");
676 sprintf(pathname,
"%s/lib/librocm_smi64.so", rocmsmi_root);
678 rsmi_dlp = dlopen(pathname, RTLD_NOW | RTLD_GLOBAL);
818 sprintf(
error_string,
"Error while loading rocm_smi symbols.");
910 int ntv_events_count;
917 if (ntv_events == NULL) {
958 int32_t device_mask_acq = 0;
965 device_mask_acq |= (1 << device_id);
973 *bitmask = device_mask_acq;
981 int32_t device_mask_rel = *bitmask;
983 if ((device_mask_rel &
device_mask) != device_mask_rel) {
988 *bitmask ^= device_mask_rel;
998 rsmi_status_t status;
1016 if (status != RSMI_STATUS_SUCCESS && status != RSMI_STATUS_NOT_SUPPORTED) {
1025 if (status != RSMI_STATUS_SUCCESS && status != RSMI_STATUS_NOT_YET_IMPLEMENTED) {
1059#define ROCMSMI_NUM_INFO_EVENTS (3)
1068static char *
get_event_name(
const char *
name, int32_t dev, int64_t variant, int64_t subvariant);
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;
1086 if (status != RSMI_STATUS_SUCCESS) {
1091 if (status != RSMI_STATUS_SUCCESS) {
1095 if (status == RSMI_STATUS_NO_DATA) {
1105 while (status != RSMI_STATUS_NO_DATA) {
1107 if (status != RSMI_STATUS_SUCCESS) {
1111 if (status == RSMI_STATUS_NO_DATA) {
1121 while (status != RSMI_STATUS_NO_DATA) {
1123 if (status != RSMI_STATUS_SUCCESS) {
1137 if (status != RSMI_STATUS_SUCCESS) {
1145 if (status != RSMI_STATUS_SUCCESS) {
1151 if (status == RSMI_STATUS_NO_DATA) {
1156 if (status != RSMI_STATUS_SUCCESS) {
1164 *
count = events_count;
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;
1195 const char *first_events[] = {
1198 "rsmi_dev_driver_version_str_get",
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;
1222 if (status != RSMI_STATUS_SUCCESS) {
1227 if (status != RSMI_STATUS_SUCCESS) {
1231 if (status == RSMI_STATUS_NO_DATA) {
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;
1253 while (status != RSMI_STATUS_NO_DATA) {
1255 if (status != RSMI_STATUS_SUCCESS) {
1259 if (status == RSMI_STATUS_NO_DATA) {
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;
1281 while (status != RSMI_STATUS_NO_DATA) {
1283 if (status != RSMI_STATUS_SUCCESS) {
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;
1309 if (status != RSMI_STATUS_SUCCESS) {
1317 if (status != RSMI_STATUS_SUCCESS) {
1323 if (status == RSMI_STATUS_NO_DATA) {
1328 if (status != RSMI_STATUS_SUCCESS) {
1355 if (strcmp(v_name,
"rsmi_dev_pci_throughput_get") == 0) {
1360 if (strcmp(v_name,
"rsmi_dev_power_profile_presets_get") == 0) {
1365 if (strcmp(v_name,
"rsmi_dev_power_cap_range_get") == 0) {
1370 if (strcmp(v_name,
"rsmi_dev_ecc_count_get") == 0) {
1375 if (strcmp(v_name,
"rsmi_dev_pci_bandwidth_get") == 0) {
1376 if (
pcie_table[dev].transfer_rate.num_supported) {
1381 (*events_count) +=
pcie_table[dev].transfer_rate.num_supported;
1387 if (strcmp(v_name,
"rsmi_dev_pci_bandwidth_set") == 0) {
1388 if (
pcie_table[dev].transfer_rate.num_supported) {
1394 if (strcmp(v_name,
"rsmi_dev_gpu_clk_freq_get") == 0) {
1396 (*events_count) +=
freq_table[table_id].num_supported;
1403 if (strcmp(v_name,
"rsmi_dev_gpu_clk_freq_set") == 0) {
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;
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;
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;
1448 rsmi_status_t status;
1451 if (status == RSMI_STATUS_SUCCESS) {
1452 *events_count += RSMI_EVNT_XGMI_LAST - RSMI_EVNT_XGMI_FIRST;
1456 if (status == RSMI_STATUS_SUCCESS) {
1457 *events_count += RSMI_EVNT_XGMI_DATA_OUT_LAST - RSMI_EVNT_XGMI_DATA_OUT_FIRST;
1462 if (
i == (uint32_t) dev) {
1465 rsmi_status_t status;
1468 if (status != RSMI_STATUS_SUCCESS) {
1473 if (status != RSMI_STATUS_SUCCESS) {
1495 if (strcmp(v_name,
"rsmi_dev_pci_throughput_get") == 0) {
1498 events[*events_count].id = *events_count;
1501 events[*events_count].device = dev;
1502 events[*events_count].variant =
i;
1503 events[*events_count].subvariant = -1;
1517 if (strcmp(v_name,
"rsmi_dev_power_profile_presets_get") == 0) {
1520 events[*events_count].id = *events_count;
1523 events[*events_count].device = dev;
1524 events[*events_count].variant =
i;
1525 events[*events_count].subvariant = -1;
1539 if (strcmp(v_name,
"rsmi_dev_power_cap_range_get") == 0) {
1542 events[*events_count].id = *events_count;
1545 events[*events_count].device = dev;
1546 events[*events_count].variant =
i;
1547 events[*events_count].subvariant = v_subvariant;
1561 if (strcmp(v_name,
"rsmi_dev_ecc_count_get") == 0) {
1564 events[*events_count].id = *events_count;
1567 events[*events_count].device = dev;
1568 events[*events_count].variant = v_variant;
1569 events[*events_count].subvariant =
i;
1583 if (strcmp(v_name,
"rsmi_dev_pci_bandwidth_get") == 0) {
1584 if (
pcie_table[dev].transfer_rate.num_supported == 0) {
1590 events[*events_count].id = *events_count;
1593 events[*events_count].device = dev;
1594 events[*events_count].variant =
i;
1595 events[*events_count].subvariant = -1;
1608 for (j = 0; j <
pcie_table[dev].transfer_rate.num_supported; ++j) {
1609 events[*events_count].id = *events_count;
1612 events[*events_count].device = dev;
1613 events[*events_count].variant =
i;
1614 events[*events_count].subvariant = j;
1629 if (strcmp(v_name,
"rsmi_dev_pci_bandwidth_set") == 0) {
1630 if (
pcie_table[dev].transfer_rate.num_supported) {
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;
1650 if (strcmp(v_name,
"rsmi_dev_gpu_clk_freq_get") == 0) {
1655 events[*events_count].id = *events_count;
1658 events[*events_count].device = dev;
1659 events[*events_count].variant = v_variant;
1660 events[*events_count].subvariant =
i;
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;
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;
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;
1722 if (strcmp(v_name,
"rsmi_dev_fan_speed_set") == 0) {
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;
1739 if (strcmp(v_name,
"rsmi_dev_power_cap_set") == 0) {
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;
1756 if (strcmp(v_name,
"rsmi_dev_perf_level_set") == 0) {
1773 rsmi_status_t status;
1776 if (status == RSMI_STATUS_SUCCESS) {
1777 for (
i = RSMI_EVNT_XGMI_FIRST;
i <= RSMI_EVNT_XGMI_LAST; ++
i) {
1778 events[*events_count].id = *events_count;
1781 events[*events_count].device = dev;
1782 events[*events_count].variant =
i;
1783 events[*events_count].subvariant = -1;
1796 if (status == RSMI_STATUS_SUCCESS) {
1797 for (
i = RSMI_EVNT_XGMI_DATA_OUT_FIRST;
i <= RSMI_EVNT_XGMI_DATA_OUT_LAST; ++
i) {
1798 events[*events_count].id = *events_count;
1801 events[*events_count].device = dev;
1802 events[*events_count].variant =
i;
1803 events[*events_count].subvariant = -1;
1820 rsmi_status_t status;
1823 if (status != RSMI_STATUS_SUCCESS) {
1831 if (status != RSMI_STATUS_SUCCESS) {
1835 events[*events_count].id = *events_count;
1838 events[*events_count].device = dev;
1839 events[*events_count].variant = j;
1840 events[*events_count].subvariant =
i;
1860 if (strcmp(
name,
"rsmi_dev_count") == 0) {
1861 return strdup(
"NUMDevices");
1862 }
else if (strcmp(
name,
"rsmi_lib_version") == 0) {
1863 return strdup(
"rsmi_version");
1864 }
else if (strcmp(
name,
"rsmi_dev_driver_version_str_get") == 0) {
1865 return strdup(
"driver_version_str");
1866 }
else if (strcmp(
name,
"rsmi_dev_id_get") == 0) {
1867 sprintf(event_name_str,
"device_id:device=%i", dev);
1868 }
else if (strcmp(
name,
"rsmi_dev_subsystem_vendor_id_get") == 0) {
1869 sprintf(event_name_str,
"subsystem_vendor_id:device=%i", dev);
1870 }
else if (strcmp(
name,
"rsmi_dev_vendor_id_get") == 0) {
1871 sprintf(event_name_str,
"vendor_id:device=%i", dev);
1872 }
else if (strcmp(
name,
"rsmi_dev_unique_id_get") == 0) {
1873 sprintf(event_name_str,
"unique_id:device=%i", dev);
1874 }
else if (strcmp(
name,
"rsmi_dev_subsystem_id_get") == 0) {
1875 sprintf(event_name_str,
"subsystem_id:device=%i", dev);
1876 }
else if (strcmp(
name,
"rsmi_dev_drm_render_minor_get") == 0) {
1877 sprintf(event_name_str,
"drm_render_minor:device=%i", dev);
1878 }
else if (strcmp(
name,
"rsmi_dev_overdrive_level_get") == 0) {
1879 sprintf(event_name_str,
"overdrive_level:device=%i", dev);
1880 }
else if (strncmp(
name,
"rsmi_dev_perf_level", strlen(
"rsmi_dev_perf_level")) == 0) {
1881 sprintf(event_name_str,
"perf_level:device=%i", dev);
1882 }
else if (strcmp(
name,
"rsmi_dev_memory_total_get") == 0) {
1884 case RSMI_MEM_TYPE_VRAM:
1885 sprintf(event_name_str,
"mem_total_VRAM:device=%i", dev);
1887 case RSMI_MEM_TYPE_VIS_VRAM:
1888 sprintf(event_name_str,
"mem_total_VIS_VRAM:device=%i", dev);
1890 case RSMI_MEM_TYPE_GTT:
1891 sprintf(event_name_str,
"mem_total_GTT:device=%i", dev);
1896 }
else if (strcmp(
name,
"rsmi_dev_memory_usage_get") == 0) {
1898 case RSMI_MEM_TYPE_VRAM:
1899 sprintf(event_name_str,
"mem_usage_VRAM:device=%i", dev);
1901 case RSMI_MEM_TYPE_VIS_VRAM:
1902 sprintf(event_name_str,
"mem_usage_VIS_VRAM:device=%i", dev);
1904 case RSMI_MEM_TYPE_GTT:
1905 sprintf(event_name_str,
"mem_usage_GTT:device=%i", dev);
1910 }
else if (strcmp(
name,
"rsmi_dev_busy_percent_get") == 0) {
1911 sprintf(event_name_str,
"busy_percent:device=%i", dev);
1912 }
else if (strcmp(
name,
"rsmi_dev_memory_busy_percent_get") == 0) {
1913 sprintf(event_name_str,
"memory_busy_percent:device=%i", dev);
1914 }
else if (strcmp(
name,
"rsmi_dev_pci_id_get") == 0) {
1915 sprintf(event_name_str,
"pci_id:device=%i", dev);
1916 }
else if (strcmp(
name,
"rsmi_dev_pci_replay_counter_get") == 0) {
1917 sprintf(event_name_str,
"pci_replay_counter:device=%i", dev);
1918 }
else if (strcmp(
name,
"rsmi_dev_pci_throughput_get") == 0) {
1921 sprintf(event_name_str,
"pci_throughput_sent:device=%i", dev);
1924 sprintf(event_name_str,
"pci_throughput_received:device=%i", dev);
1927 sprintf(event_name_str,
"pci_max_packet_size:device=%i", dev);
1932 }
else if (strcmp(
name,
"rsmi_dev_power_profile_presets_get") == 0) {
1935 sprintf(event_name_str,
"power_profiler_presets:device=%i:count", dev);
1938 sprintf(event_name_str,
"power_profiler_presets:device=%i:avail_profiles", dev);
1941 sprintf(event_name_str,
"power_profiler_presets:device=%i:current", dev);
1946 }
else if (strcmp(
name,
"rsmi_dev_power_profile_set") == 0) {
1947 sprintf(event_name_str,
"power_profile_set:device=%i", dev);
1948 }
else if (strcmp(
name,
"rsmi_dev_fan_reset") == 0) {
1949 sprintf(event_name_str,
"fan_reset:device=%i:sensor=%i", dev, (
int) subvariant);
1950 }
else if (strcmp(
name,
"rsmi_dev_fan_rpms_get") == 0) {
1951 sprintf(event_name_str,
"fan_rpms:device=%i:sensor=%i", dev, (
int) subvariant);
1952 }
else if (strcmp(
name,
"rsmi_dev_fan_speed_max_get") == 0) {
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);
1956 }
else if (strcmp(
name,
"rsmi_dev_power_ave_get") == 0) {
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);
1960 }
else if (strcmp(
name,
"rsmi_dev_power_cap_range_get") == 0) {
1963 sprintf(event_name_str,
"power_cap_range_min:device=%i:sensor=%i", dev, (
int) subvariant);
1966 sprintf(event_name_str,
"power_cap_range_max:device=%i:sensor=%i", dev, (
int) subvariant);
1971 }
else if (strcmp(
name,
"rsmi_dev_temp_metric_get") == 0) {
1973 case RSMI_TEMP_CURRENT:
1974 sprintf(event_name_str,
"temp_current:device=%i:sensor=%i", dev, (
int) subvariant);
1977 sprintf(event_name_str,
"temp_max:device=%i:sensor=%i", dev, (
int) subvariant);
1980 sprintf(event_name_str,
"temp_min:device=%i:sensor=%i", dev, (
int) subvariant);
1982 case RSMI_TEMP_MAX_HYST:
1983 sprintf(event_name_str,
"temp_max_hyst:device=%i:sensor=%i", dev, (
int) subvariant);
1985 case RSMI_TEMP_MIN_HYST:
1986 sprintf(event_name_str,
"temp_min_hyst:device=%i:sensor=%i", dev, (
int) subvariant);
1988 case RSMI_TEMP_CRITICAL:
1989 sprintf(event_name_str,
"temp_critical:device=%i:sensor=%i", dev, (
int) subvariant);
1991 case RSMI_TEMP_CRITICAL_HYST:
1992 sprintf(event_name_str,
"temp_critical_hyst:device=%i:sensor=%i", dev, (
int) subvariant);
1994 case RSMI_TEMP_EMERGENCY:
1995 sprintf(event_name_str,
"temp_emergency:device=%i:sensor=%i", dev, (
int) subvariant);
1997 case RSMI_TEMP_EMERGENCY_HYST:
1998 sprintf(event_name_str,
"temp_emergency_hyst:device=%i:sensor=%i", dev, (
int) subvariant);
2000 case RSMI_TEMP_CRIT_MIN:
2001 sprintf(event_name_str,
"temp_crit_min:device=%i:sensor=%i", dev, (
int) subvariant);
2003 case RSMI_TEMP_CRIT_MIN_HYST:
2004 sprintf(event_name_str,
"temp_crit_min_hyst:device=%i:sensor=%i", dev, (
int) subvariant);
2006 case RSMI_TEMP_OFFSET:
2007 sprintf(event_name_str,
"temp_offset:device=%i:sensor=%i", dev, (
int) subvariant);
2009 case RSMI_TEMP_LOWEST:
2010 sprintf(event_name_str,
"temp_lowest:device=%i:sensor=%i", dev, (
int) subvariant);
2012 case RSMI_TEMP_HIGHEST:
2013 sprintf(event_name_str,
"temp_highest:device=%i:sensor=%i", dev, (
int) subvariant);
2018 }
else if (strcmp(
name,
"rsmi_dev_firmware_version_get") == 0) {
2020 case RSMI_FW_BLOCK_ASD:
2021 sprintf(event_name_str,
"firmware_version:device=%i:block=ASD", dev);
2023 case RSMI_FW_BLOCK_CE:
2024 sprintf(event_name_str,
"firmware_version:device=%i:block=CE", dev);
2026 case RSMI_FW_BLOCK_DMCU:
2027 sprintf(event_name_str,
"firmware_version:device=%i:block=DMCU", dev);
2029 case RSMI_FW_BLOCK_MC:
2030 sprintf(event_name_str,
"firmware_version:device=%i:block=MC", dev);
2032 case RSMI_FW_BLOCK_ME:
2033 sprintf(event_name_str,
"firmware_version:device=%i:block=ME", dev);
2035 case RSMI_FW_BLOCK_MEC:
2036 sprintf(event_name_str,
"firmware_version:device=%i:block=MEC", dev);
2038 case RSMI_FW_BLOCK_MEC2:
2039 sprintf(event_name_str,
"firmware_version:device=%i:block=MEC2", dev);
2041 case RSMI_FW_BLOCK_PFP:
2042 sprintf(event_name_str,
"firmware_version:device=%i:block=PFP", dev);
2044 case RSMI_FW_BLOCK_RLC:
2045 sprintf(event_name_str,
"firmware_version:device=%i:block=RLC", dev);
2047 case RSMI_FW_BLOCK_RLC_SRLC:
2048 sprintf(event_name_str,
"firmware_version:device=%i:block=SRLC", dev);
2050 case RSMI_FW_BLOCK_RLC_SRLG:
2051 sprintf(event_name_str,
"firmware_version:device=%i:block=SRLG", dev);
2053 case RSMI_FW_BLOCK_RLC_SRLS:
2054 sprintf(event_name_str,
"firmware_version:device=%i:block=SRLS", dev);
2056 case RSMI_FW_BLOCK_SDMA:
2057 sprintf(event_name_str,
"firmware_version:device=%i:block=SDMA", dev);
2059 case RSMI_FW_BLOCK_SDMA2:
2060 sprintf(event_name_str,
"firmware_version:device=%i:block=SDMA2", dev);
2062 case RSMI_FW_BLOCK_SMC:
2063 sprintf(event_name_str,
"firmware_version:device=%i:block=SMC", dev);
2065 case RSMI_FW_BLOCK_SOS:
2066 sprintf(event_name_str,
"firmware_version:device=%i:block=SOS", dev);
2068 case RSMI_FW_BLOCK_TA_RAS:
2069 sprintf(event_name_str,
"firmware_version:device=%i:block=RAS", dev);
2071 case RSMI_FW_BLOCK_TA_XGMI:
2072 sprintf(event_name_str,
"firmware_version:device=%i:block=XGMI", dev);
2074 case RSMI_FW_BLOCK_UVD:
2075 sprintf(event_name_str,
"firmware_version:device=%i:block=UVD", dev);
2077 case RSMI_FW_BLOCK_VCE:
2078 sprintf(event_name_str,
"firmware_version:device=%i:block=VCE", dev);
2080 case RSMI_FW_BLOCK_VCN:
2081 sprintf(event_name_str,
"firmware_version:device=%i:block=VCN", dev);
2086 }
else if (strcmp(
name,
"rsmi_dev_ecc_count_get") == 0) {
2087 const char *block = NULL;
2089 case RSMI_GPU_BLOCK_UMC:
2092 case RSMI_GPU_BLOCK_SDMA:
2095 case RSMI_GPU_BLOCK_GFX:
2098 case RSMI_GPU_BLOCK_MMHUB:
2101 case RSMI_GPU_BLOCK_ATHUB:
2104 case RSMI_GPU_BLOCK_PCIE_BIF:
2107 case RSMI_GPU_BLOCK_HDP:
2110 case RSMI_GPU_BLOCK_XGMI_WAFL:
2111 block =
"XGMI_WAFL";
2113 case RSMI_GPU_BLOCK_DF:
2116 case RSMI_GPU_BLOCK_SMN:
2119 case RSMI_GPU_BLOCK_SEM:
2122 case RSMI_GPU_BLOCK_MP0:
2125 case RSMI_GPU_BLOCK_MP1:
2128 case RSMI_GPU_BLOCK_FUSE:
2135 switch (subvariant) {
2137 sprintf(event_name_str,
"ecc_count_correctable:device=%i:block=%s", dev, block);
2140 sprintf(event_name_str,
"ecc_count_uncorrectable:device=%i:block=%s", dev, block);
2145 }
else if (strcmp(
name,
"rsmi_dev_ecc_enabled_get") == 0) {
2146 sprintf(event_name_str,
"ecc_enabled_get:device=%i", dev);
2147 }
else if (strcmp(
name,
"rsmi_dev_ecc_status_get") == 0) {
2148 const char *block = NULL;
2150 case RSMI_GPU_BLOCK_UMC:
2153 case RSMI_GPU_BLOCK_SDMA:
2156 case RSMI_GPU_BLOCK_GFX:
2159 case RSMI_GPU_BLOCK_MMHUB:
2162 case RSMI_GPU_BLOCK_ATHUB:
2165 case RSMI_GPU_BLOCK_PCIE_BIF:
2168 case RSMI_GPU_BLOCK_HDP:
2171 case RSMI_GPU_BLOCK_XGMI_WAFL:
2172 block =
"XGMI_WAFL";
2174 case RSMI_GPU_BLOCK_DF:
2177 case RSMI_GPU_BLOCK_SMN:
2180 case RSMI_GPU_BLOCK_SEM:
2183 case RSMI_GPU_BLOCK_MP0:
2186 case RSMI_GPU_BLOCK_MP1:
2189 case RSMI_GPU_BLOCK_FUSE:
2195 sprintf(event_name_str,
"ecc_status:device=%i:block=%s", dev, block);
2196 }
else if (strcmp(
name,
"rsmi_dev_gpu_clk_freq_get") == 0) {
2197 const char *variant_str = NULL;
2200 variant_str =
"System";
2203 variant_str =
"DataFabric";
2206 variant_str =
"DisplayEngine";
2209 variant_str =
"SOC";
2212 variant_str =
"Memory";
2219 const char *subvariant_str = NULL;
2220 switch (subvariant) {
2222 subvariant_str =
"count";
2225 subvariant_str =
"current";
2232 sprintf(event_name_str,
"gpu_clk_freq_%s:device=%i:%s", variant_str, dev, subvariant_str);
2234 sprintf(event_name_str,
"gpu_clk_freq_%s:device=%i:idx=%i", variant_str, dev, idx);
2236 }
else if (strcmp(
name,
"rsmi_dev_gpu_clk_freq_set") == 0) {
2237 const char *variant_str = NULL;
2240 variant_str =
"System";
2243 variant_str =
"DataFabric";
2246 variant_str =
"DisplayEngine";
2249 variant_str =
"SOC";
2252 variant_str =
"Memory";
2258 sprintf(event_name_str,
"gpu_clk_freq_%s:device=%i:mask", variant_str, dev);
2259 }
else if (strcmp(
name,
"rsmi_dev_pci_bandwidth_get") == 0) {
2260 const char *variant_str = NULL;
2263 variant_str =
"count";
2266 variant_str =
"current";
2269 variant_str =
"rate_idx";
2272 variant_str =
"lane_idx";
2279 sprintf(event_name_str,
"pci_bandwidth_rate:device=%i:%s", dev, variant_str);
2281 sprintf(event_name_str,
"pci_bandwidth_rate:device=%i:%s=%i", dev, variant_str, (
int) subvariant);
2283 }
else if (strcmp(
name,
"rsmi_dev_pci_bandwidth_set") == 0) {
2284 sprintf(event_name_str,
"pci_bandwidth_rate:device=%i:mask", dev);
2285 }
else if (strcmp(
name,
"rsmi_dev_brand_get") == 0) {
2286 sprintf(event_name_str,
"device_brand:device=%i", dev);
2287 }
else if (strcmp(
name,
"rsmi_dev_name_get") == 0) {
2288 sprintf(event_name_str,
"device_name:device=%i", dev);
2289 }
else if (strcmp(
name,
"rsmi_dev_serial_number_get") == 0) {
2290 sprintf(event_name_str,
"device_serial_number:device=%i", dev);
2291 }
else if (strcmp(
name,
"rsmi_dev_subsystem_name_get") == 0) {
2292 sprintf(event_name_str,
"device_subsystem_name:device=%i", dev);
2293 }
else if (strcmp(
name,
"rsmi_dev_vbios_version_get") == 0) {
2294 sprintf(event_name_str,
"vbios_version:device=%i", dev);
2295 }
else if (strcmp(
name,
"rsmi_dev_vendor_name_get") == 0) {
2296 sprintf(event_name_str,
"vendor_name:device=%i", dev);
2297 }
else if (strcmp(
name,
"rsmi_dev_xgmi_evt_get") == 0) {
2298 const char *variant_str = NULL;
2301 variant_str =
"nop_sent_to_neighbor0";
2304 variant_str =
"req_sent_to_neighbor0";
2307 variant_str =
"res_sent_to_neighbor0";
2310 variant_str =
"data_beats_sent_to_neighbor0";
2313 variant_str =
"nop_sent_to_neighbor1";
2316 variant_str =
"req_sent_to_neighbor1";
2319 variant_str =
"res_sent_to_neighbor1";
2322 variant_str =
"data_beats_sent_to_neighbor1";
2325 variant_str =
"data_beats_sent_to_neighbor0";
2328 variant_str =
"data_beats_sent_to_neighbor1";
2331 variant_str =
"data_beats_sent_to_neighbor2";
2334 variant_str =
"data_beats_sent_to_neighbor3";
2337 variant_str =
"data_beats_sent_to_neighbor4";
2340 variant_str =
"data_beats_sent_to_neighbor5";
2345 sprintf(event_name_str,
"xgmi_%s:device=%i", variant_str, dev);
2346 }
else if (strcmp(
name,
"rsmi_dev_xgmi_bw_get") == 0) {
2349 sprintf(event_name_str,
"min_xgmi_internode_bw:device=%i:target=%i", dev, (
int) subvariant);
2352 sprintf(event_name_str,
"max_xgmi_internode_bw:device=%i:target=%i", dev, (
int) subvariant);
2361 return strdup(event_name_str);
2369 if (strcmp(
name,
"rsmi_dev_count") == 0) {
2370 return strdup(
"Number of Devices which have monitors, accessible by rocm_smi.");
2371 }
else if (strcmp(
name,
"rsmi_lib_version") == 0) {
2372 return strdup(
"Version of RSMI lib; 0x0000MMMMmmmmpppp Major, Minor, Patch.");
2373 }
else if (strcmp(
name,
"rsmi_dev_driver_version_str_get") == 0) {
2374 return strdup(
"Returns char* to z-terminated driver version string; do not free().");
2375 }
else if (strcmp(
name,
"rsmi_dev_id_get") == 0) {
2376 return strdup(
"Vendor supplied device id number. May be shared by same model devices; see pci_id for a unique identifier.");
2377 }
else if (strcmp(
name,
"rsmi_dev_subsystem_vendor_id_get") == 0) {
2378 return strdup(
"System vendor id number.");
2379 }
else if (strcmp(
name,
"rsmi_dev_vendor_id_get") == 0) {
2380 return strdup(
"Vendor id number.");
2381 }
else if (strcmp(
name,
"rsmi_dev_unique_id_get") == 0) {
2382 return strdup(
"Unique id for device.");
2383 }
else if (strcmp(
name,
"rsmi_dev_subsystem_id_get") == 0) {
2384 return strdup(
"Subsystem id number.");
2385 }
else if (strcmp(
name,
"rsmi_dev_drm_render_minor_get") == 0) {
2386 return strdup(
"DRM Minor Number associated with this device.");
2387 }
else if (strcmp(
name,
"rsmi_dev_overdrive_level_get") == 0) {
2388 return strdup(
"Overdriver Level \% for device, 0 to 20, max overclocked permitted. Read Only.");
2389 }
else if (strcmp(
name,
"rsmi_dev_perf_level_get") == 0) {
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);
2392 }
else if (strcmp(
name,
"rsmi_dev_perf_level_set") == 0) {
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);
2395 }
else if (strcmp(
name,
"rsmi_dev_memory_total_get") == 0) {
2397 case RSMI_MEM_TYPE_VRAM:
2398 sprintf(event_descr_str,
"Total VRAM memory.");
2400 case RSMI_MEM_TYPE_VIS_VRAM:
2401 sprintf(event_descr_str,
"Total Visible VRAM memory.");
2403 case RSMI_MEM_TYPE_GTT:
2404 sprintf(event_descr_str,
"Total Visible GTT (Graphics Translation Table) memory, aka GART memory.");
2409 }
else if (strcmp(
name,
"rsmi_dev_memory_usage_get") == 0) {
2411 case RSMI_MEM_TYPE_VRAM:
2412 sprintf(event_descr_str,
"VRAM memory in use.");
2414 case RSMI_MEM_TYPE_VIS_VRAM:
2415 sprintf(event_descr_str,
"Visible VRAM memory in use.");
2417 case RSMI_MEM_TYPE_GTT:
2418 sprintf(event_descr_str,
"(Graphic Translation Table) memory in use (aka GART memory).");
2423 }
else if (strcmp(
name,
"rsmi_dev_busy_percent_get") == 0) {
2424 return strdup(
"Percentage of time the device was busy doing any processing.");
2425 }
else if (strcmp(
name,
"rsmi_dev_memory_busy_percent_get") == 0) {
2426 return strdup(
"Percentage_of time any device memory is being used.");
2427 }
else if (strcmp(
name,
"rsmi_dev_pci_id_get") == 0) {
2428 return strdup(
"BDF (Bus/Device/Function) ID, unique per device.");
2429 }
else if (strcmp(
name,
"rsmi_dev_pci_replay_counter_get") == 0) {
2430 return strdup(
"Sum of the number of NAK's received by the GPU and the NAK's generated by the GPU.");
2431 }
else if (strcmp(
name,
"rsmi_dev_pci_throughput_get") == 0) {
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.");
2442 }
else if (strcmp(
name,
"rsmi_dev_power_profile_presets_get") == 0) {
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.");
2453 }
else if (strcmp(
name,
"rsmi_dev_power_profile_set") == 0) {
2454 return strdup(
"Write Only, set the power profile to one of the available masks. See ROCM_SMI Manual for details.");
2455 }
else if (strcmp(
name,
"rsmi_dev_fan_reset") == 0) {
2456 return strdup(
"Fan Reset. Write Only, data value is ignored.");
2457 }
else if (strcmp(
name,
"rsmi_dev_fan_rpms_get") == 0) {
2458 return strdup(
"Current fan speed in RPMs (Rotations Per Minute).");
2459 }
else if (strcmp(
name,
"rsmi_dev_fan_speed_max_get") == 0) {
2460 return strdup(
"Maximum possible fan speed in RPMs (Rotations Per Minute).");
2461 }
else if (strcmp(
name,
"rsmi_dev_fan_speed_get") == 0) {
2462 return strdup(
"Current fan speed in RPMs (Rotations Per Minute), Read Only, result [0-255].");
2463 }
else if (strcmp(
name,
"rsmi_dev_fan_speed_set") == 0) {
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].");
2465 }
else if (strcmp(
name,
"rsmi_dev_power_ave_get") == 0) {
2466 return strdup(
"Current Average Power consumption in microwatts. Requires root privileges.");
2467 }
else if (strcmp(
name,
"rsmi_dev_power_cap_get") == 0) {
2468 return strdup(
"Power cap in microwatts. Read Only. Between min/max (see power_cap_range_min/max). May require root privileges.");
2469 }
else if (strcmp(
name,
"rsmi_dev_power_cap_set") == 0) {
2470 return strdup(
"Power cap in microwatts. Read/Write. Between min/max (see power_cap_range_min/max). May require root privileges.");
2471 }
else if (strcmp(
name,
"rsmi_dev_power_cap_range_get") == 0) {
2474 return strdup(
"Power cap Minimum settable value, in microwatts.");
2476 return strdup(
"Power cap Maximim settable value, in microwatts.");
2480 }
else if (strcmp(
name,
"rsmi_dev_temp_metric_get") == 0) {
2482 case RSMI_TEMP_CURRENT:
2483 return strdup(
"Temperature current value, millidegrees Celsius.");
2485 return strdup(
"Temperature maximum value, millidegrees Celsius.");
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.");
2513 }
else if (strcmp(
name,
"rsmi_dev_firmware_version_get") == 0) {
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.");
2560 }
else if (strcmp(
name,
"rsmi_dev_ecc_count_get") == 0) {
2561 const char *block = NULL;
2563 case RSMI_GPU_BLOCK_UMC:
2566 case RSMI_GPU_BLOCK_SDMA:
2569 case RSMI_GPU_BLOCK_GFX:
2572 case RSMI_GPU_BLOCK_MMHUB:
2575 case RSMI_GPU_BLOCK_ATHUB:
2578 case RSMI_GPU_BLOCK_PCIE_BIF:
2581 case RSMI_GPU_BLOCK_HDP:
2584 case RSMI_GPU_BLOCK_XGMI_WAFL:
2585 block =
"XGMI_WAFL";
2587 case RSMI_GPU_BLOCK_DF:
2590 case RSMI_GPU_BLOCK_SMN:
2593 case RSMI_GPU_BLOCK_SEM:
2596 case RSMI_GPU_BLOCK_MP0:
2599 case RSMI_GPU_BLOCK_MP1:
2602 case RSMI_GPU_BLOCK_FUSE:
2609 switch (subvariant) {
2611 sprintf(event_descr_str,
"Correctable error count for the GPU Block %s.", block);
2614 sprintf(event_descr_str,
"Uncorrectable error count for the GPU Block %s.", block);
2619 }
else if (strcmp(
name,
"rsmi_dev_ecc_enabled_get") == 0) {
2620 return strdup(
"Bit mask of GPU blocks with ecc error counting enabled.");
2621 }
else if (strcmp(
name,
"rsmi_dev_ecc_status_get") == 0) {
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.");
2654 }
else if (strcmp(
name,
"rsmi_dev_gpu_clk_freq_get") == 0) {
2655 const char *variant_str = NULL;
2658 variant_str =
"System";
2661 variant_str =
"DataFabric";
2664 variant_str =
"DisplayEngine";
2667 variant_str =
"SOC";
2670 variant_str =
"Memory";
2677 switch (subvariant) {
2679 return strdup(
"Number of frequencies available.");
2681 return strdup(
"Current operating frequency.");
2686 sprintf(event_descr_str,
"Returns %s frequency value for supported_table[%u].", variant_str, idx);
2687 }
else if (strcmp(
name,
"rsmi_dev_gpu_clk_freq_set") == 0) {
2688 const char *variant_str = NULL;
2691 variant_str =
"System";
2694 variant_str =
"DataFabric";
2697 variant_str =
"DisplayEngine";
2700 variant_str =
"SOC";
2703 variant_str =
"Memory";
2708 sprintf(event_descr_str,
"Write Only. Sets bit mask, 1's for %s frequency value in support table permitted. All 0 mask prohibited.",
2710 }
else if (strcmp(
name,
"rsmi_dev_pci_bandwidth_get") == 0) {
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);
2720 sprintf(event_descr_str,
"Returns PCI bandwidth rate corresponding lane count from supported_table[%i].", (
int) subvariant);
2725 }
else if (strcmp(
name,
"rsmi_dev_pci_bandwidth_set") == 0) {
2726 return strdup(
"Write Only. Sets bit mask, 1's for PCI transfer rates in supported_table permitted. All 0 mask prohibited");
2727 }
else if (strcmp(
name,
"rsmi_dev_brand_get") == 0) {
2728 return strdup(
"Returns char* to z-terminated brand string; do not free().");
2729 }
else if (strcmp(
name,
"rsmi_dev_name_get") == 0) {
2730 return strdup(
"Returns char* to z-terminated name string; do not free().");
2731 }
else if (strcmp(
name,
"rsmi_dev_serial_number_get") == 0) {
2732 return strdup(
"Returns char* to z-terminated serial number string; do not free().");
2733 }
else if (strcmp(
name,
"rsmi_dev_subsystem_name_get") == 0) {
2734 return strdup(
"Returns char* to z-terminated subsystem name string; do not free().");
2735 }
else if (strcmp(
name,
"rsmi_dev_vbios_version_get") == 0) {
2736 return strdup(
"Returns char* to z-terminated vbios version string; do not free().");
2737 }
else if (strcmp(
name,
"rsmi_dev_vendor_name_get") == 0) {
2738 return strdup(
"Returns char* to z-terminated vendor name string; do not free().");
2739 }
else if (strcmp(
name,
"rsmi_dev_xgmi_evt_get") == 0) {
2740 const char *variant_str = NULL;
2743 variant_str =
"NOP operations sent to neightbor 0.";
2746 variant_str =
"Outgoing requests to neighbor 0.";
2749 variant_str =
"Outgoing responses sent to neighbor 0.";
2752 variant_str =
"Data beats sent to neighbor 0.";
2755 variant_str =
"NOP operations sent to neightbor 1.";
2758 variant_str =
"Outgoing requests to neighbor 1.";
2761 variant_str =
"Outgoing responses sent to neighbor 1.";
2764 variant_str =
"Data beats sent to neighbor 1.";
2767 variant_str =
"Data beats sent to neighbor 0.";
2770 variant_str =
"Data beats sent to neighbor 1.";
2773 variant_str =
"Data beats sent to neighbor 2.";
2776 variant_str =
"Data beats sent to neighbor 3.";
2779 variant_str =
"Data beats sent to neighbor 4.";
2782 variant_str =
"Data beats sent to neighbor 5.";
2787 sprintf(event_descr_str,
"%s", variant_str);
2788 }
else if (strcmp(
name,
"rsmi_dev_xgmi_bw_get") == 0) {
2791 sprintf(event_descr_str,
"%s.",
"Minimum bandwidth between devices");
2794 sprintf(event_descr_str,
"%s.",
"Maximum bandwidth between devices");
2803 return strdup(event_descr_str);
2809 if (strstr(
name,
"_get")) {
2811 }
else if (strstr(
name,
"_put") || strstr(
name,
"_reset")) {
2918 rsmi_status_t status;
2919 rsmi_event_group_t grp;
2921 switch (event->variant) {
2930 grp = RSMI_EVNT_GRP_XGMI;
2938 grp = RSMI_EVNT_GRP_XGMI_DATA_OUT;
2947 if (status != RSMI_STATUS_SUCCESS) {
2958 if (status != RSMI_STATUS_SUCCESS) {
2973 rsmi_status_t status;
2976 if (status != RSMI_STATUS_SUCCESS) {
2988 rsmi_status_t status;
2991 if (status != RSMI_STATUS_SUCCESS) {
3003 rsmi_status_t status;
3006 if (status != RSMI_STATUS_SUCCESS) {
3018 rsmi_status_t status;
3019 rsmi_counter_value_t value;
3026 if (status != RSMI_STATUS_SUCCESS) {
3030 event->value = (int64_t) value.value;
3043 rsmi_status_t status;
3046 if (status != RSMI_STATUS_SUCCESS) {
3050 switch (event->variant) {
3052 event->value = (int64_t)
min;
3055 event->value = (int64_t) max;
3086 rsmi_status_t status;
3089 if (status != RSMI_STATUS_SUCCESS) {
3092 event->value = (int64_t)(
version.major & 0x0000FFFF);
3093 event->value = (int64_t)(event->value << 16) | (
version.minor & 0x0000FFFF);
3094 event->value = (int64_t)(event->value << 16) | (
version.patch & 0x0000FFFF);
3107 rsmi_status_t status;
3109 if (status != RSMI_STATUS_SUCCESS) {
3113 event->value = (int64_t) event->scratch;
3126 rsmi_status_t status;
3129 if (status != RSMI_STATUS_SUCCESS) {
3132 event->value = (int64_t) data;
3145 rsmi_status_t status;
3148 if (status != RSMI_STATUS_SUCCESS) {
3151 event->value = (int64_t) data;
3164 rsmi_status_t status;
3167 if (status != RSMI_STATUS_SUCCESS) {
3170 event->value = (int64_t) data;
3183 rsmi_status_t status;
3186 if (status != RSMI_STATUS_SUCCESS) {
3189 event->value = (int64_t) data;
3202 rsmi_status_t status;
3205 if (status != RSMI_STATUS_SUCCESS) {
3208 event->value = (int64_t) data;
3221 rsmi_status_t status;
3224 if (status != RSMI_STATUS_SUCCESS) {
3227 event->value = (int64_t) data;
3236 if (!(mode & event->mode)) {
3243 rsmi_status_t status;
3247 if (status != RSMI_STATUS_SUCCESS) {
3250 event->value = (int64_t) data;
3252 data = (uint32_t) event->value;
3254 if (status != RSMI_STATUS_SUCCESS) {
3266 if (!(mode & event->mode)) {
3273 rsmi_status_t status;
3274 rsmi_dev_perf_level_t data;
3277 if (status != RSMI_STATUS_SUCCESS) {
3280 event->value = (int64_t) data;
3282 data = (rsmi_dev_perf_level_t) event->value;
3284 if (status != RSMI_STATUS_SUCCESS) {
3300 rsmi_status_t status;
3303 if (status != RSMI_STATUS_SUCCESS) {
3306 event->value = (int64_t) data;
3319 rsmi_status_t status;
3322 if (status != RSMI_STATUS_SUCCESS) {
3325 event->value = (int64_t) data;
3338 rsmi_status_t status;
3341 if (status != RSMI_STATUS_SUCCESS) {
3344 event->value = (int64_t) data;
3357 rsmi_status_t status;
3360 if (status != RSMI_STATUS_SUCCESS) {
3363 event->value = (int64_t) data;
3376 rsmi_status_t status;
3379 if (status != RSMI_STATUS_SUCCESS) {
3382 event->value = (int64_t) data;
3395 rsmi_status_t status;
3398 if (status != RSMI_STATUS_SUCCESS) {
3401 event->value = (int64_t) data;
3414 rsmi_status_t status;
3417 if (status != RSMI_STATUS_SUCCESS) {
3421 switch (event->variant) {
3423 event->value = (int64_t) data[0];
3426 event->value = (int64_t) data[1];
3429 event->value = (int64_t) data[2];
3447 rsmi_status_t status;
3448 rsmi_power_profile_status_t profile;
3450 if (status != RSMI_STATUS_SUCCESS) {
3454 switch (event->variant) {
3456 event->value = (int64_t) profile.num_profiles;
3459 event->value = (int64_t) profile.available_profiles;
3462 event->value = (int64_t) profile.current;
3482 rsmi_status_t status;
3483 rsmi_power_profile_preset_masks_t mask = (rsmi_power_profile_preset_masks_t) event->value;
3485 if (status != RSMI_STATUS_SUCCESS) {
3503 rsmi_status_t status;
3505 if (status != RSMI_STATUS_SUCCESS) {
3520 rsmi_status_t status;
3522 if (status != RSMI_STATUS_SUCCESS) {
3537 rsmi_status_t status;
3540 if (status != RSMI_STATUS_SUCCESS) {
3543 event->value = (int64_t) data;
3559 rsmi_status_t status;
3561 if (status != RSMI_STATUS_SUCCESS) {
3576 rsmi_status_t status;
3579 if (status != RSMI_STATUS_SUCCESS) {
3582 event->value = (int64_t) data;
3591 if (!(mode & event->mode)) {
3598 rsmi_status_t status;
3602 if (status != RSMI_STATUS_SUCCESS) {
3605 event->value = (int64_t) data;
3607 data = (uint64_t) event->value;
3609 if (status != RSMI_STATUS_SUCCESS) {
3625 rsmi_status_t status;
3628 if (status != RSMI_STATUS_SUCCESS) {
3632 switch (event->variant) {
3634 event->value = (int64_t) data[1];
3637 event->value = (int64_t) data[0];
3654 rsmi_status_t status;
3656 if (status != RSMI_STATUS_SUCCESS) {
3671 rsmi_status_t status;
3674 if (status != RSMI_STATUS_SUCCESS) {
3677 event->value = (int64_t) data;
3690 rsmi_status_t status;
3691 rsmi_error_count_t data;
3693 if (status != RSMI_STATUS_SUCCESS) {
3697 switch (event->subvariant) {
3699 event->value = (int64_t) data.correctable_err;
3702 event->value = (int64_t) data.uncorrectable_err;
3719 rsmi_status_t status;
3722 if (status != RSMI_STATUS_SUCCESS) {
3725 event->value = (int64_t) data;
3738 rsmi_status_t status;
3739 rsmi_ras_err_state_t data;
3741 if (status != RSMI_STATUS_SUCCESS) {
3744 event->value = (int64_t) data;
3753 if (!(mode & event->mode)) {
3760 rsmi_status_t status;
3764 if (status != RSMI_STATUS_SUCCESS) {
3767 uint32_t current, freq_id;
3768 switch (event->subvariant) {
3770 event->value = (int64_t)
freq_table[table_id].num_supported;
3774 event->value = (int64_t)
freq_table[table_id].frequency[current];
3778 event->value = (int64_t)
freq_table[table_id].frequency[freq_id];
3781 uint64_t data = (uint64_t) event->value;
3783 uint64_t mask = (1 <<
freq_table[freq_id].num_supported) - 1;
3784 if ((data & mask) == 0) {
3788 if (status != RSMI_STATUS_SUCCESS) {
3800 if (!(mode & event->mode)) {
3807 rsmi_status_t status;
3811 if (status != RSMI_STATUS_SUCCESS) {
3815 switch (event->variant) {
3817 event->value = (int64_t)
pcie_table[event->device].transfer_rate.num_supported;
3820 current =
pcie_table[event->device].transfer_rate.current;
3821 event->value = (int64_t)
pcie_table[
event->device].transfer_rate.frequency[current];
3825 current =
event->subvariant;
3826 event->value = (int64_t)
pcie_table[event->device].transfer_rate.frequency[current];
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) {
3838 if (status != RSMI_STATUS_SUCCESS) {
3854 rsmi_status_t status;
3856 if (status != RSMI_STATUS_SUCCESS) {
3860 event->value = (int64_t) event->scratch;
3873 rsmi_status_t status;
3875 if (status != RSMI_STATUS_SUCCESS) {
3879 event->value = (int64_t) event->scratch;
3892 rsmi_status_t status;
3894 if (status != RSMI_STATUS_SUCCESS) {
3898 event->value = (int64_t) event->scratch;
3911 rsmi_status_t status;
3913 if (status != RSMI_STATUS_SUCCESS) {
3917 event->value = (int64_t) event->scratch;
3930 rsmi_status_t status;
3932 if (status != RSMI_STATUS_SUCCESS) {
3936 event->value = (int64_t) event->scratch;
3949 rsmi_status_t status;
3951 if (status != RSMI_STATUS_SUCCESS) {
3955 event->value = (int64_t) event->scratch;
static int htable_insert(void *handle, const char *key, void *in)
static int htable_delete(void *handle, const char *key)
static int htable_shutdown(void *handle)
static int htable_find(void *handle, const char *key, void **out)
static int htable_init(void **handle)
char events[MAX_EVENTS][BUFSIZ]
static long iter[MAX_THREADS]
unsigned long AO_t __attribute__((__aligned__(4)))
Return codes and api definitions.
#define papi_calloc(a, b)
rocs_pci_throughput_variant_e
@ ROCS_PCI_THROUGHPUT_VARIANT__RECEIVED
@ ROCS_PCI_THROUGHPUT_VARIANT__NUM
@ ROCS_PCI_THROUGHPUT_VARIANT__MAX_PACKET_SIZE
@ ROCS_PCI_THROUGHPUT_VARIANT__SENT
@ ROCS_XGMI_BW_VARIANT__NUM
@ ROCS_XGMI_BW_VARIANT__MIN
@ ROCS_XGMI_BW_VARIANT__MAX
static rsmi_status_t(* rsmi_counter_control_p)(rsmi_event_handle_t, rsmi_counter_command_t, void *)
static rsmi_pcie_bandwidth_t * pcie_table
static rsmi_status_t(* rsmi_dev_overdrive_level_get_p)(uint32_t, uint32_t *)
static int acquire_devices(unsigned int *, int, int32_t *)
static rsmi_status_t(* rsmi_num_monitor_dev_p)(uint32_t *)
rocs_gpu_clk_freq_subvariant_e
@ ROCS_GPU_CLK_FREQ_SUBVARIANT__NUM
@ ROCS_GPU_CLK_FREQ_SUBVARIANT__COUNT
@ ROCS_GPU_CLK_FREQ_SUBVARIANT__CURRENT
static int start_simple(void *)
static int stop_xgmi_evt(void *)
static int access_rsmi_dev_unique_id(rocs_access_mode_e, void *)
static ntv_event_table_t ntv_table
static rsmi_status_t(* rsmi_dev_counter_group_supported_p)(uint32_t, rsmi_event_group_t)
static int handle_xgmi_events(int32_t dev, int *count, ntv_event_t *events)
int rocs_ctx_write(rocs_ctx_t rocs_ctx, long long *counts)
int rocs_err_get_last(const char **err_string)
static rsmi_status_t(* rsmi_counter_available_counters_get_p)(uint32_t, rsmi_event_group_t, uint32_t *)
static int access_rsmi_dev_busy_percent(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_dev_drm_render_minor_get_p)(uint32_t, uint32_t *)
@ ROCS_EVENT_TYPE__SPECIAL
@ ROCS_EVENT_TYPE__NORMAL
static rsmi_status_t(* rsmi_dev_power_cap_set_p)(uint32_t, uint32_t, uint64_t)
static int handle_special_events(const char *name, int32_t dev, int64_t variant, int64_t subvariant, int *count, ntv_event_t *events)
int rocs_evt_code_to_descr(unsigned int event_code, char *descr, int len)
static int get_ntv_events(ntv_event_t *, int)
static start_function_f get_start_func(const char *name)
static int load_rsmi_sym(void)
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_ecc_status_get_p)(uint32_t, rsmi_gpu_block_t, rsmi_ras_err_state_t *)
static rsmi_status_t(* rsmi_dev_perf_level_get_p)(uint32_t, rsmi_dev_perf_level_t *)
static int access_rsmi_dev_ecc_count(rocs_access_mode_e, void *)
@ ROCS_XGMI_VARIANT__MI50_1_RESPONSE_TX
@ ROCS_XGMI_VARIANT__MI50_0_NOP_TX
@ ROCS_XGMI_VARIANT__MI100_DATA_OUT_4
@ ROCS_XGMI_VARIANT__MI50_0_RESPONSE_TX
@ ROCS_XGMI_VARIANT__MI100_DATA_OUT_0
@ ROCS_XGMI_VARIANT__MI50_1_NOP_TX
@ ROCS_XGMI_VARIANT__MI50_0_REQUEST_TX
@ ROCS_XGMI_VARIANT__MI50_1_REQUEST_TX
@ ROCS_XGMI_VARIANT__MI50_0_BEATS_TX
@ ROCS_XGMI_VARIANT__MI100_DATA_OUT_5
@ ROCS_XGMI_VARIANT__MI50_1_BEATS_TX
@ ROCS_XGMI_VARIANT__MI100_DATA_OUT_1
@ ROCS_XGMI_VARIANT__MI100_DATA_OUT_3
@ ROCS_XGMI_VARIANT__MI100_DATA_OUT_2
static rsmi_status_t(* rsmi_dev_counter_destroy_p)(rsmi_event_handle_t)
static char * get_event_name(const char *name, int32_t dev, int64_t variant, int64_t subvariant)
static int access_rsmi_dev_memory_busy_percent(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_dev_power_cap_range_get_p)(uint32_t, uint32_t, uint64_t *, uint64_t *)
close_function_f close_func_p
static rsmi_status_t(* rsmi_version_get_p)(rsmi_version_t *)
static int access_rsmi_dev_memory_usage(rocs_access_mode_e, void *)
struct @6 event_function_table[]
static rsmi_status_t(* rsmi_dev_pci_id_get_p)(uint32_t, uint64_t *)
static rsmi_status_t(* rsmi_dev_pci_replay_counter_get_p)(uint32_t, uint64_t *)
static int access_rsmi_dev_pci_bandwidth(rocs_access_mode_e, void *)
static int access_rsmi_dev_subsystem_name(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_dev_gpu_clk_freq_set_p)(uint32_t, rsmi_clk_type_t, uint64_t)
static int release_devices(int32_t *)
static rsmi_status_t(* rsmi_func_iter_next_p)(rsmi_func_id_iter_handle_t)
static int stop_simple(void *)
int rocs_evt_name_to_code(const char *name, unsigned int *event_code)
static int start_xgmi_evt(void *)
static close_function_f get_close_func(const char *name)
static int access_rsmi_dev_vendor_name(rocs_access_mode_e, void *)
access_function_f access_func_p
stop_function_f stop_func_p
rocs_ecc_count_subvariant_e
@ ROCS_ECC_COUNT_SUBVARIANT__CORRECTABLE
@ ROCS_ECC_COUNT_SUBVARIANT__UNCORRECTABLE
@ ROCS_ECC_COUNT_SUBVARIANT__NUM
static int access_rsmi_dev_driver_version_str(rocs_access_mode_e, void *)
static int access_rsmi_dev_overdrive_level(rocs_access_mode_e, void *)
static rocs_access_mode_e get_access_mode(const char *)
static int get_ntv_events_count(int *count)
rocs_power_cap_range_variant_e
@ ROCS_POWER_CAP_RANGE_VARIANT__MIN
@ ROCS_POWER_CAP_RANGE_VARIANT__NUM
@ ROCS_POWER_CAP_RANGE_VARIANT__MAX
start_function_f start_func_p
static rsmi_status_t(* rsmi_dev_fan_reset_p)(uint32_t, uint32_t)
static stop_function_f get_stop_func(const char *name)
static rsmi_status_t(* rsmi_dev_brand_get_p)(uint32_t, char *, uint32_t)
static rsmi_status_t(* rsmi_shut_down_p)(void)
open_function_f open_func_p
static rsmi_status_t(* rsmi_dev_firmware_version_get_p)(uint32_t, rsmi_fw_block_t, uint64_t *)
static rsmi_status_t(* rsmi_dev_counter_create_p)(uint32_t, rsmi_event_type_t, rsmi_event_handle_t *)
static int access_rsmi_dev_gpu_clk_freq(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_dev_memory_reserved_pages_get_p)(uint32_t, uint32_t *, rsmi_retired_page_record_t *)
static int open_xgmi_evt(void *)
static int access_rsmi_dev_brand(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_dev_unique_id_get_p)(uint32_t, uint64_t *)
static int open_simple(void *)
static rsmi_status_t(* rsmi_dev_od_volt_curve_regions_get_p)(uint32_t, uint32_t *, rsmi_freq_volt_region_t *)
static int access_rsmi_dev_fan_reset(rocs_access_mode_e, void *)
static int access_rsmi_dev_power_profile_set(rocs_access_mode_e, void *)
static int access_rsmi_dev_memory_total(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_dev_pci_bandwidth_set_p)(uint32_t, uint64_t)
static int shutdown_device_table(void)
static int access_rsmi_dev_power_cap_range(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_dev_fan_speed_max_get_p)(uint32_t, uint32_t, uint64_t *)
static rsmi_status_t(* rsmi_dev_vendor_name_get_p)(uint32_t, char *, size_t)
static int access_rsmi_lib_version(rocs_access_mode_e, void *)
int rocs_ctx_close(rocs_ctx_t rocs_ctx)
@ ROCS_PCI_BW_VARIANT__COUNT
@ ROCS_PCI_BW_VARIANT__RATE_IDX
@ ROCS_PCI_BW_VARIANT__NUM
@ ROCS_PCI_BW_VARIANT__CURRENT
@ ROCS_PCI_BW_VARIANT__LANE_IDX
static int handle_xgmi_events_count(int32_t dev, int *count)
static open_function_f get_open_func(const char *name)
static rsmi_status_t(* rsmi_is_P2P_accessible_p)(uint32_t, uint32_t, int *)
static rsmi_status_t(* rsmi_init_p)(uint64_t)
static rsmi_status_t(* rsmi_dev_supported_func_iterator_open_p)(uint32_t, rsmi_func_id_iter_handle_t *)
static int access_rsmi_dev_pci_replay_counter(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_dev_memory_usage_get_p)(uint32_t, rsmi_memory_type_t, uint64_t *)
static int access_rsmi_dev_name(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_counter_read_p)(rsmi_event_type_t, rsmi_counter_value_t *)
static ntv_event_table_t * ntv_table_p
static int access_xgmi_bw(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_dev_overdrive_level_set_p)(uint32_t, uint32_t)
static rsmi_status_t(* rsmi_dev_power_cap_get_p)(uint32_t, uint32_t, uint64_t *)
static int access_rsmi_dev_count(rocs_access_mode_e, void *)
static int access_rsmi_dev_firmware_version(rocs_access_mode_e, void *)
static char * get_event_descr(const char *name, int64_t variant, int64_t subvariant)
static int access_rsmi_dev_serial_number(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_dev_memory_total_get_p)(uint32_t, rsmi_memory_type_t, uint64_t *)
static int access_rsmi_dev_vendor_id(rocs_access_mode_e, void *)
static int access_rsmi_dev_temp_metric(rocs_access_mode_e, void *)
int(* close_function_f)(void *arg)
static int access_rsmi_dev_power_profile_presets(rocs_access_mode_e, void *)
static int init_device_table(void)
static int access_rsmi_dev_power_cap(rocs_access_mode_e, void *)
int rocs_ctx_read(rocs_ctx_t rocs_ctx, long long **counts)
static int access_rsmi_dev_ecc_status(rocs_access_mode_e, void *)
#define PAPI_ROCMSMI_MAX_DEV_COUNT
static rsmi_status_t(* rsmi_dev_vendor_id_get_p)(uint32_t, uint16_t *)
static rsmi_status_t(* rsmi_dev_vbios_version_get_p)(uint32_t, char *, uint32_t)
int rocs_ctx_start(rocs_ctx_t rocs_ctx)
int rocs_ctx_reset(rocs_ctx_t rocs_ctx)
static rsmi_status_t(* rsmi_dev_ecc_enabled_get_p)(uint32_t, uint64_t *)
rocs_power_presets_variant_e
@ ROCS_POWER_PRESETS_VARIANT__CURRENT
@ ROCS_POWER_PRESETS_VARIANT__COUNT
@ ROCS_POWER_PRESETS_VARIANT__AVAIL_PROFILES
@ ROCS_POWER_PRESETS_VARIANT__NUM
static rsmi_status_t(* rsmi_dev_od_volt_info_get_p)(uint32_t, rsmi_od_volt_freq_data_t *)
static int close_simple(void *)
static rsmi_status_t(* rsmi_dev_serial_number_get_p)(uint32_t, char *, uint32_t)
static int access_rsmi_dev_ecc_enabled(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_minmax_bandwidth_get_p)(uint32_t, uint32_t, uint64_t *, uint64_t *)
int rocs_ctx_open(unsigned int *events_id, int num_events, rocs_ctx_t *rocs_ctx)
static rsmi_status_t(* rsmi_func_iter_value_get_p)(rsmi_func_id_iter_handle_t, rsmi_func_id_value_t *)
static int access_rsmi_dev_pci_throughput(rocs_access_mode_e, void *)
static access_function_f get_access_func(const char *name)
static rsmi_status_t(* rsmi_dev_fan_speed_set_p)(uint32_t, uint32_t, uint64_t)
static int access_rsmi_dev_vbios_version(rocs_access_mode_e, void *)
int rocs_ctx_stop(rocs_ctx_t rocs_ctx)
static int access_rsmi_dev_pci_id(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_dev_perf_level_set_p)(int32_t, rsmi_dev_perf_level_t)
rocs_gpu_clk_freq_variant_e
@ ROCS_GPU_CLK_FREQ_VARIANT__MEMORY
@ ROCS_GPU_CLK_FREQ_VARIANT__DATA_FABRIC
@ ROCS_GPU_CLK_FREQ_VARIANT__SYSTEM
@ ROCS_GPU_CLK_FREQ_VARIANT__NUM
@ ROCS_GPU_CLK_FREQ_VARIANT__SOC
@ ROCS_GPU_CLK_FREQ_VARIANT__DISPLAY_ENGINE
int(* open_function_f)(void *arg)
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_fan_speed_get_p)(uint32_t, uint32_t, int64_t *)
static rsmi_status_t(* rsmi_dev_power_profile_presets_get_p)(uint32_t, uint32_t, rsmi_power_profile_status_t *)
#define PAPI_ROCMSMI_MAX_SUBVAR
static rsmi_status_t(* rsmi_dev_busy_percent_get_p)(uint32_t, uint32_t *)
@ ROCS_ACCESS_MODE__WRITE
static int32_t device_mask
int rocs_evt_code_to_name(unsigned int event_code, char *name, int len)
static rsmi_status_t(* rsmi_dev_name_get_p)(uint32_t, char *, size_t)
static rsmi_status_t(* rsmi_dev_memory_busy_percent_get_p)(uint32_t, uint32_t *)
int(* stop_function_f)(void *arg)
static rsmi_status_t(* rsmi_dev_subsystem_vendor_id_get_p)(uint32_t, uint16_t *)
static int access_rsmi_dev_drm_render_minor(rocs_access_mode_e, void *)
static int access_rsmi_dev_subsystem_id(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_dev_id_get_p)(uint32_t, uint16_t *)
static int init_event_table(void)
static rsmi_status_t(* rsmi_dev_pci_bandwidth_get_p)(uint32_t, rsmi_pcie_bandwidth_t *)
static int access_rsmi_dev_fan_speed(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_dev_ecc_count_get_p)(uint32_t, rsmi_gpu_block_t, rsmi_error_count_t *)
static int unload_rsmi_sym(void)
#define ROCMSMI_NUM_INFO_EVENTS
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_power_avg_get_p)(uint32_t, uint32_t, uint64_t *)
unsigned int _rocm_smi_lock
static int access_rsmi_dev_fan_rpms(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_dev_supported_func_iterator_close_p)(rsmi_func_id_iter_handle_t *)
static rsmi_status_t(* rsmi_dev_gpu_clk_freq_get_p)(uint32_t, rsmi_clk_type_t, rsmi_frequencies_t *)
static char error_string[PAPI_MAX_STR_LEN+1]
static int close_xgmi_evt(void *)
static int shutdown_event_table(void)
static int access_rsmi_dev_subsystem_vendor_id(rocs_access_mode_e, void *)
static int handle_special_events_count(const char *v_name, int32_t dev, int64_t v_variant, int64_t v_subvariant, int *count)
static rsmi_status_t(* rsmi_version_str_get_p)(rsmi_sw_component_t, char *, size_t)
int(* start_function_f)(void *arg)
static int access_rsmi_dev_id(rocs_access_mode_e, void *)
static int32_t device_count
static rsmi_status_t(* rsmi_dev_subsystem_name_get_p)(uint32_t, char *, size_t)
static int access_rsmi_dev_power_ave(rocs_access_mode_e, void *)
static int access_rsmi_dev_fan_speed_max(rocs_access_mode_e, void *)
int rocs_evt_enum(unsigned int *event_code, int modifier)
static rsmi_status_t(* rsmi_status_string_p)(rsmi_status_t, const char **)
static int access_rsmi_dev_perf_level(rocs_access_mode_e, void *)
static rsmi_status_t(* rsmi_dev_subsystem_id_get_p)(uint32_t, uint16_t *)
static int access_xgmi_evt(rocs_access_mode_e, void *)
int(* access_function_f)(rocs_access_mode_e mode, void *arg)
static rsmi_frequencies_t * freq_table
static rsmi_status_t(* rsmi_dev_fan_rpms_get_p)(uint32_t, uint32_t, int64_t *)
static rsmi_status_t(* rsmi_dev_pci_throughput_get_p)(uint32_t, uint64_t *, uint64_t *, uint64_t *)
#define ROCS_EVENTS_OPENED
#define ROCS_EVENTS_RUNNING
open_function_f open_func_p
stop_function_f stop_func_p
access_function_f access_func_p
close_function_f close_func_p
start_function_f start_func_p
inline_static int _papi_hwi_lock(int lck)
inline_static int _papi_hwi_unlock(int lck)