AI/rocm-systems
2
0
Rozštěpit 0
Zdrojový kód Úkoly Pull requesty Akce Balíčky Projekty Vydání Wiki Aktivita

Merge amd-dev into amd-master 20231122

Procházet zdrojové kódy 
Signed-off-by: Maisam Arif <maisarif@amd.com>
Change-Id: I3f08e74f5b3459a14ab36d0e6c5ef52631786cc6


[ROCm/amdsmi commit: f319f73567]
Tento commit je obsažen v:
Maisam Arif
2023-11-22 03:38:56 -06:00
rodič 7f68a873bf 09f4046345
revize 73505488d8
27 změnil soubory, kde provedl 10945 přidání a 1269 odebrání
Stáhněte soubor záplaty Stáhněte rozdílový soubor Rozbalit všechny soubory Sbalit všechny soubory
projects/amdsmi/CMakeLists.txt
+6 -3
Zobrazit soubor
@@ -141,6 +141,7 @@ set(CMN_SRC_LIST
"${ROCM_SRC_DIR}/rocm_smi_counters.cc"
"${ROCM_SRC_DIR}/rocm_smi_device.cc"
"${ROCM_SRC_DIR}/rocm_smi_gpu_metrics.cc"
"${ROCM_SRC_DIR}/rocm_smi_binary_parser.cc"
"${ROCM_SRC_DIR}/rocm_smi_io_link.cc"
"${ROCM_SRC_DIR}/rocm_smi_kfd.cc"
"${ROCM_SRC_DIR}/rocm_smi_main.cc"
@@ -163,6 +164,7 @@ set(CMN_INC_LIST
"${ROCM_INC_DIR}/rocm_smi_counters.h"
"${ROCM_INC_DIR}/rocm_smi_device.h"
"${ROCM_INC_DIR}/rocm_smi_gpu_metrics.h"
"${ROCM_INC_DIR}/rocm_smi_binary_parser.h"
"${ROCM_INC_DIR}/rocm_smi_exception.h"
"${ROCM_INC_DIR}/rocm_smi_io_link.h"
"${ROCM_INC_DIR}/rocm_smi_kfd.h"
@@ -245,12 +247,12 @@ install(
#Debian package specific variables
set(CPACK_DEBIAN_PACKAGE_PROVIDES "amd-smi")
set(CPACK_DEBIAN_PACKAGE_RECOMMENDS "sudo, python3-argcomplete, libdrm-dev, python3-yaml")
set(CPACK_DEBIAN_PACKAGE_RECOMMENDS "python3-argcomplete, libdrm-dev, python3-yaml")
set(CPACK_DEBIAN_ASAN_PACKAGE_RECOMMENDS ${CPACK_DEBIAN_PACKAGE_RECOMMENDS})
set(CPACK_DEBIAN_DEV_PACKAGE_RECOMMENDS ${CPACK_DEBIAN_PACKAGE_RECOMMENDS})
set(CPACK_DEBIAN_ASAN_PACKAGE_PROVIDES "${AMD_SMI_PACKAGE}-asan")
set(CPACK_DEBIAN_DEV_PACKAGE_PROVIDES "${AMD_SMI_PACKAGE}")
set(CPACK_DEBIAN_PACKAGE_DEPENDS "python3 (>= 3.6.8), python3-pip")
set(CPACK_DEBIAN_PACKAGE_DEPENDS "sudo, python3 (>= 3.6.8), python3-pip")
set(CPACK_DEBIAN_ASAN_PACKAGE_DEPENDS ${CPACK_DEBIAN_PACKAGE_DEPENDS})
set(CPACK_DEBIAN_DEV_PACKAGE_DEPENDS ${CPACK_DEBIAN_PACKAGE_DEPENDS})
@@ -269,11 +271,12 @@ endif()
set(CPACK_RPM_PACKAGE_PROVIDES "amd-smi")
set(CPACK_RPM_DEV_PACKAGE_PROVIDES "${AMD_SMI_PACKAGE}")
set(CPACK_RPM_ASAN_PACKAGE_PROVIDES "${AMD_SMI_PACKAGE}-asan")
# NOTE: RPM SUGGESTS DO NOT WORK! https://bugzilla.redhat.com/show_bug.cgi?id=1811358
set(CPACK_RPM_PACKAGE_SUGGESTS "python3-argcomplete")
set(CPACK_RPM_DEV_PACKAGE_SUGGESTS ${CPACK_RPM_PACKAGE_SUGGESTS})
set(CPACK_RPM_ASAN_PACKAGE_SUGGESTS ${CPACK_RPM_PACKAGE_SUGGESTS})
# python version gated by rhel8 :(
set(CPACK_RPM_PACKAGE_REQUIRES "python3 >= 3.6.8, python3-pip, python3-PyYAML")
set(CPACK_RPM_PACKAGE_REQUIRES "sudo, python3 >= 3.6.8, python3-pip, python3-PyYAML")
set(CPACK_RPM_DEV_PACKAGE_REQUIRES ${CPACK_RPM_PACKAGE_REQUIRES})
set(CPACK_RPM_ASAN_PACKAGE_REQUIRES ${CPACK_RPM_PACKAGE_REQUIRES})
projects/amdsmi/DEBIAN/postinst.in
+16 -14
Zobrazit soubor
@@ -105,7 +105,6 @@ do_ldconfig() {
}
do_install_amdsmi_python_lib() {
echo "Installing AMD-SMI python library (amdsmi)..."
# get python version
local python3_minor_version
python3_minor_version=$(python3 -c 'import sys;print(sys.version_info.minor)')
@@ -123,8 +122,11 @@ do_install_amdsmi_python_lib() {
return
fi
local PREVIOUS_PIP_ROOT_ACTION="$PIP_ROOT_USER_ACTION"
local PREVIOUS_PIP_ROOT_USER_ACTION="$PIP_ROOT_USER_ACTION"
export PIP_ROOT_USER_ACTION=ignore
# python3.11 requires --break-system-packages
local PREVIOUS_PIP_BREAK_SYSTEM_PACKAGES="$PIP_BREAK_SYSTEM_PACKAGES"
export PIP_BREAK_SYSTEM_PACKAGES=1
# Remove old python library
local pip_list_output
@@ -140,21 +142,21 @@ do_install_amdsmi_python_lib() {
local python_lib_path=@CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@
python3 -m pip install "$python_lib_path" --quiet --disable-pip-version-check
unset PIP_ROOT_USER_ACTION
export PIP_ROOT_USER_ACTION="$PREVIOUS_PIP_ROOT_ACTION"
export PIP_ROOT_USER_ACTION="$PREVIOUS_PIP_ROOT_USER_ACTION"
export PIP_BREAK_SYSTEM_PACKAGES="$PREVIOUS_PIP_BREAK_SYSTEM_PACKAGES"
pip_list_output=$(python3 -m pip list --disable-pip-version-check)
# check pip list output for argcomplete
if [[ $pip_list_output == *"argcomplete"* ]]; then
activate-global-python-argcomplete3
# Newer versions of argcomplete do not have the 3 at the end
if [ $? -ne 0 ]; then
echo "[WARNING] Could not find activate-global-python-argcomplete3. "\
"Trying newer activate-global-python-argcomplete..."
activate-global-python-argcomplete
# only try to activate argcomplete if such command exists
if command -v activate-global-python-argcomplete &>/dev/null; then
activate-global-python-argcomplete
else
# try older argcomplete3 version
if command -v activate-global-python-argcomplete3 &>/dev/null; then
activate-global-python-argcomplete3
else
echo "[WARNING] Could not find argcomplete or argcomplete3. "\
"Argument completion will not work..."
fi
fi
echo "Installed AMD-SMI python library (amdsmi)..."
}
case "$1" in
projects/amdsmi/DEBIAN/prerm.in
+12 -20
Zobrazit soubor
@@ -10,15 +10,17 @@ rm_ldconfig() {
rm_leftovers() {
# remove pyc files generated by python
rm -rf @CPACK_PACKAGING_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBEXECDIR@/amdsmi_cli/__pycache__
rm -rf @CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/amdsmi/__pycache__
rm -rf "@CPACK_PACKAGING_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBEXECDIR@/amdsmi_cli/__pycache__"
rm -rf "@CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/amdsmi/__pycache__"
# remove build and egg files
rm -rf "@CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/amdsmi.egg-info"
rm -rf "@CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/build"
# remove leftover doc files
rm -rf @CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/../doc/amd_smi*
rm -rf @CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/
# remove leftover libs
rm -rf @CPACK_PACKAGING_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBDIR@/libamd_smi.so*
if test -e "@CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/../doc/amd_smi*"; then
rm -rf "@CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/../doc/amd_smi*"
fi
}
rm_logFolder() {
@@ -41,7 +43,6 @@ return_logrotateToOrigConfig() {
}
rm_python_lib() {
echo "Removing AMD-SMI python library (amdsmi)..."
# get python version
local python3_minor_version
python3_minor_version=$(python3 -c 'import sys;print(sys.version_info.minor)')
@@ -63,26 +64,17 @@ rm_python_lib() {
pip_list_output=$(python3 -m pip list --disable-pip-version-check)
# check pip list output for amdsmi
if [[ $pip_list_output == *"amdsmi"* ]]; then
local PREVIOUS_PIP_ROOT_ACTION="$PIP_ROOT_USER_ACTION"
export PIP_ROOT_USER_ACTION=ignore
echo "Detected AMD-SMI python library (amdsmi)..."
python3 -m pip uninstall amdsmi --yes --quiet --disable-pip-version-check
echo "Removed AMD-SMI python library (amdsmi)..."
unset PIP_ROOT_USER_ACTION
export PIP_ROOT_USER_ACTION="$PREVIOUS_PIP_ROOT_ACTION"
PIP_ROOT_USER_ACTION=ignore PIP_BREAK_SYSTEM_PACKAGES=1 python3 -m pip uninstall amdsmi --yes --quiet --disable-pip-version-check
fi
local pip_list_output
pip_list_output=$(python3 -m pip list --disable-pip-version-check)
# check pip list output for amdsmi
if [[ $pip_list_output == *"amdsmi"* ]]; then
echo "[WARNING] AMD-SMI python library (amdsmi) is still installed in pip. "\
"Check post install to ensure version is correct"
return
else
echo "Removed AMD-SMI python library (amdsmi)..."
fi
echo "Removed AMD-SMI python library (amdsmi)..."
}
projects/amdsmi/RPM/post.in
+17 -16
Zobrazit soubor
@@ -12,8 +12,7 @@ do_configureLogrotate() {
chmod -R a+rw "${logPath}"
chmod a+rw "${logFile}"
command -v logrotate &>/dev/null
if [ $? -ne 0 ]; then
if ! command -v logrotate &>/dev/null; then
echo "[WARNING] Detected logrotate is not installed."\
"$packageName logs (when turned on) will not rotate properly."
return
@@ -105,7 +104,6 @@ do_ldconfig() {
}
do_install_amdsmi_python_lib() {
echo "Installing AMD-SMI python library (amdsmi)..."
# get python version
local python3_minor_version
python3_minor_version=$(python3 -c 'import sys;print(sys.version_info.minor)')
@@ -123,8 +121,11 @@ do_install_amdsmi_python_lib() {
return
fi
local PREVIOUS_PIP_ROOT_ACTION="$PIP_ROOT_USER_ACTION"
local PREVIOUS_PIP_ROOT_USER_ACTION="$PIP_ROOT_USER_ACTION"
export PIP_ROOT_USER_ACTION=ignore
# python3.11 requires --break-system-packages
local PREVIOUS_PIP_BREAK_SYSTEM_PACKAGES="$PIP_BREAK_SYSTEM_PACKAGES"
export PIP_BREAK_SYSTEM_PACKAGES=1
# Remove old python library
local pip_list_output
@@ -140,21 +141,21 @@ do_install_amdsmi_python_lib() {
local python_lib_path=@CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@
python3 -m pip install "$python_lib_path" --quiet --disable-pip-version-check
unset PIP_ROOT_USER_ACTION
export PIP_ROOT_USER_ACTION="$PREVIOUS_PIP_ROOT_ACTION"
export PIP_ROOT_USER_ACTION="$PREVIOUS_PIP_ROOT_USER_ACTION"
export PIP_BREAK_SYSTEM_PACKAGES="$PREVIOUS_PIP_BREAK_SYSTEM_PACKAGES"
pip_list_output=$(python3 -m pip list --disable-pip-version-check)
# check pip list output for argcomplete
if [[ $pip_list_output == *"argcomplete"* ]]; then
activate-global-python-argcomplete3
# Newer versions of argcomplete do not have the 3 at the end
if [ $? -ne 0 ]; then
echo "[WARNING] Could not find activate-global-python-argcomplete3. "\
"Trying newer activate-global-python-argcomplete..."
activate-global-python-argcomplete
# only try to activate argcomplete if such command exists
if command -v activate-global-python-argcomplete &>/dev/null; then
activate-global-python-argcomplete
else
# try older argcomplete3 version
if command -v activate-global-python-argcomplete3 &>/dev/null; then
activate-global-python-argcomplete3
else
echo "[WARNING] Could not find argcomplete or argcomplete3. "\
"Argument completion will not work..."
fi
fi
echo "Installed AMD-SMI python library (amdsmi)..."
}
# post install or upgrade, $i is 1 or 2 -> do these actions
projects/amdsmi/RPM/preun.in
+12 -20
Zobrazit soubor
@@ -2,15 +2,17 @@
rm_leftovers() {
# remove pyc files generated by python
rm -rf @CPACK_PACKAGING_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBEXECDIR@/amdsmi_cli/__pycache__
rm -rf @CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/amdsmi/__pycache__
rm -rf "@CPACK_PACKAGING_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBEXECDIR@/amdsmi_cli/__pycache__"
rm -rf "@CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/amdsmi/__pycache__"
# remove build and egg files
rm -rf "@CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/amdsmi.egg-info"
rm -rf "@CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/build"
# remove leftover doc files
rm -rf @CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/../doc/amd_smi*
rm -rf @CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/
# remove leftover libs
rm -rf @CPACK_PACKAGING_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBDIR@/libamd_smi.so*
if test -e "@CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/../doc/amd_smi*"; then
rm -rf "@CPACK_PACKAGING_INSTALL_PREFIX@/@SHARE_INSTALL_PREFIX@/../doc/amd_smi*"
fi
}
rm_logFolder() {
@@ -33,7 +35,6 @@ return_logrotateToOrigConfig() {
}
rm_python_lib() {
echo "Removing AMD-SMI python library (amdsmi)..."
# get python version
local python3_minor_version
python3_minor_version=$(python3 -c 'import sys;print(sys.version_info.minor)')
@@ -55,26 +56,17 @@ rm_python_lib() {
pip_list_output=$(python3 -m pip list --disable-pip-version-check)
# check pip list output for amdsmi
if [[ $pip_list_output == *"amdsmi"* ]]; then
local PREVIOUS_PIP_ROOT_ACTION="$PIP_ROOT_USER_ACTION"
export PIP_ROOT_USER_ACTION=ignore
echo "Detected AMD-SMI python library (amdsmi)..."
python3 -m pip uninstall amdsmi --yes --quiet --disable-pip-version-check
echo "Removed AMD-SMI python library (amdsmi)..."
unset PIP_ROOT_USER_ACTION
export PIP_ROOT_USER_ACTION="$PREVIOUS_PIP_ROOT_ACTION"
PIP_ROOT_USER_ACTION=ignore PIP_BREAK_SYSTEM_PACKAGES=1 python3 -m pip uninstall amdsmi --yes --quiet --disable-pip-version-check
fi
local pip_list_output
pip_list_output=$(python3 -m pip list --disable-pip-version-check)
# check pip list output for amdsmi
if [[ $pip_list_output == *"amdsmi"* ]]; then
echo "[WARNING] AMD-SMI python library (amdsmi) is still installed in pip. "\
"Check post install to ensure version is correct"
return
else
echo "Removed AMD-SMI python library (amdsmi)..."
fi
echo "Removed AMD-SMI python library (amdsmi)..."
}
projects/amdsmi/amdsmi_cli/amdsmi_commands.py
+73 -28
Zobrazit soubor
@@ -505,12 +505,16 @@ class AMDSMICommands():
ras_info = amdsmi_interface.amdsmi_get_gpu_ras_feature_info(args.gpu)
for key, value in ras_info.items():
if isinstance(value, int):
if value == 65535 or value == 0:
if value == 65535:
logging.debug(f"Failed to get ras {key} for gpu {gpu_id}")
ras_info[key] = "N/A"
continue
if self.logger.is_human_readable_format():
ras_info[key] = f"{value}"
if key != "eeprom_version":
if value:
ras_info[key] = "ENABLED"
else:
ras_info[key] = "DISABLED"
ras_dict.update(ras_info)
except amdsmi_exception.AmdSmiLibraryException as e:
logging.debug("Failed to get ras info for gpu %s | %s", gpu_id, e.get_error_info())
@@ -524,13 +528,13 @@ class AMDSMICommands():
if 'partition' in current_platform_args:
if args.partition:
try:
compute_partition = amdsmi_interface.amdsmi_dev_compute_partition_get(args.gpu)
compute_partition = amdsmi_interface.amdsmi_get_gpu_compute_partition(args.gpu)
except amdsmi_exception.AmdSmiLibraryException as e:
compute_partition = "N/A"
logging.debug("Failed to get compute partition info for gpu %s | %s", gpu_id, e.get_error_info())
try:
memory_partition = amdsmi_interface.amdsmi_dev_memory_partition_get(args.gpu)
memory_partition = amdsmi_interface.amdsmi_get_gpu_memory_partition(args.gpu)
except amdsmi_exception.AmdSmiLibraryException as e:
memory_partition = "N/A"
logging.debug("Failed to get memory partition info for gpu %s | %s", gpu_id, e.get_error_info())
@@ -981,12 +985,13 @@ class AMDSMICommands():
'current_soc_voltage': "N/A",
'current_mem_voltage': "N/A",
'power_limit': "N/A",
'power_management': "N/A"}
'power_management': "N/A",
'throttle_status': "N/A"}
try:
power_info = amdsmi_interface.amdsmi_get_power_info(args.gpu)
for key, value in power_info.items():
if value == 0xFFFFFFFF:
if value == 0xFFFF:
power_info[key] = "N/A"
elif self.logger.is_human_readable_format():
if "voltage" in key:
@@ -994,7 +999,11 @@ class AMDSMICommands():
elif "power" in key:
power_info[key] = f"{value} W"
power_dict['current_power'] = power_info['average_socket_power']
power_dict['current_power'] = power_info['current_socket_power']
if power_dict['current_power'] == "N/A":
power_dict['current_power'] = power_info['average_socket_power']
power_dict['current_gfx_voltage'] = power_info['gfx_voltage']
power_dict['current_soc_voltage'] = power_info['soc_voltage']
power_dict['current_mem_voltage'] = power_info['mem_voltage']
@@ -1012,6 +1021,16 @@ class AMDSMICommands():
except amdsmi_exception.AmdSmiLibraryException as e:
logging.debug("Failed to get power management status for gpu %s | %s", gpu_id, e.get_error_info())
try:
throttle_status = amdsmi_interface.amdsmi_get_gpu_metrics_throttle_status(args.gpu)
if throttle_status:
power_dict['throttle_status'] = "THROTTLED"
else:
power_dict['throttle_status'] = "UNTHROTTLED"
except amdsmi_exception.AmdSmiLibraryException as e:
logging.debug("Failed to get throttle status for gpu %s | %s", gpu_id, e.get_error_info())
values_dict['power'] = power_dict
if "clock" in current_platform_args:
if args.clock:
@@ -1060,8 +1079,12 @@ class AMDSMICommands():
logging.debug("Failed to get %s clock info for gpu %s | %s", clock_name, gpu_id, e.get_error_info())
try:
# is_clk_locked = amdsmi_interface.amdsmi_is_clk_locked(args.gpu, amdsmi_interface.AmdSmiClkType.GFX)
is_clk_locked = "N/A"
is_clk_locked = amdsmi_interface.amdsmi_get_gpu_metrics_gfxclk_lock_status(args.gpu)
if self.logger.is_human_readable_format():
if is_clk_locked:
is_clk_locked = "LOCKED"
else:
is_clk_locked = "UNLOCKED"
except amdsmi_exception.AmdSmiLibraryException as e:
is_clk_locked = "N/A"
logging.debug("Failed to get gfx clock lock status info for gpu %s | %s", gpu_id, e.get_error_info())
@@ -1114,7 +1137,7 @@ class AMDSMICommands():
if self.logger.is_human_readable_format():
unit = '\N{DEGREE SIGN}C'
for temperature_key, temperature_value in temperatures.items():
if 'AMD_SMI_STATUS' not in str(temperature_value):
if 'N/A' not in str(temperature_value):
temperatures[temperature_key] = f"{temperature_value} {unit}"
values_dict['temperature'] = temperatures
@@ -1123,12 +1146,26 @@ class AMDSMICommands():
ecc_count = {}
try:
ecc_count = amdsmi_interface.amdsmi_get_gpu_total_ecc_count(args.gpu)
ecc_count['correctable'] = ecc_count.pop('correctable_count')
ecc_count['uncorrectable'] = ecc_count.pop('uncorrectable_count')
ecc_count['total_correctable'] = ecc_count.pop('correctable_count')
ecc_count['total_uncorrectable'] = ecc_count.pop('uncorrectable_count')
except amdsmi_exception.AmdSmiLibraryException as e:
ecc_count['correctable'] = "N/A"
ecc_count['uncorrectable'] = "N/A"
logging.debug("Failed to get ecc count for gpu %s | %s", gpu_id, e.get_error_info())
ecc_count['total_correctable'] = "N/A"
ecc_count['total_uncorrectable'] = "N/A"
ecc_count['cache_correctable'] = "N/A"
ecc_count['cache_uncorrectable'] = "N/A"
logging.debug("Failed to get total ecc count for gpu %s | %s", gpu_id, e.get_error_info())
if ecc_count['total_correctable'] != "N/A":
# Get the UMC error count for getting total cache correctable errors
umc_block = amdsmi_interface.AmdSmiGpuBlock['UMC']
try:
umc_count = amdsmi_interface.amdsmi_get_gpu_ecc_count(args.gpu, umc_block)
ecc_count['cache_correctable'] = ecc_count['total_correctable'] - umc_count['correctable_count']
ecc_count['cache_uncorrectable'] = ecc_count['total_uncorrectable'] - umc_count['uncorrectable_count']
except amdsmi_exception.AmdSmiLibraryException as e:
ecc_count['cache_correctable'] = "N/A"
ecc_count['cache_uncorrectable'] = "N/A"
logging.debug("Failed to get cache ecc count for gpu %s at block %s | %s", gpu_id, umc_block, e.get_error_info())
values_dict['ecc'] = ecc_count
if "pcie" in current_platform_args:
@@ -1162,23 +1199,28 @@ class AMDSMICommands():
logging.debug("Failed to get pcie link status for gpu %s | %s", gpu_id, e.get_error_info())
try:
pci_replay_counter = amdsmi_interface.amdsmi_get_gpu_pci_replay_counter(args.gpu)
pci_replay_counter = amdsmi_interface.amdsmi_get_gpu_metrics_pcie_replay_count_acc(args.gpu)
pcie_dict['replay_count'] = pci_replay_counter
except amdsmi_exception.AmdSmiLibraryException as e:
logging.debug("Failed to get pci replay counter for gpu %s | %s", gpu_id, e.get_error_info())
logging.debug("Falling back to sysfs pci replay counter for gpu %s | %s", gpu_id, e.get_error_info())
try:
pci_replay_counter = amdsmi_interface.amdsmi_get_gpu_pci_replay_counter(args.gpu)
pcie_dict['replay_count'] = pci_replay_counter
except amdsmi_exception.AmdSmiLibraryException as err:
pcie_dict['replay_count'] = "N/A"
logging.debug("Failed to get sysfs fallback pci replay counter for gpu %s | %s", gpu_id, err.get_error_info())
try:
# l0_to_recovery_counter = amdsmi_interface.amdsmi_get_gpu_pci_l0_to_recovery_counter(args.gpu)
# pcie_dict['l0_to_recovery_count'] = l0_to_recovery_counter
pcie_dict['l0_to_recovery_count'] = "N/A"
l0_to_recovery_counter = amdsmi_interface.amdsmi_get_gpu_metrics_pcie_l0_recov_count_acc(args.gpu)
pcie_dict['l0_to_recovery_count'] = l0_to_recovery_counter
except amdsmi_exception.AmdSmiLibraryException as e:
pcie_dict['l0_to_recovery_count'] = "N/A"
logging.debug("Failed to get pcie l0 to recovery counter for gpu %s | %s", gpu_id, e.get_error_info())
try:
# pci_replay_rollover_counter = amdsmi_interface.amdsmi_get_gpu_pci_replay_rollover_counter(args.gpu)
# pcie_dict['replay_roll_over_count'] = pci_replay_rollover_counter
pcie_dict['replay_roll_over_count'] = "N/A"
pci_replay_rollover_counter = amdsmi_interface.amdsmi_get_gpu_metrics_pcie_replay_rover_count_acc(args.gpu)
pcie_dict['replay_rollover_count'] = pci_replay_rollover_counter
except amdsmi_exception.AmdSmiLibraryException as e:
pcie_dict['replay_roll_over_count'] = "N/A"
logging.debug("Failed to get pcie replay rollover counter for gpu %s | %s", gpu_id, e.get_error_info())
@@ -1702,7 +1744,10 @@ class AMDSMICommands():
try:
dest_gpu_link_status = amdsmi_interface.amdsmi_is_P2P_accessible(src_gpu, dest_gpu)
src_gpu_links[dest_gpu_key] = bool(dest_gpu_link_status)
if dest_gpu_link_status:
src_gpu_links[dest_gpu_key] = "ENABLED"
else:
src_gpu_links[dest_gpu_key] = "DISABLED"
except amdsmi_exception.AmdSmiLibraryException as e:
src_gpu_links[dest_gpu_key] = "N/A"
logging.debug("Failed to get link status for %s to %s | %s",
@@ -1943,7 +1988,7 @@ class AMDSMICommands():
if args.compute_partition:
compute_partition = amdsmi_interface.AmdSmiComputePartitionType[args.compute_partition]
try:
amdsmi_interface.amdsmi_dev_compute_partition_set(args.gpu, compute_partition)
amdsmi_interface.amdsmi_set_gpu_compute_partition(args.gpu, compute_partition)
except amdsmi_exception.AmdSmiLibraryException as e:
if e.get_error_code() == amdsmi_interface.amdsmi_wrapper.AMDSMI_STATUS_NO_PERM:
raise PermissionError('Command requires elevation') from e
@@ -1952,7 +1997,7 @@ class AMDSMICommands():
if args.memory_partition:
memory_partition = amdsmi_interface.AmdSmiMemoryPartitionType[args.memory_partition]
try:
amdsmi_interface.amdsmi_dev_memory_partition_set(args.gpu, memory_partition)
amdsmi_interface.amdsmi_set_gpu_memory_partition(args.gpu, memory_partition)
except amdsmi_exception.AmdSmiLibraryException as e:
if e.get_error_code() == amdsmi_interface.amdsmi_wrapper.AMDSMI_STATUS_NO_PERM:
raise PermissionError('Command requires elevation') from e
@@ -2165,7 +2210,7 @@ class AMDSMICommands():
self.logger.store_output(args.gpu, 'reset_perf_determinism', result)
if args.compute_partition:
try:
amdsmi_interface.amdsmi_dev_compute_partition_reset(args.gpu)
amdsmi_interface.amdsmi_reset_gpu_compute_partition(args.gpu)
result = 'Successfully reset compute partition'
except amdsmi_exception.AmdSmiLibraryException as e:
if e.get_error_code() == amdsmi_interface.amdsmi_wrapper.AMDSMI_STATUS_NO_PERM:
@@ -2175,7 +2220,7 @@ class AMDSMICommands():
self.logger.store_output(args.gpu, 'reset_compute_partition', result)
if args.memory_partition:
try:
amdsmi_interface.amdsmi_dev_memory_partition_reset(args.gpu)
amdsmi_interface.amdsmi_reset_gpu_memory_partition(args.gpu)
result = 'Successfully reset memory partition'
except amdsmi_exception.AmdSmiLibraryException as e:
if e.get_error_code() == amdsmi_interface.amdsmi_wrapper.AMDSMI_STATUS_NO_PERM:
projects/amdsmi/amdsmi_cli/amdsmi_parser.py
+1 -1
Zobrazit soubor
@@ -248,7 +248,7 @@ class AMDSMIParser(argparse.ArgumentParser):
command_modifier_group.add_argument('--file', action=self._check_output_file_path(), type=str, required=False, help=file_help)
# Placing loglevel outside the subcommands so it can be used with any subcommand
command_modifier_group.add_argument('--loglevel', action='store', required=False, help=loglevel_help, default='ERROR', metavar='LEVEL',
command_modifier_group.add_argument('--loglevel', action='store', type=str.upper, required=False, help=loglevel_help, default='ERROR', metavar='LEVEL',
choices=loglevel_choices)
projects/amdsmi/include/amd_smi/amdsmi.h
+1321 -82
Zobrazit soubor
Rozdílový obsah nebyl zobrazen, protože je příliš veliký Načíst rozdílové porovnání
projects/amdsmi/include/amd_smi/impl/amd_smi_common.h
+3
Zobrazit soubor
@@ -56,6 +56,7 @@ const std::map<rsmi_status_t, amdsmi_status_t> rsmi_status_map = {
{RSMI_STATUS_SUCCESS, AMDSMI_STATUS_SUCCESS},
{RSMI_STATUS_INVALID_ARGS, AMDSMI_STATUS_INVAL},
{RSMI_STATUS_NOT_SUPPORTED, AMDSMI_STATUS_NOT_SUPPORTED},
{RSMI_STATUS_FILE_ERROR, AMDSMI_STATUS_FILE_ERROR},
{RSMI_STATUS_PERMISSION, AMDSMI_STATUS_NO_PERM},
{RSMI_STATUS_OUT_OF_RESOURCES, AMDSMI_STATUS_OUT_OF_RESOURCES},
{RSMI_STATUS_INTERNAL_EXCEPTION, AMDSMI_STATUS_INTERNAL_EXCEPTION},
@@ -71,6 +72,8 @@ const std::map<rsmi_status_t, amdsmi_status_t> rsmi_status_map = {
{RSMI_STATUS_UNEXPECTED_DATA, AMDSMI_STATUS_UNEXPECTED_DATA},
{RSMI_STATUS_BUSY, AMDSMI_STATUS_BUSY},
{RSMI_STATUS_REFCOUNT_OVERFLOW, AMDSMI_STATUS_REFCOUNT_OVERFLOW},
{RSMI_STATUS_SETTING_UNAVAILABLE, AMDSMI_STATUS_SETTING_UNAVAILABLE},
{RSMI_STATUS_AMDGPU_RESTART_ERR, AMDSMI_STATUS_AMDGPU_RESTART_ERR},
{RSMI_STATUS_UNKNOWN_ERROR, AMDSMI_STATUS_UNKNOWN_ERROR},
};
projects/amdsmi/py-interface/README.md
+1627 -20
Zobrazit soubor
Rozdílový obsah nebyl zobrazen, protože je příliš veliký Načíst rozdílové porovnání
projects/amdsmi/py-interface/__init__.py
+53 -1
Zobrazit soubor
@@ -130,7 +130,6 @@ from .amdsmi_interface import amdsmi_get_gpu_volt_metric
# # Clock, Power and Performance Query
from .amdsmi_interface import amdsmi_get_utilization_count
from .amdsmi_interface import amdsmi_get_gpu_perf_level
from .amdsmi_interface import amdsmi_set_gpu_perf_determinism_mode
from .amdsmi_interface import amdsmi_get_gpu_overdrive_level
from .amdsmi_interface import amdsmi_get_clk_freq
from .amdsmi_interface import amdsmi_get_gpu_od_volt_info
@@ -195,6 +194,59 @@ from .amdsmi_interface import amdsmi_topo_get_link_type
from .amdsmi_interface import amdsmi_is_P2P_accessible
from .amdsmi_interface import amdsmi_get_xgmi_info
# # Individual GPU Metrics Functions
from .amdsmi_interface import amdsmi_get_gpu_metrics_temp_hotspot
from .amdsmi_interface import amdsmi_get_gpu_metrics_temp_mem
from .amdsmi_interface import amdsmi_get_gpu_metrics_temp_vrsoc
from .amdsmi_interface import amdsmi_get_gpu_metrics_curr_socket_power
from .amdsmi_interface import amdsmi_get_gpu_metrics_avg_gfx_activity
from .amdsmi_interface import amdsmi_get_gpu_metrics_avg_umc_activity
from .amdsmi_interface import amdsmi_get_gpu_metrics_energy_acc
from .amdsmi_interface import amdsmi_get_gpu_metrics_system_clock_counter
from .amdsmi_interface import amdsmi_get_gpu_metrics_firmware_timestamp
from .amdsmi_interface import amdsmi_get_gpu_metrics_throttle_status
from .amdsmi_interface import amdsmi_get_gpu_metrics_pcie_link_width
from .amdsmi_interface import amdsmi_get_gpu_metrics_pcie_link_speed
from .amdsmi_interface import amdsmi_get_gpu_metrics_xgmi_link_width
from .amdsmi_interface import amdsmi_get_gpu_metrics_xgmi_link_speed
from .amdsmi_interface import amdsmi_get_gpu_metrics_gfxclk_lock_status
from .amdsmi_interface import amdsmi_get_gpu_metrics_gfx_activity_acc
from .amdsmi_interface import amdsmi_get_gpu_metrics_mem_activity_acc
from .amdsmi_interface import amdsmi_get_gpu_metrics_pcie_bandwidth_acc
from .amdsmi_interface import amdsmi_get_gpu_metrics_pcie_bandwidth_inst
from .amdsmi_interface import amdsmi_get_gpu_metrics_pcie_l0_recov_count_acc
from .amdsmi_interface import amdsmi_get_gpu_metrics_pcie_replay_count_acc
from .amdsmi_interface import amdsmi_get_gpu_metrics_pcie_replay_rover_count_acc
from .amdsmi_interface import amdsmi_get_gpu_metrics_curr_uclk
from .amdsmi_interface import amdsmi_get_gpu_metrics_temp_hbm
from .amdsmi_interface import amdsmi_get_gpu_metrics_vcn_activity
from .amdsmi_interface import amdsmi_get_gpu_metrics_xgmi_read_data
from .amdsmi_interface import amdsmi_get_gpu_metrics_xgmi_write_data
from .amdsmi_interface import amdsmi_get_gpu_metrics_curr_gfxclk
from .amdsmi_interface import amdsmi_get_gpu_metrics_curr_socclk
from .amdsmi_interface import amdsmi_get_gpu_metrics_curr_vclk0
from .amdsmi_interface import amdsmi_get_gpu_metrics_curr_dclk0
from .amdsmi_interface import amdsmi_get_gpu_metrics_temp_edge
from .amdsmi_interface import amdsmi_get_gpu_metrics_temp_vrgfx
from .amdsmi_interface import amdsmi_get_gpu_metrics_temp_vrmem
from .amdsmi_interface import amdsmi_get_gpu_metrics_avg_mm_activity
from .amdsmi_interface import amdsmi_get_gpu_metrics_curr_vclk1
from .amdsmi_interface import amdsmi_get_gpu_metrics_curr_dclk1
from .amdsmi_interface import amdsmi_get_gpu_metrics_indep_throttle_status
from .amdsmi_interface import amdsmi_get_gpu_metrics_avg_socket_power
from .amdsmi_interface import amdsmi_get_gpu_metrics_curr_fan_speed
from .amdsmi_interface import amdsmi_get_gpu_metrics_avg_gfx_clock_frequency
from .amdsmi_interface import amdsmi_get_gpu_metrics_avg_soc_clock_frequency
from .amdsmi_interface import amdsmi_get_gpu_metrics_avg_uclock_frequency
from .amdsmi_interface import amdsmi_get_gpu_metrics_avg_vclock0_frequency
from .amdsmi_interface import amdsmi_get_gpu_metrics_avg_dclock0_frequency
from .amdsmi_interface import amdsmi_get_gpu_metrics_avg_vclock1_frequency
from .amdsmi_interface import amdsmi_get_gpu_metrics_avg_dclock1_frequency
from .amdsmi_interface import amdsmi_get_gpu_metrics_volt_soc
from .amdsmi_interface import amdsmi_get_gpu_metrics_volt_gfx
from .amdsmi_interface import amdsmi_get_gpu_metrics_volt_mem
from .amdsmi_interface import amdsmi_get_gpu_metrics_header_info
# # Enums
from .amdsmi_interface import AmdSmiInitFlags
from .amdsmi_interface import AmdSmiContainerTypes
projects/amdsmi/py-interface/amdsmi_interface.py
+1119 -13
Zobrazit soubor
Rozdílový obsah nebyl zobrazen, protože je příliš veliký Načíst rozdílové porovnání
projects/amdsmi/py-interface/amdsmi_wrapper.py
+371 -85
Zobrazit soubor
@@ -284,6 +284,8 @@ amdsmi_status_t__enumvalues = {
51: 'AMDSMI_NO_DRV',
52: 'AMDSMI_FILE_NOT_FOUND',
53: 'AMDSMI_ARG_PTR_NULL',
54: 'AMDSMI_STATUS_AMDGPU_RESTART_ERR',
55: 'AMDSMI_STATUS_SETTING_UNAVAILABLE',
4294967294: 'AMDSMI_STATUS_MAP_ERROR',
4294967295: 'AMDSMI_STATUS_UNKNOWN_ERROR',
}
@@ -326,6 +328,8 @@ AMDSMI_HSMP_TIMEOUT = 50
AMDSMI_NO_DRV = 51
AMDSMI_FILE_NOT_FOUND = 52
AMDSMI_ARG_PTR_NULL = 53
AMDSMI_STATUS_AMDGPU_RESTART_ERR = 54
AMDSMI_STATUS_SETTING_UNAVAILABLE = 55
AMDSMI_STATUS_MAP_ERROR = 4294967294
AMDSMI_STATUS_UNKNOWN_ERROR = 4294967295
amdsmi_status_t = ctypes.c_uint32 # enum
@@ -862,6 +866,7 @@ class struct_amdsmi_power_info_t(Structure):
struct_amdsmi_power_info_t._pack_ = 1 # source:False
struct_amdsmi_power_info_t._fields_ = [
('current_socket_power', ctypes.c_uint32),
('average_socket_power', ctypes.c_uint32),
('gfx_voltage', ctypes.c_uint32),
('soc_voltage', ctypes.c_uint32),
@@ -1479,13 +1484,62 @@ struct_amdsmi_gpu_metrics_t._fields_ = [
('current_fan_speed', ctypes.c_uint16),
('pcie_link_width', ctypes.c_uint16),
('pcie_link_speed', ctypes.c_uint16),
('padding', ctypes.c_uint16),
('PADDING_0', ctypes.c_ubyte * 2),
('gfx_activity_acc', ctypes.c_uint32),
('mem_activity_acc', ctypes.c_uint32),
('temperature_hbm', ctypes.c_uint16 * 4),
('firmware_timestamp', ctypes.c_uint64),
('voltage_soc', ctypes.c_uint16),
('voltage_gfx', ctypes.c_uint16),
('voltage_mem', ctypes.c_uint16),
('PADDING_1', ctypes.c_ubyte * 2),
('indep_throttle_status', ctypes.c_uint64),
('current_socket_power', ctypes.c_uint16),
('vcn_activity', ctypes.c_uint16 * 4),
('PADDING_2', ctypes.c_ubyte * 2),
('gfxclk_lock_status', ctypes.c_uint32),
('xgmi_link_width', ctypes.c_uint16),
('xgmi_link_speed', ctypes.c_uint16),
('PADDING_3', ctypes.c_ubyte * 4),
('pcie_bandwidth_acc', ctypes.c_uint64),
('pcie_bandwidth_inst', ctypes.c_uint64),
('pcie_l0_to_recov_count_acc', ctypes.c_uint64),
('pcie_replay_count_acc', ctypes.c_uint64),
('pcie_replay_rover_count_acc', ctypes.c_uint64),
('xgmi_read_data_acc', ctypes.c_uint64 * 8),
('xgmi_write_data_acc', ctypes.c_uint64 * 8),
('current_gfxclks', ctypes.c_uint16 * 8),
('current_socclks', ctypes.c_uint16 * 4),
('current_vclk0s', ctypes.c_uint16 * 4),
('current_dclk0s', ctypes.c_uint16 * 4),
]
amdsmi_gpu_metrics_t = struct_amdsmi_gpu_metrics_t
class struct_amdsmi_name_value_t(Structure):
pass
struct_amdsmi_name_value_t._pack_ = 1 # source:False
struct_amdsmi_name_value_t._fields_ = [
('name', ctypes.c_char * 64),
('value', ctypes.c_uint64),
]
amdsmi_name_value_t = struct_amdsmi_name_value_t
# values for enumeration 'amdsmi_reg_type_t'
amdsmi_reg_type_t__enumvalues = {
0: 'AMDSMI_REG_XGMI',
1: 'AMDSMI_REG_WAFL',
2: 'AMDSMI_REG_PCIE',
3: 'AMDSMI_REG_USR',
4: 'AMDSMI_REG_USR1',
}
AMDSMI_REG_XGMI = 0
AMDSMI_REG_WAFL = 1
AMDSMI_REG_PCIE = 2
AMDSMI_REG_USR = 3
AMDSMI_REG_USR1 = 4
amdsmi_reg_type_t = ctypes.c_uint32 # enum
class struct_amdsmi_ras_feature_t(Structure):
pass
@@ -1796,6 +1850,12 @@ amdsmi_get_gpu_od_volt_info.argtypes = [amdsmi_processor_handle, ctypes.POINTER(
amdsmi_get_gpu_metrics_info = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_info
amdsmi_get_gpu_metrics_info.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_info.argtypes = [amdsmi_processor_handle, ctypes.POINTER(struct_amdsmi_gpu_metrics_t)]
amdsmi_get_gpu_pm_metrics_info = _libraries['libamd_smi.so'].amdsmi_get_gpu_pm_metrics_info
amdsmi_get_gpu_pm_metrics_info.restype = amdsmi_status_t
amdsmi_get_gpu_pm_metrics_info.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.POINTER(struct_amdsmi_name_value_t)), ctypes.POINTER(ctypes.c_uint32)]
amdsmi_get_gpu_reg_table_info = _libraries['libamd_smi.so'].amdsmi_get_gpu_reg_table_info
amdsmi_get_gpu_reg_table_info.restype = amdsmi_status_t
amdsmi_get_gpu_reg_table_info.argtypes = [amdsmi_processor_handle, amdsmi_reg_type_t, ctypes.POINTER(ctypes.POINTER(struct_amdsmi_name_value_t)), ctypes.POINTER(ctypes.c_uint32)]
amdsmi_set_gpu_clk_range = _libraries['libamd_smi.so'].amdsmi_set_gpu_clk_range
amdsmi_set_gpu_clk_range.restype = amdsmi_status_t
amdsmi_set_gpu_clk_range.argtypes = [amdsmi_processor_handle, uint64_t, uint64_t, amdsmi_clk_type_t]
@@ -1883,24 +1943,24 @@ amdsmi_topo_get_link_type.argtypes = [amdsmi_processor_handle, amdsmi_processor_
amdsmi_is_P2P_accessible = _libraries['libamd_smi.so'].amdsmi_is_P2P_accessible
amdsmi_is_P2P_accessible.restype = amdsmi_status_t
amdsmi_is_P2P_accessible.argtypes = [amdsmi_processor_handle, amdsmi_processor_handle, ctypes.POINTER(ctypes.c_bool)]
amdsmi_dev_compute_partition_get = _libraries['libamd_smi.so'].amdsmi_dev_compute_partition_get
amdsmi_dev_compute_partition_get.restype = amdsmi_status_t
amdsmi_dev_compute_partition_get.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_char), uint32_t]
amdsmi_dev_compute_partition_set = _libraries['libamd_smi.so'].amdsmi_dev_compute_partition_set
amdsmi_dev_compute_partition_set.restype = amdsmi_status_t
amdsmi_dev_compute_partition_set.argtypes = [amdsmi_processor_handle, amdsmi_compute_partition_type_t]
amdsmi_dev_compute_partition_reset = _libraries['libamd_smi.so'].amdsmi_dev_compute_partition_reset
amdsmi_dev_compute_partition_reset.restype = amdsmi_status_t
amdsmi_dev_compute_partition_reset.argtypes = [amdsmi_processor_handle]
amdsmi_dev_memory_partition_get = _libraries['libamd_smi.so'].amdsmi_dev_memory_partition_get
amdsmi_dev_memory_partition_get.restype = amdsmi_status_t
amdsmi_dev_memory_partition_get.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_char), uint32_t]
amdsmi_dev_memory_partition_set = _libraries['libamd_smi.so'].amdsmi_dev_memory_partition_set
amdsmi_dev_memory_partition_set.restype = amdsmi_status_t
amdsmi_dev_memory_partition_set.argtypes = [amdsmi_processor_handle, amdsmi_memory_partition_type_t]
amdsmi_dev_memory_partition_reset = _libraries['libamd_smi.so'].amdsmi_dev_memory_partition_reset
amdsmi_dev_memory_partition_reset.restype = amdsmi_status_t
amdsmi_dev_memory_partition_reset.argtypes = [amdsmi_processor_handle]
amdsmi_get_gpu_compute_partition = _libraries['libamd_smi.so'].amdsmi_get_gpu_compute_partition
amdsmi_get_gpu_compute_partition.restype = amdsmi_status_t
amdsmi_get_gpu_compute_partition.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_char), uint32_t]
amdsmi_set_gpu_compute_partition = _libraries['libamd_smi.so'].amdsmi_set_gpu_compute_partition
amdsmi_set_gpu_compute_partition.restype = amdsmi_status_t
amdsmi_set_gpu_compute_partition.argtypes = [amdsmi_processor_handle, amdsmi_compute_partition_type_t]
amdsmi_reset_gpu_compute_partition = _libraries['libamd_smi.so'].amdsmi_reset_gpu_compute_partition
amdsmi_reset_gpu_compute_partition.restype = amdsmi_status_t
amdsmi_reset_gpu_compute_partition.argtypes = [amdsmi_processor_handle]
amdsmi_get_gpu_memory_partition = _libraries['libamd_smi.so'].amdsmi_get_gpu_memory_partition
amdsmi_get_gpu_memory_partition.restype = amdsmi_status_t
amdsmi_get_gpu_memory_partition.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_char), uint32_t]
amdsmi_set_gpu_memory_partition = _libraries['libamd_smi.so'].amdsmi_set_gpu_memory_partition
amdsmi_set_gpu_memory_partition.restype = amdsmi_status_t
amdsmi_set_gpu_memory_partition.argtypes = [amdsmi_processor_handle, amdsmi_memory_partition_type_t]
amdsmi_reset_gpu_memory_partition = _libraries['libamd_smi.so'].amdsmi_reset_gpu_memory_partition
amdsmi_reset_gpu_memory_partition.restype = amdsmi_status_t
amdsmi_reset_gpu_memory_partition.argtypes = [amdsmi_processor_handle]
amdsmi_init_gpu_event_notification = _libraries['libamd_smi.so'].amdsmi_init_gpu_event_notification
amdsmi_init_gpu_event_notification.restype = amdsmi_status_t
amdsmi_init_gpu_event_notification.argtypes = [amdsmi_processor_handle]
@@ -1967,6 +2027,173 @@ amdsmi_get_gpu_process_info.argtypes = [amdsmi_processor_handle, amdsmi_process_
amdsmi_get_gpu_total_ecc_count = _libraries['libamd_smi.so'].amdsmi_get_gpu_total_ecc_count
amdsmi_get_gpu_total_ecc_count.restype = amdsmi_status_t
amdsmi_get_gpu_total_ecc_count.argtypes = [amdsmi_processor_handle, ctypes.POINTER(struct_amdsmi_error_count_t)]
gpu_metric_temp_hbm_t = ctypes.c_uint16 * 4
gpu_metric_vcn_activity_t = ctypes.c_uint16 * 4
gpu_metric_xgmi_read_data_acc_t = ctypes.c_uint64 * 8
gpu_metric_xgmi_write_data_acc_t = ctypes.c_uint64 * 8
gpu_metric_curr_gfxclk_t = ctypes.c_uint16 * 8
gpu_metric_curr_socclk_t = ctypes.c_uint16 * 4
gpu_metric_curr_vclk0_t = ctypes.c_uint16 * 4
gpu_metric_curr_dclk0_t = ctypes.c_uint16 * 4
amdsmi_get_gpu_metrics_temp_hotspot = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_temp_hotspot
amdsmi_get_gpu_metrics_temp_hotspot.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_temp_hotspot.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_temp_mem = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_temp_mem
amdsmi_get_gpu_metrics_temp_mem.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_temp_mem.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_temp_vrsoc = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_temp_vrsoc
amdsmi_get_gpu_metrics_temp_vrsoc.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_temp_vrsoc.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_curr_socket_power = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_curr_socket_power
amdsmi_get_gpu_metrics_curr_socket_power.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_curr_socket_power.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_avg_gfx_activity = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_avg_gfx_activity
amdsmi_get_gpu_metrics_avg_gfx_activity.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_avg_gfx_activity.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_avg_umc_activity = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_avg_umc_activity
amdsmi_get_gpu_metrics_avg_umc_activity.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_avg_umc_activity.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_energy_acc = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_energy_acc
amdsmi_get_gpu_metrics_energy_acc.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_energy_acc.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint64)]
amdsmi_get_gpu_metrics_system_clock_counter = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_system_clock_counter
amdsmi_get_gpu_metrics_system_clock_counter.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_system_clock_counter.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint64)]
amdsmi_get_gpu_metrics_firmware_timestamp = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_firmware_timestamp
amdsmi_get_gpu_metrics_firmware_timestamp.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_firmware_timestamp.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint64)]
amdsmi_get_gpu_metrics_throttle_status = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_throttle_status
amdsmi_get_gpu_metrics_throttle_status.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_throttle_status.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint32)]
amdsmi_get_gpu_metrics_pcie_link_width = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_pcie_link_width
amdsmi_get_gpu_metrics_pcie_link_width.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_pcie_link_width.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_pcie_link_speed = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_pcie_link_speed
amdsmi_get_gpu_metrics_pcie_link_speed.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_pcie_link_speed.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_xgmi_link_width = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_xgmi_link_width
amdsmi_get_gpu_metrics_xgmi_link_width.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_xgmi_link_width.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_xgmi_link_speed = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_xgmi_link_speed
amdsmi_get_gpu_metrics_xgmi_link_speed.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_xgmi_link_speed.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_gfxclk_lock_status = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_gfxclk_lock_status
amdsmi_get_gpu_metrics_gfxclk_lock_status.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_gfxclk_lock_status.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint32)]
amdsmi_get_gpu_metrics_gfx_activity_acc = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_gfx_activity_acc
amdsmi_get_gpu_metrics_gfx_activity_acc.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_gfx_activity_acc.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint32)]
amdsmi_get_gpu_metrics_mem_activity_acc = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_mem_activity_acc
amdsmi_get_gpu_metrics_mem_activity_acc.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_mem_activity_acc.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint32)]
amdsmi_get_gpu_metrics_pcie_bandwidth_acc = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_pcie_bandwidth_acc
amdsmi_get_gpu_metrics_pcie_bandwidth_acc.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_pcie_bandwidth_acc.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint64)]
amdsmi_get_gpu_metrics_pcie_bandwidth_inst = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_pcie_bandwidth_inst
amdsmi_get_gpu_metrics_pcie_bandwidth_inst.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_pcie_bandwidth_inst.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint64)]
amdsmi_get_gpu_metrics_pcie_l0_recov_count_acc = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_pcie_l0_recov_count_acc
amdsmi_get_gpu_metrics_pcie_l0_recov_count_acc.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_pcie_l0_recov_count_acc.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint64)]
amdsmi_get_gpu_metrics_pcie_replay_count_acc = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_pcie_replay_count_acc
amdsmi_get_gpu_metrics_pcie_replay_count_acc.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_pcie_replay_count_acc.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint64)]
amdsmi_get_gpu_metrics_pcie_replay_rover_count_acc = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_pcie_replay_rover_count_acc
amdsmi_get_gpu_metrics_pcie_replay_rover_count_acc.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_pcie_replay_rover_count_acc.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint64)]
amdsmi_get_gpu_metrics_curr_uclk = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_curr_uclk
amdsmi_get_gpu_metrics_curr_uclk.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_curr_uclk.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_temp_hbm = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_temp_hbm
amdsmi_get_gpu_metrics_temp_hbm.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_temp_hbm.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16 * 4)]
amdsmi_get_gpu_metrics_vcn_activity = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_vcn_activity
amdsmi_get_gpu_metrics_vcn_activity.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_vcn_activity.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16 * 4)]
amdsmi_get_gpu_metrics_xgmi_read_data = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_xgmi_read_data
amdsmi_get_gpu_metrics_xgmi_read_data.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_xgmi_read_data.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint64 * 8)]
amdsmi_get_gpu_metrics_xgmi_write_data = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_xgmi_write_data
amdsmi_get_gpu_metrics_xgmi_write_data.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_xgmi_write_data.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint64 * 8)]
amdsmi_get_gpu_metrics_curr_gfxclk = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_curr_gfxclk
amdsmi_get_gpu_metrics_curr_gfxclk.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_curr_gfxclk.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16 * 8)]
amdsmi_get_gpu_metrics_curr_socclk = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_curr_socclk
amdsmi_get_gpu_metrics_curr_socclk.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_curr_socclk.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16 * 4)]
amdsmi_get_gpu_metrics_curr_vclk0 = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_curr_vclk0
amdsmi_get_gpu_metrics_curr_vclk0.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_curr_vclk0.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16 * 4)]
amdsmi_get_gpu_metrics_curr_dclk0 = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_curr_dclk0
amdsmi_get_gpu_metrics_curr_dclk0.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_curr_dclk0.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16 * 4)]
amdsmi_get_gpu_metrics_temp_edge = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_temp_edge
amdsmi_get_gpu_metrics_temp_edge.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_temp_edge.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_temp_vrgfx = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_temp_vrgfx
amdsmi_get_gpu_metrics_temp_vrgfx.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_temp_vrgfx.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_temp_vrmem = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_temp_vrmem
amdsmi_get_gpu_metrics_temp_vrmem.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_temp_vrmem.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_avg_mm_activity = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_avg_mm_activity
amdsmi_get_gpu_metrics_avg_mm_activity.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_avg_mm_activity.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_curr_vclk1 = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_curr_vclk1
amdsmi_get_gpu_metrics_curr_vclk1.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_curr_vclk1.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_curr_dclk1 = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_curr_dclk1
amdsmi_get_gpu_metrics_curr_dclk1.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_curr_dclk1.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_indep_throttle_status = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_indep_throttle_status
amdsmi_get_gpu_metrics_indep_throttle_status.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_indep_throttle_status.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint64)]
amdsmi_get_gpu_metrics_avg_socket_power = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_avg_socket_power
amdsmi_get_gpu_metrics_avg_socket_power.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_avg_socket_power.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_curr_fan_speed = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_curr_fan_speed
amdsmi_get_gpu_metrics_curr_fan_speed.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_curr_fan_speed.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_avg_gfx_clock_frequency = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_avg_gfx_clock_frequency
amdsmi_get_gpu_metrics_avg_gfx_clock_frequency.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_avg_gfx_clock_frequency.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_avg_soc_clock_frequency = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_avg_soc_clock_frequency
amdsmi_get_gpu_metrics_avg_soc_clock_frequency.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_avg_soc_clock_frequency.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_avg_uclock_frequency = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_avg_uclock_frequency
amdsmi_get_gpu_metrics_avg_uclock_frequency.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_avg_uclock_frequency.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_avg_vclock0_frequency = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_avg_vclock0_frequency
amdsmi_get_gpu_metrics_avg_vclock0_frequency.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_avg_vclock0_frequency.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_avg_dclock0_frequency = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_avg_dclock0_frequency
amdsmi_get_gpu_metrics_avg_dclock0_frequency.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_avg_dclock0_frequency.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_avg_vclock1_frequency = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_avg_vclock1_frequency
amdsmi_get_gpu_metrics_avg_vclock1_frequency.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_avg_vclock1_frequency.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_avg_dclock1_frequency = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_avg_dclock1_frequency
amdsmi_get_gpu_metrics_avg_dclock1_frequency.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_avg_dclock1_frequency.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_volt_soc = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_volt_soc
amdsmi_get_gpu_metrics_volt_soc.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_volt_soc.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_volt_gfx = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_volt_gfx
amdsmi_get_gpu_metrics_volt_gfx.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_volt_gfx.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_volt_mem = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_volt_mem
amdsmi_get_gpu_metrics_volt_mem.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_volt_mem.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_header_info = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_header_info
amdsmi_get_gpu_metrics_header_info.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_header_info.argtypes = [amdsmi_processor_handle, ctypes.POINTER(struct_amd_metrics_table_header_t)]
amdsmi_get_gpu_metrics_xcd_counter = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_xcd_counter
amdsmi_get_gpu_metrics_xcd_counter.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_xcd_counter.argtypes = [amdsmi_processor_handle, ctypes.POINTER(ctypes.c_uint16)]
amdsmi_get_gpu_metrics_log = _libraries['libamd_smi.so'].amdsmi_get_gpu_metrics_log
amdsmi_get_gpu_metrics_log.restype = amdsmi_status_t
amdsmi_get_gpu_metrics_log.argtypes = [amdsmi_processor_handle]
amdsmi_get_cpu_core_energy = _libraries['libamd_smi.so'].amdsmi_get_cpu_core_energy
amdsmi_get_cpu_core_energy.restype = amdsmi_status_t
amdsmi_get_cpu_core_energy.argtypes = [amdsmi_processor_handle, uint32_t, ctypes.POINTER(ctypes.c_uint64)]
@@ -2154,12 +2381,14 @@ __all__ = \
'AMDSMI_RAS_ERR_STATE_INVALID', 'AMDSMI_RAS_ERR_STATE_LAST',
'AMDSMI_RAS_ERR_STATE_MULT_UC', 'AMDSMI_RAS_ERR_STATE_NONE',
'AMDSMI_RAS_ERR_STATE_PARITY', 'AMDSMI_RAS_ERR_STATE_POISON',
'AMDSMI_RAS_ERR_STATE_SING_C', 'AMDSMI_SLOT_TYPE__CEM',
'AMDSMI_RAS_ERR_STATE_SING_C', 'AMDSMI_REG_PCIE',
'AMDSMI_REG_USR', 'AMDSMI_REG_USR1', 'AMDSMI_REG_WAFL',
'AMDSMI_REG_XGMI', 'AMDSMI_SLOT_TYPE__CEM',
'AMDSMI_SLOT_TYPE__OAM', 'AMDSMI_SLOT_TYPE__PCIE',
'AMDSMI_SLOT_TYPE__RESERVED', 'AMDSMI_STATUS_ADDRESS_FAULT',
'AMDSMI_STATUS_API_FAILED', 'AMDSMI_STATUS_BUSY',
'AMDSMI_STATUS_DRIVER_NOT_LOADED', 'AMDSMI_STATUS_DRM_ERROR',
'AMDSMI_STATUS_FAIL_LOAD_MODULE',
'AMDSMI_STATUS_AMDGPU_RESTART_ERR', 'AMDSMI_STATUS_API_FAILED',
'AMDSMI_STATUS_BUSY', 'AMDSMI_STATUS_DRIVER_NOT_LOADED',
'AMDSMI_STATUS_DRM_ERROR', 'AMDSMI_STATUS_FAIL_LOAD_MODULE',
'AMDSMI_STATUS_FAIL_LOAD_SYMBOL', 'AMDSMI_STATUS_FILE_ERROR',
'AMDSMI_STATUS_INIT_ERROR', 'AMDSMI_STATUS_INPUT_OUT_OF_BOUNDS',
'AMDSMI_STATUS_INSUFFICIENT_SIZE',
@@ -2172,15 +2401,16 @@ __all__ = \
'AMDSMI_STATUS_NO_PERM', 'AMDSMI_STATUS_NO_SLOT',
'AMDSMI_STATUS_OUT_OF_RESOURCES',
'AMDSMI_STATUS_REFCOUNT_OVERFLOW', 'AMDSMI_STATUS_RETRY',
'AMDSMI_STATUS_SUCCESS', 'AMDSMI_STATUS_TIMEOUT',
'AMDSMI_STATUS_UNEXPECTED_DATA', 'AMDSMI_STATUS_UNEXPECTED_SIZE',
'AMDSMI_STATUS_UNKNOWN_ERROR', 'AMDSMI_TEMP_CRITICAL',
'AMDSMI_TEMP_CRITICAL_HYST', 'AMDSMI_TEMP_CRIT_MIN',
'AMDSMI_TEMP_CRIT_MIN_HYST', 'AMDSMI_TEMP_CURRENT',
'AMDSMI_TEMP_EMERGENCY', 'AMDSMI_TEMP_EMERGENCY_HYST',
'AMDSMI_TEMP_FIRST', 'AMDSMI_TEMP_HIGHEST', 'AMDSMI_TEMP_LAST',
'AMDSMI_TEMP_LOWEST', 'AMDSMI_TEMP_MAX', 'AMDSMI_TEMP_MAX_HYST',
'AMDSMI_TEMP_MIN', 'AMDSMI_TEMP_MIN_HYST', 'AMDSMI_TEMP_OFFSET',
'AMDSMI_STATUS_SETTING_UNAVAILABLE', 'AMDSMI_STATUS_SUCCESS',
'AMDSMI_STATUS_TIMEOUT', 'AMDSMI_STATUS_UNEXPECTED_DATA',
'AMDSMI_STATUS_UNEXPECTED_SIZE', 'AMDSMI_STATUS_UNKNOWN_ERROR',
'AMDSMI_TEMP_CRITICAL', 'AMDSMI_TEMP_CRITICAL_HYST',
'AMDSMI_TEMP_CRIT_MIN', 'AMDSMI_TEMP_CRIT_MIN_HYST',
'AMDSMI_TEMP_CURRENT', 'AMDSMI_TEMP_EMERGENCY',
'AMDSMI_TEMP_EMERGENCY_HYST', 'AMDSMI_TEMP_FIRST',
'AMDSMI_TEMP_HIGHEST', 'AMDSMI_TEMP_LAST', 'AMDSMI_TEMP_LOWEST',
'AMDSMI_TEMP_MAX', 'AMDSMI_TEMP_MAX_HYST', 'AMDSMI_TEMP_MIN',
'AMDSMI_TEMP_MIN_HYST', 'AMDSMI_TEMP_OFFSET',
'AMDSMI_UTILIZATION_COUNTER_FIRST',
'AMDSMI_UTILIZATION_COUNTER_LAST', 'AMDSMI_VOLT_AVERAGE',
'AMDSMI_VOLT_CURRENT', 'AMDSMI_VOLT_FIRST', 'AMDSMI_VOLT_HIGHEST',
@@ -2218,12 +2448,12 @@ __all__ = \
'FW_ID_DRV_CAP', 'FW_ID_FIRST', 'FW_ID_IMU_DRAM',
'FW_ID_IMU_IRAM', 'FW_ID_ISP', 'FW_ID_MC', 'FW_ID_MES_KIQ',
'FW_ID_MES_STACK', 'FW_ID_MES_THREAD1', 'FW_ID_MES_THREAD1_STACK',
'FW_ID_MMSCH', 'FW_ID_PPTABLE', 'FW_ID_PSP_BL', 'FW_ID_PSP_DBG',
'FW_ID_PSP_INTF', 'FW_ID_PSP_KEYDB', 'FW_ID_PSP_SOC',
'FW_ID_PSP_SOSDRV', 'FW_ID_PSP_SPL', 'FW_ID_PSP_SYSDRV',
'FW_ID_PSP_TOC', 'FW_ID_REG_ACCESS_WHITELIST', 'FW_ID_RLC',
'FW_ID_RLCV_LX7', 'FW_ID_RLC_P', 'FW_ID_RLC_RESTORE_LIST_CNTL',
'FW_ID_RLC_RESTORE_LIST_GPM_MEM',
'FW_ID_MMSCH', 'FW_ID_PM', 'FW_ID_PPTABLE', 'FW_ID_PSP_BL',
'FW_ID_PSP_DBG', 'FW_ID_PSP_INTF', 'FW_ID_PSP_KEYDB',
'FW_ID_PSP_SOC', 'FW_ID_PSP_SOSDRV', 'FW_ID_PSP_SPL',
'FW_ID_PSP_SYSDRV', 'FW_ID_PSP_TOC', 'FW_ID_REG_ACCESS_WHITELIST',
'FW_ID_RLC', 'FW_ID_RLCV_LX7', 'FW_ID_RLC_P',
'FW_ID_RLC_RESTORE_LIST_CNTL', 'FW_ID_RLC_RESTORE_LIST_GPM_MEM',
'FW_ID_RLC_RESTORE_LIST_SRM_MEM', 'FW_ID_RLC_SAVE_RESTORE_LIST',
'FW_ID_RLC_SRLG', 'FW_ID_RLC_SRLS', 'FW_ID_RLC_V', 'FW_ID_RLX6',
'FW_ID_RLX6_CORE1', 'FW_ID_RLX6_DRAM_BOOT',
@@ -2235,39 +2465,34 @@ __all__ = \
'FW_ID_RS64_PFP_P1_DATA', 'FW_ID_SDMA0', 'FW_ID_SDMA1',
'FW_ID_SDMA2', 'FW_ID_SDMA3', 'FW_ID_SDMA4', 'FW_ID_SDMA5',
'FW_ID_SDMA6', 'FW_ID_SDMA7', 'FW_ID_SDMA_TH0', 'FW_ID_SDMA_TH1',
'FW_ID_SEC_POLICY_STAGE2', 'FW_ID_PM', 'FW_ID_SMU',
'FW_ID_TA_RAS', 'FW_ID_TA_XGMI', 'FW_ID_UVD', 'FW_ID_VCE',
'FW_ID_VCN', 'FW_ID__MAX', 'MEMORY_PARTITION_NPS1',
'MEMORY_PARTITION_NPS2', 'MEMORY_PARTITION_NPS4',
'MEMORY_PARTITION_NPS8', 'MEMORY_PARTITION_UNKNOWN',
'NON_AMD_CPU', 'NON_AMD_GPU', 'RD_BW0', 'TEMPERATURE_TYPE_EDGE',
'TEMPERATURE_TYPE_FIRST', 'TEMPERATURE_TYPE_HBM_0',
'TEMPERATURE_TYPE_HBM_1', 'TEMPERATURE_TYPE_HBM_2',
'TEMPERATURE_TYPE_HBM_3', 'TEMPERATURE_TYPE_HOTSPOT',
'TEMPERATURE_TYPE_JUNCTION', 'TEMPERATURE_TYPE_PLX',
'TEMPERATURE_TYPE_VRAM', 'TEMPERATURE_TYPE__MAX', 'UNKNOWN',
'VRAM_TYPE_DDR2', 'VRAM_TYPE_DDR3', 'VRAM_TYPE_DDR4',
'VRAM_TYPE_GDDR1', 'VRAM_TYPE_GDDR3', 'VRAM_TYPE_GDDR4',
'VRAM_TYPE_GDDR5', 'VRAM_TYPE_GDDR6', 'VRAM_TYPE_HBM',
'VRAM_TYPE_UNKNOWN', 'VRAM_TYPE__MAX', 'WR_BW0',
'amd_metrics_table_header_t', 'amdsmi_asic_info_t',
'amdsmi_bdf_t', 'amdsmi_bit_field_t', 'amdsmi_board_info_t',
'amdsmi_cache_flags_type_t', 'amdsmi_clk_info_t',
'amdsmi_clk_type_t', 'amdsmi_compute_partition_type_t',
'amdsmi_container_types_t', 'amdsmi_counter_command_t',
'amdsmi_counter_value_t', 'amdsmi_cpu_apb_disable',
'amdsmi_cpu_apb_enable', 'amdsmi_cpusocket_handle',
'amdsmi_ddr_bw_metrics_t', 'amdsmi_dev_compute_partition_get',
'amdsmi_dev_compute_partition_reset',
'amdsmi_dev_compute_partition_set',
'amdsmi_dev_memory_partition_get',
'amdsmi_dev_memory_partition_reset',
'amdsmi_dev_memory_partition_set', 'amdsmi_dev_perf_level_t',
'amdsmi_dimm_power_t', 'amdsmi_dimm_thermal_t',
'amdsmi_dpm_level_t', 'amdsmi_driver_info_t',
'amdsmi_engine_usage_t', 'amdsmi_error_count_t',
'amdsmi_event_group_t', 'amdsmi_event_handle_t',
'amdsmi_event_type_t', 'amdsmi_evt_notification_data_t',
'FW_ID_SEC_POLICY_STAGE2', 'FW_ID_SMU', 'FW_ID_TA_RAS',
'FW_ID_TA_XGMI', 'FW_ID_UVD', 'FW_ID_VCE', 'FW_ID_VCN',
'FW_ID__MAX', 'MEMORY_PARTITION_NPS1', 'MEMORY_PARTITION_NPS2',
'MEMORY_PARTITION_NPS4', 'MEMORY_PARTITION_NPS8',
'MEMORY_PARTITION_UNKNOWN', 'NON_AMD_CPU', 'NON_AMD_GPU',
'RD_BW0', 'TEMPERATURE_TYPE_EDGE', 'TEMPERATURE_TYPE_FIRST',
'TEMPERATURE_TYPE_HBM_0', 'TEMPERATURE_TYPE_HBM_1',
'TEMPERATURE_TYPE_HBM_2', 'TEMPERATURE_TYPE_HBM_3',
'TEMPERATURE_TYPE_HOTSPOT', 'TEMPERATURE_TYPE_JUNCTION',
'TEMPERATURE_TYPE_PLX', 'TEMPERATURE_TYPE_VRAM',
'TEMPERATURE_TYPE__MAX', 'UNKNOWN', 'VRAM_TYPE_DDR2',
'VRAM_TYPE_DDR3', 'VRAM_TYPE_DDR4', 'VRAM_TYPE_GDDR1',
'VRAM_TYPE_GDDR3', 'VRAM_TYPE_GDDR4', 'VRAM_TYPE_GDDR5',
'VRAM_TYPE_GDDR6', 'VRAM_TYPE_HBM', 'VRAM_TYPE_UNKNOWN',
'VRAM_TYPE__MAX', 'WR_BW0', 'amd_metrics_table_header_t',
'amdsmi_asic_info_t', 'amdsmi_bdf_t', 'amdsmi_bit_field_t',
'amdsmi_board_info_t', 'amdsmi_cache_flags_type_t',
'amdsmi_clk_info_t', 'amdsmi_clk_type_t',
'amdsmi_compute_partition_type_t', 'amdsmi_container_types_t',
'amdsmi_counter_command_t', 'amdsmi_counter_value_t',
'amdsmi_cpu_apb_disable', 'amdsmi_cpu_apb_enable',
'amdsmi_cpusocket_handle', 'amdsmi_ddr_bw_metrics_t',
'amdsmi_dev_perf_level_t', 'amdsmi_dimm_power_t',
'amdsmi_dimm_thermal_t', 'amdsmi_dpm_level_t',
'amdsmi_driver_info_t', 'amdsmi_engine_usage_t',
'amdsmi_error_count_t', 'amdsmi_event_group_t',
'amdsmi_event_handle_t', 'amdsmi_event_type_t',
'amdsmi_evt_notification_data_t',
'amdsmi_evt_notification_type_t',
'amdsmi_first_online_core_on_cpu_socket', 'amdsmi_freq_ind_t',
'amdsmi_freq_volt_region_t', 'amdsmi_frequencies_t',
@@ -2300,6 +2525,7 @@ __all__ = \
'amdsmi_get_gpu_available_counters',
'amdsmi_get_gpu_bad_page_info', 'amdsmi_get_gpu_bdf_id',
'amdsmi_get_gpu_board_info', 'amdsmi_get_gpu_cache_info',
'amdsmi_get_gpu_compute_partition',
'amdsmi_get_gpu_compute_process_gpus',
'amdsmi_get_gpu_compute_process_info',
'amdsmi_get_gpu_compute_process_info_by_pid',
@@ -2308,18 +2534,73 @@ __all__ = \
'amdsmi_get_gpu_ecc_enabled', 'amdsmi_get_gpu_ecc_status',
'amdsmi_get_gpu_event_notification', 'amdsmi_get_gpu_fan_rpms',
'amdsmi_get_gpu_fan_speed', 'amdsmi_get_gpu_fan_speed_max',
'amdsmi_get_gpu_id', 'amdsmi_get_gpu_memory_reserved_pages',
'amdsmi_get_gpu_id', 'amdsmi_get_gpu_memory_partition',
'amdsmi_get_gpu_memory_reserved_pages',
'amdsmi_get_gpu_memory_total', 'amdsmi_get_gpu_memory_usage',
'amdsmi_get_gpu_metrics_info',
'amdsmi_get_gpu_metrics_avg_dclock0_frequency',
'amdsmi_get_gpu_metrics_avg_dclock1_frequency',
'amdsmi_get_gpu_metrics_avg_gfx_activity',
'amdsmi_get_gpu_metrics_avg_gfx_clock_frequency',
'amdsmi_get_gpu_metrics_avg_mm_activity',
'amdsmi_get_gpu_metrics_avg_soc_clock_frequency',
'amdsmi_get_gpu_metrics_avg_socket_power',
'amdsmi_get_gpu_metrics_avg_uclock_frequency',
'amdsmi_get_gpu_metrics_avg_umc_activity',
'amdsmi_get_gpu_metrics_avg_vclock0_frequency',
'amdsmi_get_gpu_metrics_avg_vclock1_frequency',
'amdsmi_get_gpu_metrics_curr_dclk0',
'amdsmi_get_gpu_metrics_curr_dclk1',
'amdsmi_get_gpu_metrics_curr_fan_speed',
'amdsmi_get_gpu_metrics_curr_gfxclk',
'amdsmi_get_gpu_metrics_curr_socclk',
'amdsmi_get_gpu_metrics_curr_socket_power',
'amdsmi_get_gpu_metrics_curr_uclk',
'amdsmi_get_gpu_metrics_curr_vclk0',
'amdsmi_get_gpu_metrics_curr_vclk1',
'amdsmi_get_gpu_metrics_energy_acc',
'amdsmi_get_gpu_metrics_firmware_timestamp',
'amdsmi_get_gpu_metrics_gfx_activity_acc',
'amdsmi_get_gpu_metrics_gfxclk_lock_status',
'amdsmi_get_gpu_metrics_header_info',
'amdsmi_get_gpu_metrics_indep_throttle_status',
'amdsmi_get_gpu_metrics_info', 'amdsmi_get_gpu_metrics_log',
'amdsmi_get_gpu_metrics_mem_activity_acc',
'amdsmi_get_gpu_metrics_pcie_bandwidth_acc',
'amdsmi_get_gpu_metrics_pcie_bandwidth_inst',
'amdsmi_get_gpu_metrics_pcie_l0_recov_count_acc',
'amdsmi_get_gpu_metrics_pcie_link_speed',
'amdsmi_get_gpu_metrics_pcie_link_width',
'amdsmi_get_gpu_metrics_pcie_replay_count_acc',
'amdsmi_get_gpu_metrics_pcie_replay_rover_count_acc',
'amdsmi_get_gpu_metrics_system_clock_counter',
'amdsmi_get_gpu_metrics_temp_edge',
'amdsmi_get_gpu_metrics_temp_hbm',
'amdsmi_get_gpu_metrics_temp_hotspot',
'amdsmi_get_gpu_metrics_temp_mem',
'amdsmi_get_gpu_metrics_temp_vrgfx',
'amdsmi_get_gpu_metrics_temp_vrmem',
'amdsmi_get_gpu_metrics_temp_vrsoc',
'amdsmi_get_gpu_metrics_throttle_status',
'amdsmi_get_gpu_metrics_vcn_activity',
'amdsmi_get_gpu_metrics_volt_gfx',
'amdsmi_get_gpu_metrics_volt_mem',
'amdsmi_get_gpu_metrics_volt_soc',
'amdsmi_get_gpu_metrics_xcd_counter',
'amdsmi_get_gpu_metrics_xgmi_link_speed',
'amdsmi_get_gpu_metrics_xgmi_link_width',
'amdsmi_get_gpu_metrics_xgmi_read_data',
'amdsmi_get_gpu_metrics_xgmi_write_data',
'amdsmi_get_gpu_od_volt_curve_regions',
'amdsmi_get_gpu_od_volt_info', 'amdsmi_get_gpu_overdrive_level',
'amdsmi_get_gpu_pci_bandwidth',
'amdsmi_get_gpu_pci_replay_counter',
'amdsmi_get_gpu_pci_throughput', 'amdsmi_get_gpu_perf_level',
'amdsmi_get_gpu_pm_metrics_info',
'amdsmi_get_gpu_power_profile_presets',
'amdsmi_get_gpu_process_info', 'amdsmi_get_gpu_process_list',
'amdsmi_get_gpu_ras_block_features_enabled',
'amdsmi_get_gpu_ras_feature_info', 'amdsmi_get_gpu_revision',
'amdsmi_get_gpu_ras_feature_info',
'amdsmi_get_gpu_reg_table_info', 'amdsmi_get_gpu_revision',
'amdsmi_get_gpu_subsystem_id', 'amdsmi_get_gpu_subsystem_name',
'amdsmi_get_gpu_topo_numa_affinity',
'amdsmi_get_gpu_total_ecc_count', 'amdsmi_get_gpu_vbios_info',
@@ -2345,7 +2626,7 @@ __all__ = \
'amdsmi_is_gpu_power_management_enabled',
'amdsmi_link_id_bw_type_t', 'amdsmi_memory_page_status_t',
'amdsmi_memory_partition_type_t', 'amdsmi_memory_type_t',
'amdsmi_mm_ip_t', 'amdsmi_od_vddc_point_t',
'amdsmi_mm_ip_t', 'amdsmi_name_value_t', 'amdsmi_od_vddc_point_t',
'amdsmi_od_volt_curve_t', 'amdsmi_od_volt_freq_data_t',
'amdsmi_pcie_bandwidth_t', 'amdsmi_pcie_info_t',
'amdsmi_pcie_slot_type_t', 'amdsmi_power_cap_info_t',
@@ -2354,10 +2635,11 @@ __all__ = \
'amdsmi_proc_info_t', 'amdsmi_process_handle_t',
'amdsmi_process_info_t', 'amdsmi_processor_handle',
'amdsmi_range_t', 'amdsmi_ras_err_state_t',
'amdsmi_ras_feature_t', 'amdsmi_reset_gpu',
'amdsmi_reset_gpu_fan', 'amdsmi_reset_gpu_xgmi_error',
'amdsmi_retired_page_record_t', 'amdsmi_set_clk_freq',
'amdsmi_set_cpu_core_boostlimit',
'amdsmi_ras_feature_t', 'amdsmi_reg_type_t', 'amdsmi_reset_gpu',
'amdsmi_reset_gpu_compute_partition', 'amdsmi_reset_gpu_fan',
'amdsmi_reset_gpu_memory_partition',
'amdsmi_reset_gpu_xgmi_error', 'amdsmi_retired_page_record_t',
'amdsmi_set_clk_freq', 'amdsmi_set_cpu_core_boostlimit',
'amdsmi_set_cpu_df_pstate_range',
'amdsmi_set_cpu_gmi3_link_width_range',
'amdsmi_set_cpu_pcie_link_rate',
@@ -2365,11 +2647,11 @@ __all__ = \
'amdsmi_set_cpu_socket_boostlimit',
'amdsmi_set_cpu_socket_lclk_dpm_level',
'amdsmi_set_cpu_socket_power_cap', 'amdsmi_set_cpu_xgmi_width',
'amdsmi_set_gpu_clk_range',
'amdsmi_set_gpu_clk_range', 'amdsmi_set_gpu_compute_partition',
'amdsmi_set_gpu_event_notification_mask',
'amdsmi_set_gpu_fan_speed', 'amdsmi_set_gpu_od_clk_info',
'amdsmi_set_gpu_od_volt_info', 'amdsmi_set_gpu_overdrive_level',
'amdsmi_set_gpu_pci_bandwidth',
'amdsmi_set_gpu_fan_speed', 'amdsmi_set_gpu_memory_partition',
'amdsmi_set_gpu_od_clk_info', 'amdsmi_set_gpu_od_volt_info',
'amdsmi_set_gpu_overdrive_level', 'amdsmi_set_gpu_pci_bandwidth',
'amdsmi_set_gpu_perf_determinism_mode',
'amdsmi_set_gpu_perf_level', 'amdsmi_set_gpu_power_profile',
'amdsmi_set_power_cap', 'amdsmi_shut_down',
@@ -2385,7 +2667,11 @@ __all__ = \
'amdsmi_voltage_type_t', 'amdsmi_vram_info_t',
'amdsmi_vram_type_t', 'amdsmi_vram_usage_t',
'amdsmi_vram_vendor_type_t', 'amdsmi_xgmi_info_t',
'amdsmi_xgmi_status_t', 'processor_type_t', 'size_t',
'amdsmi_xgmi_status_t', 'gpu_metric_curr_dclk0_t',
'gpu_metric_curr_gfxclk_t', 'gpu_metric_curr_socclk_t',
'gpu_metric_curr_vclk0_t', 'gpu_metric_temp_hbm_t',
'gpu_metric_vcn_activity_t', 'gpu_metric_xgmi_read_data_acc_t',
'gpu_metric_xgmi_write_data_acc_t', 'processor_type_t', 'size_t',
'struct_amd_metrics_table_header_t', 'struct_amdsmi_asic_info_t',
'struct_amdsmi_board_info_t', 'struct_amdsmi_clk_info_t',
'struct_amdsmi_counter_value_t', 'struct_amdsmi_ddr_bw_metrics_t',
@@ -2396,7 +2682,7 @@ __all__ = \
'struct_amdsmi_freq_volt_region_t', 'struct_amdsmi_frequencies_t',
'struct_amdsmi_frequency_range_t', 'struct_amdsmi_fw_info_t',
'struct_amdsmi_gpu_cache_info_t', 'struct_amdsmi_gpu_metrics_t',
'struct_amdsmi_link_id_bw_type_t',
'struct_amdsmi_link_id_bw_type_t', 'struct_amdsmi_name_value_t',
'struct_amdsmi_od_vddc_point_t', 'struct_amdsmi_od_volt_curve_t',
'struct_amdsmi_od_volt_freq_data_t',
'struct_amdsmi_pcie_bandwidth_t', 'struct_amdsmi_pcie_info_t',
projects/amdsmi/rocm_smi/example/rocm_smi_example.cc
+342 -41
Zobrazit soubor
@@ -47,10 +47,12 @@
#include <stdint.h>
#include <unistd.h>
#include <vector>
#include <iostream>
#include <algorithm>
#include <bitset>
#include <iostream>
#include <map>
#include <vector>
#include <type_traits>
#include "rocm_smi/rocm_smi.h"
#include "rocm_smi/rocm_smi_utils.h"
@@ -166,9 +168,9 @@ void print_function_header_with_rsmi_ret(
}
static void print_test_header(const char *str, uint32_t dv_ind) {
std::cout << "********************************" << "\n";
std::cout << "******************************************" << "\n";
std::cout << "*** " << str << "\n";
std::cout << "********************************" << "\n";
std::cout << "******************************************" << "\n";
std::cout << "Device index: " << dv_ind << "\n";
}
@@ -728,6 +730,40 @@ template<typename T> constexpr float convert_mw_to_w(T mw) {
return static_cast<float>(mw / 1000.0);
}
template <typename T>
auto print_error_or_value(rsmi_status_t status_code, const T& metric) {
if (status_code == rsmi_status_t::RSMI_STATUS_SUCCESS) {
if constexpr (std::is_array_v<T>) {
auto idx = uint16_t(0);
auto str_values = std::string();
const auto num_elems = static_cast<uint16_t>(std::end(metric) - std::begin(metric));
str_values = ("\n\t\t num of values: " + std::to_string(num_elems) + "\n");
for (const auto& el : metric) {
str_values += "\t\t [" + std::to_string(idx) + "]: " + std::to_string(el) + "\n";
++idx;
}
return str_values;
}
else if constexpr ((std::is_same_v<T, std::uint16_t>) ||
(std::is_same_v<T, std::uint32_t>) ||
(std::is_same_v<T, std::uint64_t>)) {
return std::to_string(metric);
}
}
else {
return ("\n\t\tStatus: [" + std::to_string(status_code) + "] " + "-> " + amd::smi::getRSMIStatusString(status_code));
}
};
template <typename T>
std::string print_unsigned_int(T value) {
std::stringstream ss;
ss << static_cast<uint64_t>(value | 0);
return ss.str();
}
int main() {
rsmi_status_t ret;
@@ -742,7 +778,7 @@ int main() {
rsmi_dev_perf_level_t pfl;
rsmi_frequencies_t f;
uint32_t num_monitor_devs = 0;
rsmi_gpu_metrics_t p;
rsmi_gpu_metrics_t gpu_metrics;
std::string val_str;
RSMI_POWER_TYPE power_type = RSMI_INVALID_POWER;
@@ -809,43 +845,308 @@ int main() {
std::cout << "Not Supported\n";
}
ret = rsmi_dev_gpu_metrics_info_get(i, &p);
print_test_header("GPU METRICS", i);
print_function_header_with_rsmi_ret(ret,
"rsmi_dev_gpu_metrics_info_get(" + std::to_string(i) + ", &p)");
std::cout << "\t**p.common_header.content_revision: " << std::dec
<< p.common_header.content_revision << "\n";
std::cout << "\t**p.common_header.format_revision: " << std::dec
<< p.common_header.format_revision << "\n";
std::cout << "\t**p.average_gfxclk_frequency: " << std::dec
<< p.average_gfxclk_frequency << "\n";
std::cout << "\t**p.average_socclk_frequency: " << std::dec
<< p.average_socclk_frequency << "\n";
std::cout << "\t**p.average_uclk_frequency: " << std::dec
<< p.average_uclk_frequency << "\n";
std::cout << "\t**p.average_vclk0_frequency: " << std::dec
<< p.average_vclk0_frequency << "\n";
std::cout << "\t**p.average_dclk0_frequency: " << std::dec
<< p.average_dclk0_frequency << "\n";
std::cout << "\t**p.average_vclk1_frequency: " << std::dec
<< p.average_vclk1_frequency << "\n";
std::cout << "\t**p.average_dclk1_frequency: " << std::dec
<< p.average_dclk1_frequency << "\n";
//
std::cout << "\n";
print_test_header("GPU METRICS: Using static struct (Backwards Compatibility) ", i);
print_function_header_with_rsmi_ret(ret, "rsmi_dev_gpu_metrics_info_get(" + std::to_string(i) + ", &gpu_metrics)");
rsmi_dev_gpu_metrics_info_get(i, &gpu_metrics);
std::cout << "\t**.common_header.format_revision : "
<< print_unsigned_int(gpu_metrics.common_header.format_revision) << "\n";
std::cout << "\t**.common_header.content_revision : "
<< print_unsigned_int(gpu_metrics.common_header.content_revision) << "\n";
std::cout << "\t**.temperature_edge : " << std::dec
<< gpu_metrics.temperature_edge << "\n";
std::cout << "\t**.temperature_hotspot : " << std::dec
<< gpu_metrics.temperature_hotspot << "\n";
std::cout << "\t**.temperature_mem : " << std::dec
<< gpu_metrics.temperature_mem << "\n";
std::cout << "\t**.temperature_vrgfx : " << std::dec
<< gpu_metrics.temperature_vrgfx << "\n";
std::cout << "\t**.temperature_vrsoc : " << std::dec
<< gpu_metrics.temperature_vrsoc << "\n";
std::cout << "\t**.temperature_vrmem : " << std::dec
<< gpu_metrics.temperature_vrmem << "\n";
std::cout << "\t**.average_gfx_activity : " << std::dec
<< gpu_metrics.average_gfx_activity << "\n";
std::cout << "\t**.average_umc_activity : " << std::dec
<< gpu_metrics.average_umc_activity << "\n";
std::cout << "\t**.average_mm_activity : " << std::dec
<< gpu_metrics.average_mm_activity << "\n";
std::cout << "\t**.average_socket_power : " << std::dec
<< gpu_metrics.average_socket_power << "\n";
std::cout << "\t**.energy_accumulator : " << std::dec
<< gpu_metrics.energy_accumulator << "\n";
std::cout << "\t**.system_clock_counter : " << std::dec
<< gpu_metrics.system_clock_counter << "\n";
std::cout << "\t**.average_gfxclk_frequency : " << std::dec
<< gpu_metrics.average_gfxclk_frequency << "\n";
std::cout << "\t**.average_socclk_frequency : " << std::dec
<< gpu_metrics.average_socclk_frequency << "\n";
std::cout << "\t**.average_uclk_frequency : " << std::dec
<< gpu_metrics.average_uclk_frequency << "\n";
std::cout << "\t**.average_vclk0_frequency : " << std::dec
<< gpu_metrics.average_vclk0_frequency<< "\n";
std::cout << "\t**.average_dclk0_frequency : " << std::dec
<< gpu_metrics.average_dclk0_frequency << "\n";
std::cout << "\t**.average_vclk1_frequency : " << std::dec
<< gpu_metrics.average_vclk1_frequency << "\n";
std::cout << "\t**.average_dclk1_frequency : " << std::dec
<< gpu_metrics.average_dclk1_frequency << "\n";
std::cout << "\t**.current_gfxclk : " << std::dec
<< gpu_metrics.current_gfxclk << "\n";
std::cout << "\t**.current_socclk : " << std::dec
<< gpu_metrics.current_socclk << "\n";
std::cout << "\t**.current_uclk : " << std::dec
<< gpu_metrics.current_uclk << "\n";
std::cout << "\t**.current_vclk0 : " << std::dec
<< gpu_metrics.current_vclk0 << "\n";
std::cout << "\t**.current_dclk0 : " << std::dec
<< gpu_metrics.current_dclk0 << "\n";
std::cout << "\t**.current_vclk1 : " << std::dec
<< gpu_metrics.current_vclk1 << "\n";
std::cout << "\t**.current_dclk1 : " << std::dec
<< gpu_metrics.current_dclk1 << "\n";
std::cout << "\t**.throttle_status : " << std::dec
<< gpu_metrics.throttle_status << "\n";
std::cout << "\t**.current_fan_speed : " << std::dec
<< gpu_metrics.current_fan_speed << "\n";
std::cout << "\t**.pcie_link_width : " << std::dec
<< gpu_metrics.pcie_link_width << "\n";
std::cout << "\t**.pcie_link_speed : " << std::dec
<< gpu_metrics.pcie_link_speed << "\n";
std::cout << "\t**.gfx_activity_acc : " << std::dec
<< gpu_metrics.gfx_activity_acc << "\n";
std::cout << "\t**.mem_activity_acc : " << std::dec
<< gpu_metrics.mem_activity_acc << "\n";
std::cout << "\t**.firmware_timestamp : " << std::dec
<< gpu_metrics.firmware_timestamp << "\n";
std::cout << "\t**.voltage_soc : " << std::dec
<< gpu_metrics.voltage_soc << "\n";
std::cout << "\t**.voltage_gfx : " << std::dec
<< gpu_metrics.voltage_gfx << "\n";
std::cout << "\t**.voltage_mem : " << std::dec
<< gpu_metrics.voltage_mem << "\n";
std::cout << "\t**.indep_throttle_status : " << std::dec
<< gpu_metrics.indep_throttle_status << "\n";
std::cout << "\t**.current_socket_power : " << std::dec
<< gpu_metrics.current_socket_power << "\n";
std::cout << "\t**.gfxclk_lock_status : " << std::dec
<< gpu_metrics.gfxclk_lock_status << "\n";
std::cout << "\t**.xgmi_link_width : " << std::dec
<< gpu_metrics.xgmi_link_width << "\n";
std::cout << "\t**.xgmi_link_speed : " << std::dec
<< gpu_metrics.xgmi_link_speed << "\n";
std::cout << "\t**.pcie_bandwidth_acc : " << std::dec
<< gpu_metrics.pcie_bandwidth_acc << "\n";
std::cout << "\t**.pcie_bandwidth_inst : " << std::dec
<< gpu_metrics.pcie_bandwidth_inst << "\n";
std::cout << "\t**.pcie_l0_to_recov_count_acc : " << std::dec
<< gpu_metrics.pcie_l0_to_recov_count_acc << "\n";
std::cout << "\t**.pcie_replay_count_acc : " << std::dec
<< gpu_metrics.pcie_replay_count_acc << "\n";
std::cout << "\t**.pcie_replay_rover_count_acc : " << std::dec
<< gpu_metrics.pcie_replay_rover_count_acc << "\n";
std::cout << "\t**.temperature_hbm[] : " << std::dec << "\n";
for (const auto& temp : gpu_metrics.temperature_hbm) {
std::cout << "\t -> " << std::dec << temp << "\n";
}
std::cout << "\t**.vcn_activity[] : " << std::dec << "\n";
for (const auto& vcn : gpu_metrics.vcn_activity) {
std::cout << "\t -> " << std::dec << vcn << "\n";
}
std::cout << "\t**.xgmi_read_data_acc[] : " << std::dec << "\n";
for (const auto& read_data : gpu_metrics.xgmi_read_data_acc) {
std::cout << "\t -> " << std::dec << read_data << "\n";
}
std::cout << "\t**.xgmi_write_data_acc[] : " << std::dec << "\n";
for (const auto& write_data : gpu_metrics.xgmi_write_data_acc) {
std::cout << "\t -> " << std::dec << write_data << "\n";
}
std::cout << "\t**.current_gfxclks[] : " << std::dec << "\n";
for (const auto& gfxclk : gpu_metrics.current_gfxclks) {
std::cout << "\t -> " << std::dec << gfxclk << "\n";
}
std::cout << "\t**.current_socclks[] : " << std::dec << "\n";
for (const auto& socclk : gpu_metrics.current_socclks) {
std::cout << "\t -> " << std::dec << socclk << "\n";
}
std::cout << "\t**.current_vclk0s[] : " << std::dec << "\n";
for (const auto& vclk : gpu_metrics.current_vclk0s) {
std::cout << "\t -> " << std::dec << vclk << "\n";
}
std::cout << "\t**.current_dclk0s[] : " << std::dec << "\n";
for (const auto& dclk : gpu_metrics.current_dclk0s) {
std::cout << "\t -> " << std::dec << dclk << "\n";
}
std::cout << " ** Note: Values MAX'ed out (UINTX MAX are unsupported for the version in question) ** " << "\n";
std::cout << "\n\n";
print_test_header("GPU METRICS: Using direct APIs (newer)", i);
metrics_table_header_t header_values;
GPUMetricTempHbm_t hbm_values;
GPUMetricVcnActivity_t vcn_values;
GPUMetricXgmiReadDataAcc_t xgmi_read_values;
GPUMetricXgmiWriteDataAcc_t xgmi_write_values;
GPUMetricCurrGfxClk_t curr_gfxclk_values;
GPUMetricCurrSocClk_t curr_socclk_values;
GPUMetricCurrVClk0_t curr_vclk0_values;
GPUMetricCurrDClk0_t curr_dclk0_values;
ret = rsmi_dev_metrics_header_info_get(i, &header_values);
std::cout << "\t[Metrics Header]" << "\n";
std::cout << "\t -> format_revision : " << print_unsigned_int(header_values.format_revision) << "\n";
std::cout << "\t -> content_revision : " << print_unsigned_int(header_values.content_revision) << "\n";
std::cout << "\t--------------------" << "\n";
std::cout << "\n";
std::cout << "\t[Temperature]" << "\n";
ret = rsmi_dev_metrics_temp_edge_get(i, &val_ui16);
std::cout << "\t -> temp_edge(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_temp_hotspot_get(i, &val_ui16);
std::cout << "\t -> temp_hotspot(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_temp_mem_get(i, &val_ui16);
std::cout << "\t -> temp_mem(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_temp_vrgfx_get(i, &val_ui16);
std::cout << "\t -> temp_vrgfx(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_temp_vrsoc_get(i, &val_ui16);
std::cout << "\t -> temp_vrsoc(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_temp_vrmem_get(i, &val_ui16);
std::cout << "\t -> temp_vrmem(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_temp_hbm_get(i, &hbm_values);
std::cout << "\t -> temp_hbm(): " << print_error_or_value(ret, hbm_values) << "\n";
std::cout << "\n";
std::cout << "\t[Power/Energy]" << "\n";
ret = rsmi_dev_metrics_curr_socket_power_get(i, &val_ui16);
std::cout << "\t -> current_socket_power(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_energy_acc_get(i, &val_ui64);
std::cout << "\t -> energy_accum(): " << print_error_or_value(ret, val_ui64) << "\n";
ret = rsmi_dev_metrics_avg_socket_power_get(i, &val_ui16);
std::cout << "\t -> average_socket_power(): " << print_error_or_value(ret, val_ui16) << "\n";
std::cout << "\n";
std::cout << "\t[Utilization]" << "\n";
ret = rsmi_dev_metrics_avg_gfx_activity_get(i, &val_ui16);
std::cout << "\t -> average_gfx_activity(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_avg_umc_activity_get(i, &val_ui16);
std::cout << "\t -> average_umc_activity(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_avg_mm_activity_get(i, &val_ui16);
std::cout << "\t -> average_mm_activity(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_vcn_activity_get(i, &vcn_values);
std::cout << "\t -> vcn_activity(): " << print_error_or_value(ret, vcn_values) << "\n";
ret = rsmi_dev_metrics_mem_activity_acc_get(i, &val_ui32);
std::cout << "\t -> mem_activity_accum(): " << print_error_or_value(ret, val_ui32) << "\n";
ret = rsmi_dev_metrics_gfx_activity_acc_get(i, &val_ui32);
std::cout << "\t -> gfx_activity_accum(): " << print_error_or_value(ret, val_ui32) << "\n";
std::cout << "\n";
std::cout << "\t[Average Clock]" << "\n";
ret = rsmi_dev_metrics_avg_gfx_clock_frequency_get(i, &val_ui16);
std::cout << "\t -> average_gfx_clock_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_avg_soc_clock_frequency_get(i, &val_ui16);
std::cout << "\t -> average_soc_clock_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_avg_uclock_frequency_get(i, &val_ui16);
std::cout << "\t -> average_uclock_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_avg_vclock0_frequency_get(i, &val_ui16);
std::cout << "\t -> average_vclock0_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_avg_dclock0_frequency_get(i, &val_ui16);
std::cout << "\t -> average_dclock0_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_avg_vclock1_frequency_get(i, &val_ui16);
std::cout << "\t -> average_vclock1_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_avg_dclock1_frequency_get(i, &val_ui16);
std::cout << "\t -> average_dclock1_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
std::cout << "\n";
std::cout << "\t[Current Clock]" << "\n";
ret = rsmi_dev_metrics_curr_vclk1_get(i, &val_ui16);
std::cout << "\t -> current_vclock1(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_curr_dclk1_get(i, &val_ui16);
std::cout << "\t -> current_dclock1(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_curr_uclk_get(i, &val_ui16);
std::cout << "\t -> current_uclock(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_curr_dclk0_get(i, &curr_dclk0_values);
std::cout << "\t -> current_dclk0(): " << print_error_or_value(ret, curr_dclk0_values) << "\n";
ret = rsmi_dev_metrics_curr_gfxclk_get(i, &curr_gfxclk_values);
std::cout << "\t -> current_gfxclk(): " << print_error_or_value(ret, curr_gfxclk_values) << "\n";
ret = rsmi_dev_metrics_curr_socclk_get(i, &curr_socclk_values);
std::cout << "\t -> current_soc_clock(): " << print_error_or_value(ret, curr_socclk_values) << "\n";
ret = rsmi_dev_metrics_curr_vclk0_get(i, &curr_vclk0_values);
std::cout << "\t -> current_vclk0(): " << print_error_or_value(ret, curr_vclk0_values) << "\n";
std::cout << "\n";
std::cout << "\t[Throttle]" << "\n";
ret = rsmi_dev_metrics_indep_throttle_status_get(i, &val_ui64);
std::cout << "\t -> indep_throttle_status(): " << print_error_or_value(ret, val_ui64) << "\n";
ret = rsmi_dev_metrics_throttle_status_get(i, &val_ui32);
std::cout << "\t -> throttle_status(): " << print_error_or_value(ret, val_ui32) << "\n";
std::cout << "\n";
std::cout << "\t[Gfx Clock Lock]" << "\n";
ret = rsmi_dev_metrics_gfxclk_lock_status_get(i, &val_ui32);
std::cout << "\t -> gfxclk_lock_status(): " << print_error_or_value(ret, val_ui32) << "\n";
std::cout << "\n";
std::cout << "\t[Current Fan Speed]" << "\n";
ret = rsmi_dev_metrics_curr_fan_speed_get(i, &val_ui16);
std::cout << "\t -> current_fan_speed(): " << print_error_or_value(ret, val_ui16) << "\n";
std::cout << "\n";
std::cout << "\t[Link/Bandwidth/Speed]" << "\n";
ret = rsmi_dev_metrics_pcie_link_width_get(i, &val_ui16);
std::cout << "\t -> pcie_link_width(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_pcie_link_speed_get(i, &val_ui16);
std::cout << "\t -> pcie_link_speed(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_pcie_bandwidth_acc_get(i, &val_ui64);
std::cout << "\t -> pcie_bandwidth_accum(): " << print_error_or_value(ret, val_ui64) << "\n";
ret = rsmi_dev_metrics_pcie_bandwidth_inst_get(i, &val_ui64);
std::cout << "\t -> pcie_bandwidth_inst(): " << print_error_or_value(ret, val_ui64) << "\n";
ret = rsmi_dev_metrics_pcie_l0_recov_count_acc_get(i, &val_ui64);
std::cout << "\t -> pcie_l0_recov_count_accum(): " << print_error_or_value(ret, val_ui64) << "\n";
ret = rsmi_dev_metrics_pcie_replay_count_acc_get(i, &val_ui64);
std::cout << "\t -> pcie_replay_count_accum(): " << print_error_or_value(ret, val_ui64) << "\n";
ret = rsmi_dev_metrics_pcie_replay_rover_count_acc_get(i, &val_ui64);
std::cout << "\t -> pcie_replay_rollover_count_accum(): " << print_error_or_value(ret, val_ui64) << "\n";
ret = rsmi_dev_metrics_xgmi_link_width_get(i, &val_ui16);
std::cout << "\t -> xgmi_link_width(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_xgmi_link_speed_get(i, &val_ui16);
std::cout << "\t -> xgmi_link_speed(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_xgmi_read_data_get(i, &xgmi_read_values);
std::cout << "\t -> xgmi_read_data(): " << print_error_or_value(ret, xgmi_read_values) << "\n";
ret = rsmi_dev_metrics_xgmi_write_data_get(i, &xgmi_write_values);
std::cout << "\t -> xgmi_write_data(): " << print_error_or_value(ret, xgmi_write_values) << "\n";
std::cout << "\n";
std::cout << "\t[Voltage]" << "\n";
ret = rsmi_dev_metrics_volt_soc_get(i, &val_ui16);
std::cout << "\t -> voltage_soc(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_volt_gfx_get(i, &val_ui16);
std::cout << "\t -> voltage_gfx(): " << print_error_or_value(ret, val_ui16) << "\n";
ret = rsmi_dev_metrics_volt_mem_get(i, &val_ui16);
std::cout << "\t -> voltage_mem(): " << print_error_or_value(ret, val_ui16) << "\n";
std::cout << "\n";
std::cout << "\t[Timestamp]" << "\n";
ret = rsmi_dev_metrics_system_clock_counter_get(i, &val_ui64);
std::cout << "\t -> system_clock_counter(): " << print_error_or_value(ret, val_ui64) << "\n";
ret = rsmi_dev_metrics_firmware_timestamp_get(i, &val_ui64);
std::cout << "\t -> firmware_timestamp(): " << print_error_or_value(ret, val_ui64) << "\n";
std::cout << "\n";
std::cout << "\t[XCD CounterVoltage]" << "\n";
ret = rsmi_dev_metrics_xcd_counter_get(i, &val_ui16);
std::cout << "\t -> xcd_counter(): " << print_error_or_value(ret, val_ui16) << "\n";
std::cout << "\n\n";
std::cout << "\t**p.current_gfxclk: " << std::dec
<< p.current_gfxclk << "\n";
std::cout << "\t**p.current_socclk: " << std::dec
<< p.current_socclk << "\n";
std::cout << "\t**p.current_uclk: " << std::dec
<< p.current_uclk << "\n";
std::cout << "\t**p.current_vclk0: " << std::dec
<< p.current_vclk0 << "\n";
std::cout << "\t**p.current_dclk0: " << std::dec
<< p.current_dclk0 << "\n";
std::cout << "\t**p.current_vclk1: " << std::dec
<< p.current_vclk1 << "\n";
std::cout << "\t**p.current_dclk1: " << std::dec
<< p.current_dclk1 << "\n";
ret = rsmi_dev_perf_level_get(i, &pfl);
CHK_AND_PRINT_RSMI_ERR_RET(ret)
projects/amdsmi/rocm_smi/include/rocm_smi/rocm_smi.h
+1290 -68
Zobrazit soubor
Rozdílový obsah nebyl zobrazen, protože je příliš veliký Načíst rozdílové porovnání
projects/amdsmi/rocm_smi/include/rocm_smi/rocm_smi_binary_parser.h
+262
Zobrazit soubor
@@ -0,0 +1,262 @@
/*
* =============================================================================
* The University of Illinois/NCSA
* Open Source License (NCSA)
*
* Copyright (c) 2017-2023, Advanced Micro Devices, Inc.
* All rights reserved.
*
* Developed by:
*
* AMD Research and AMD ROC Software Development
*
* Advanced Micro Devices, Inc.
*
* www.amd.com
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal with the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimers.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimers in
* the documentation and/or other materials provided with the distribution.
* - Neither the names of <Name of Development Group, Name of Institution>,
* nor the names of its contributors may be used to endorse or promote
* products derived from this Software without specific prior written
* permission.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS WITH THE SOFTWARE.
*
*/
#ifndef ROCM_SMI_ROCM_SMI_BINARY_PARSER_H_
#define ROCM_SMI_ROCM_SMI_BINARY_PARSER_H_
#include "rocm_smi/rocm_smi_common.h"
#include "rocm_smi/rocm_smi.h"
#include <cstdint>
#include <map>
#include <memory>
#include <tuple>
#include <vector>
/**
* A binary parser to read the pm table and register table
*
*/
namespace amd::smi {
// definition for register table
enum amdgpu_sysfs_reg_offset {
AMDGPU_SYS_REG_STATE_XGMI = 0x0000,
AMDGPU_SYS_REG_STATE_WAFL = 0x1000,
AMDGPU_SYS_REG_STATE_PCIE = 0x2000,
AMDGPU_SYS_REG_STATE_USR = 0x3000,
AMDGPU_SYS_REG_STATE_USR_1 = 0x4000,
AMDGPU_SYS_REG_STATE_END = 0x5000,
};
#define FIELD_FLAG_NUM_INSTANCE 0x01
#define FIELD_FLAG_NUM_SMN 0x02
#define FIELD_FLAG_INSTANCE_START 0x04
#define FIELD_FLAG_SMN_START 0x08
#define FIELD_TYPE_U8 0x01
#define FIELD_TYPE_U16 0x02
#define FIELD_TYPE_U32 0x04
#define FIELD_TYPE_U64 0x08
struct metric_field {
uint8_t field_type;
int field_arr_size;
const char *field_name;
uint8_t field_flag;
};
struct metric_field xgmi_regs[] = {
{ FIELD_TYPE_U16, 1, "structure_size", 0 },
{ FIELD_TYPE_U8, 1, "format_revision", 0 },
{ FIELD_TYPE_U8, 1, "content_revision", 0 },
{ FIELD_TYPE_U8, 1, "state_type", 0 },
{ FIELD_TYPE_U8, 1, "num_instances", FIELD_FLAG_NUM_INSTANCE },
{ FIELD_TYPE_U16, 1, "pad", 0 },
{ FIELD_TYPE_U16, 1, "instance", FIELD_FLAG_INSTANCE_START },
{ FIELD_TYPE_U16, 1, "state", 0 },
{ FIELD_TYPE_U16, 1, "num_smn_regs", FIELD_FLAG_NUM_SMN },
{ FIELD_TYPE_U16, 1, "pad", 0 },
{ FIELD_TYPE_U64, 1, "addr", FIELD_FLAG_SMN_START },
{ FIELD_TYPE_U32, 1, "value", 0 },
{ FIELD_TYPE_U32, 1, "pad", 0 },
{ 0, 0, NULL, 0 },
};
// check me!
struct metric_field wafl_regs[] = {
{ FIELD_TYPE_U16, 1, "structure_size", 0 },
{ FIELD_TYPE_U8, 1, "format_revision", 0 },
{ FIELD_TYPE_U8, 1, "content_revision", 0 },
{ FIELD_TYPE_U8, 1, "state_type", 0 },
{ FIELD_TYPE_U8, 1, "num_instances", FIELD_FLAG_NUM_INSTANCE },
{ FIELD_TYPE_U16, 1, "pad", 0 },
{ FIELD_TYPE_U16, 1, "instance", FIELD_FLAG_INSTANCE_START },
{ FIELD_TYPE_U16, 1, "state", 0 },
{ FIELD_TYPE_U16, 1, "num_smn_regs", FIELD_FLAG_NUM_SMN },
{ FIELD_TYPE_U16, 1, "pad", 0 },
{ FIELD_TYPE_U64, 1, "addr", FIELD_FLAG_SMN_START },
{ FIELD_TYPE_U32, 1, "value", 0 },
{ FIELD_TYPE_U32, 1, "pad", 0 },
{ 0, 0, NULL, 0 },
};
struct metric_field pcie_regs[] = {
{ FIELD_TYPE_U16, 1, "structure_size", 0 },
{ FIELD_TYPE_U8, 1, "format_revision", 0 },
{ FIELD_TYPE_U8, 1, "content_revision", 0 },
{ FIELD_TYPE_U8, 1, "state_type", 0 },
{ FIELD_TYPE_U8, 1, "num_instances", FIELD_FLAG_NUM_INSTANCE },
{ FIELD_TYPE_U16, 1, "pad", 0 },
{ FIELD_TYPE_U16, 1, "instance", FIELD_FLAG_INSTANCE_START },
{ FIELD_TYPE_U16, 1, "state", 0 },
{ FIELD_TYPE_U16, 1, "num_smn_regs", FIELD_FLAG_NUM_SMN },
{ FIELD_TYPE_U16, 1, "pad", 0 },
{ FIELD_TYPE_U16, 1, "device_status", 0 },
{ FIELD_TYPE_U16, 1, "link_status", 0 },
{ FIELD_TYPE_U32, 1, "sub_bus_number_latency", 0 },
{ FIELD_TYPE_U32, 1, "pcie_corr_err_status", 0 },
{ FIELD_TYPE_U32, 1, "pcie_uncorr_err_status", 0 },
{ FIELD_TYPE_U64, 1, "addr", FIELD_FLAG_SMN_START },
{ FIELD_TYPE_U32, 1, "value", 0 },
{ FIELD_TYPE_U32, 1, "pad", 0 },
{ 0, 0, NULL, 0 },
};
struct metric_field usr_regs[] = {
{ FIELD_TYPE_U16, 1, "structure_size", 0 },
{ FIELD_TYPE_U8, 1, "format_revision", 0 },
{ FIELD_TYPE_U8, 1, "content_revision", 0 },
{ FIELD_TYPE_U8, 1, "state_type", 0 },
{ FIELD_TYPE_U8, 1, "num_instances", FIELD_FLAG_NUM_INSTANCE },
{ FIELD_TYPE_U16, 1, "pad", 0 },
{ FIELD_TYPE_U16, 1, "instance", FIELD_FLAG_INSTANCE_START },
{ FIELD_TYPE_U16, 1, "state", 0 },
{ FIELD_TYPE_U16, 1, "num_smn_regs", FIELD_FLAG_NUM_SMN },
{ FIELD_TYPE_U16, 1, "pad", 0 },
{ FIELD_TYPE_U64, 1, "addr", FIELD_FLAG_SMN_START },
{ FIELD_TYPE_U32, 1, "value", 0 },
{ FIELD_TYPE_U32, 1, "pad", 0 },
{ 0, 0, NULL, 0 },
};
// definition for pm metrics table
#define FIELD_FLAG_ACCUMULATOR 0x01
struct metric_field smu_13_0_6_v8[] = {
{ FIELD_TYPE_U16, 1, "structure_size", 0 },
{ FIELD_TYPE_U16, 1, "pad", 0 },
{ FIELD_TYPE_U32, 1, "mp1_ip_discovery_version", 0 },
{ FIELD_TYPE_U32, 1, "pmfw_version", 0 },
{ FIELD_TYPE_U32, 1, "pmmetrics_version", 0 },
{ FIELD_TYPE_U32, 1, "AccumulationCounter", 0 },
{ FIELD_TYPE_U32, 1, "MaxSocketTemperature", 0 },
{ FIELD_TYPE_U32, 1, "MaxVrTemperature", 0 },
{ FIELD_TYPE_U32, 1, "MaxHbmTemperature", 0 },
{ FIELD_TYPE_U64, 1, "MaxSocketTemperatureAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U64, 1, "MaxVrTemperatureAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U64, 1, "MaxHbmTemperatureAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U32, 1, "SocketPowerLimit", 0 },
{ FIELD_TYPE_U32, 1, "MaxSocketPowerLimit", 0 },
{ FIELD_TYPE_U32, 1, "SocketPower", 0 },
{ FIELD_TYPE_U64, 1, "Timestamp", 0 },
{ FIELD_TYPE_U64, 1, "SocketEnergyAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U64, 1, "CcdEnergyAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U64, 1, "XcdEnergyAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U64, 1, "AidEnergyAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U64, 1, "HbmEnergyAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U32, 1, "CclkFrequencyLimit", 0 },
{ FIELD_TYPE_U32, 1, "GfxclkFrequencyLimit", 0 },
{ FIELD_TYPE_U32, 1, "FclkFrequency", 0 },
{ FIELD_TYPE_U32, 1, "UclkFrequency", 0 },
{ FIELD_TYPE_U32, 4, "SocclkFrequency", 0 },
{ FIELD_TYPE_U32, 4, "VclkFrequency", 0 },
{ FIELD_TYPE_U32, 4, "DclkFrequency", 0 },
{ FIELD_TYPE_U32, 4, "LclkFrequency", 0 },
{ FIELD_TYPE_U64, 8, "GfxclkFrequencyAcc", FIELD_FLAG_ACCUMULATOR},
{ FIELD_TYPE_U64, 96, "CclkFrequencyAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U32, 1, "MaxCclkFrequency", 0 },
{ FIELD_TYPE_U32, 1, "MinCclkFrequency", 0 },
{ FIELD_TYPE_U32, 1, "MaxGfxclkFrequency", 0 },
{ FIELD_TYPE_U32, 1, "MinGfxclkFrequency", 0 },
{ FIELD_TYPE_U32, 4, "FclkFrequencyTable", 0 },
{ FIELD_TYPE_U32, 4, "UclkFrequencyTable", 0 },
{ FIELD_TYPE_U32, 4, "SocclkFrequencyTable", 0 },
{ FIELD_TYPE_U32, 4, "VclkFrequencyTable", 0 },
{ FIELD_TYPE_U32, 4, "DclkFrequencyTable", 0 },
{ FIELD_TYPE_U32, 4, "LclkFrequencyTable", 0 },
{ FIELD_TYPE_U32, 1, "MaxLclkDpmRange", 0 },
{ FIELD_TYPE_U32, 1, "MinLclkDpmRange", 0 },
{ FIELD_TYPE_U32, 1, "XgmiWidth", 0 },
{ FIELD_TYPE_U32, 1, "XgmiBitrate", 0 },
{ FIELD_TYPE_U64, 8, "XgmiReadBandwidthAcc", 0 },
{ FIELD_TYPE_U64, 8, "XgmiWriteBandwidthAcc", 0 },
{ FIELD_TYPE_U32, 1, "SocketC0Residency", 0 },
{ FIELD_TYPE_U32, 1, "SocketGfxBusy", 0 },
{ FIELD_TYPE_U32, 1, "DramBandwidthUtilization", 0 },
{ FIELD_TYPE_U64, 1, "SocketC0ResidencyAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U64, 1, "SocketGfxBusyAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U64, 1, "DramBandwidthAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U32, 1, "MaxDramBandwidth", 0 },
{ FIELD_TYPE_U64, 1, "DramBandwidthUtilizationAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U64, 4, "PcieBandwidthAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U32, 1, "ProchotResidencyAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U32, 1, "PptResidencyAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U32, 1, "SocketThmResidencyAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U32, 1, "VrThmResidencyAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U32, 1, "HbmThmResidencyAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U32, 1, "GfxLockXCDMak", 0 },
{ FIELD_TYPE_U32, 8, "GfxclkFrequency", 0 },
{ FIELD_TYPE_U64, 4, "PublicSerialNumber_AID", 0 },
{ FIELD_TYPE_U64, 8, "PublicSerialNumber_XCD", 0 },
{ FIELD_TYPE_U64, 12, "PublicSerialNumber_CCD", 0 },
{ FIELD_TYPE_U64, 8, "XgmiReadDataSizeAcc", FIELD_FLAG_ACCUMULATOR },
{ FIELD_TYPE_U64, 8, "XgmiWriteDataSizeAcc", FIELD_FLAG_ACCUMULATOR },
{ 0, 0, NULL, 0 },
};
} // namespace amd::smi
#endif // ROCM_SMI_ROCM_SMI_BINARY_PARSER_H_
projects/amdsmi/rocm_smi/include/rocm_smi/rocm_smi_device.h
+8 -9
Zobrazit soubor
@@ -53,6 +53,7 @@
#include <unordered_set>
#include <map>
#include <type_traits>
#include <optional>
#include "rocm_smi/rocm_smi_monitor.h"
#include "rocm_smi/rocm_smi_power_mon.h"
@@ -171,6 +172,8 @@ enum DevInfoTypes {
kDevMemPageBad,
kDevNumaNode,
kDevGpuMetrics,
kDevPmMetrics,
kDevRegMetrics,
kDevGpuReset,
kDevAvailableComputePartition,
kDevComputePartition,
@@ -205,6 +208,7 @@ class Device {
int readDevInfo(DevInfoTypes type, std::vector<std::string> *retVec);
int readDevInfo(DevInfoTypes type, std::size_t b_size,
void *p_binary_data);
std::string get_sys_file_path_by_type(DevInfoTypes type) const;
// Get the property from a file which may contain multiple properties.
int readDevInfo(DevInfoTypes type, const std::string& property,
std::string& value);
@@ -231,7 +235,7 @@ class Device {
void set_evt_notif_anon_fd(uint32_t fd) {
evt_notif_anon_fd_ = static_cast<int>(fd);}
int evt_notif_anon_fd(void) const {return evt_notif_anon_fd_;}
metrics_table_header_t &gpu_metrics_ver(void) {return gpu_metrics_ver_;}
void fillSupportedFuncs(void);
void DumpSupportedFunctions(void);
bool DeviceAPISupported(std::string name, uint64_t variant,
@@ -241,18 +245,15 @@ class Device {
template <typename T> std::string readBootPartitionState(uint32_t dv_ind);
rsmi_status_t check_amdgpu_property_reinforcement_query(uint32_t dev_idx, AMDGpuVerbTypes_t verb_type);
void dev_set_gpu_metric(GpuMetricsBasePtr gpu_metrics_ptr) { m_gpu_metrics_ptr = gpu_metrics_ptr; };
void dev_set_gpu_metric(GpuMetricsBasePtr gpu_metrics_ptr) { m_gpu_metrics_ptr = std::move(gpu_metrics_ptr); };
GpuMetricsBasePtr& dev_get_gpu_metric() { return m_gpu_metrics_ptr; };
const AMDGpuMetricsHeader_v1_t& dev_get_metrics_header() {return m_gpu_metrics_header; }
rsmi_status_t setup_gpu_metrics_reading();
rsmi_status_t dev_read_gpu_metrics_header_data();
rsmi_status_t dev_read_gpu_metrics_all_data();
rsmi_status_t dev_log_gpu_metrics();
rsmi_status_t run_internal_gpu_metrics_query(AMDGpuMetricsUnitType_t metric_counter, AMDGpuDynamicMetricTblValues_t& values);
template<typename T>
rsmi_status_t dev_run_gpu_metrics_query(AMDGpuMetricsUnitType_t metric_counter, T& metric_value);
rsmi_status_t dev_log_gpu_metrics(std::ostringstream& outstream_metrics);
AMGpuMetricsPublicLatestTupl_t dev_copy_internal_to_external_metrics();
private:
std::shared_ptr<Monitor> monitor_;
@@ -287,8 +288,6 @@ class Device {
int evt_notif_anon_fd_;
FILE *evt_notif_anon_file_ptr_;
struct metrics_table_header_t gpu_metrics_ver_;
GpuMetricsBasePtr m_gpu_metrics_ptr;
AMDGpuMetricsHeader_v1_t m_gpu_metrics_header;
uint64_t m_gpu_metrics_updated_timestamp;
projects/amdsmi/rocm_smi/include/rocm_smi/rocm_smi_gpu_metrics.h
+172 -59
Zobrazit soubor
@@ -47,10 +47,16 @@
#include "rocm_smi/rocm_smi_common.h"
#include "rocm_smi/rocm_smi.h"
#include <array>
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <cstring>
#include <map>
#include <memory>
#include <type_traits>
#include <tuple>
#include <variant>
#include <vector>
@@ -96,15 +102,14 @@ struct AMDGpuMetricsHeader_v1_t
uint8_t m_content_revision;
};
struct AMDGpuMetricsBase_t;
using AMDGpuMetricsBaseRef = AMDGpuMetricsBase_t&;
struct AMDGpuMetricsBase_t
{
virtual ~AMDGpuMetricsBase_t() = default;
};
using AMDGpuMetricsBaseRef = AMDGpuMetricsBase_t&;
struct AMDGpuMetrics_v11_t : AMDGpuMetricsBase_t
struct AMDGpuMetrics_v11_t
{
~AMDGpuMetrics_v11_t() = default;
@@ -166,7 +171,7 @@ struct AMDGpuMetrics_v11_t : AMDGpuMetricsBase_t
uint16_t m_temperature_hbm[kRSMI_MAX_NUM_HBM_INSTANCES];
};
struct AMDGpuMetrics_v12_t : AMDGpuMetricsBase_t
struct AMDGpuMetrics_v12_t
{
~AMDGpuMetrics_v12_t() = default;
@@ -226,11 +231,11 @@ struct AMDGpuMetrics_v12_t : AMDGpuMetricsBase_t
uint32_t m_mem_activity_acc; // new in v1
uint16_t m_temperature_hbm[kRSMI_MAX_NUM_HBM_INSTANCES]; // new in v1
// PMFW attached timestamp (10ns resolution)
// PMFW attached timestamp (10ns resolution)
uint64_t m_firmware_timestamp;
};
struct AMDGpuMetrics_v13_t : AMDGpuMetricsBase_t
struct AMDGpuMetrics_v13_t
{
~AMDGpuMetrics_v13_t() = default;
@@ -304,7 +309,7 @@ struct AMDGpuMetrics_v13_t : AMDGpuMetricsBase_t
uint64_t m_indep_throttle_status;
};
struct AMDGpuMetrics_v14_t : AMDGpuMetricsBase_t
struct AMDGpuMetrics_v14_t
{
~AMDGpuMetrics_v14_t() = default;
@@ -316,7 +321,7 @@ struct AMDGpuMetrics_v14_t : AMDGpuMetricsBase_t
uint16_t m_temperature_vrsoc;
// Power (Watts)
uint16_t m_curr_socket_power;
uint16_t m_current_socket_power;
// Utilization (%)
uint16_t m_average_gfx_activity;
@@ -340,8 +345,8 @@ struct AMDGpuMetrics_v14_t : AMDGpuMetricsBase_t
uint16_t m_pcie_link_speed; // in 0.1 GT/s
// XGMI bus width and bitrate (in Gbps)
uint16_t m_xgmi_link_width;
uint16_t m_xgmi_link_speed;
uint16_t m_xgmi_link_width;
uint16_t m_xgmi_link_speed;
// Utilization Accumulated (%)
uint32_t m_gfx_activity_acc;
@@ -353,6 +358,15 @@ struct AMDGpuMetrics_v14_t : AMDGpuMetricsBase_t
// PCIE instantaneous bandwidth (GB/sec)
uint64_t m_pcie_bandwidth_inst;
// PCIE L0 to recovery state transition accumulated count
uint64_t m_pcie_l0_to_recov_count_acc;
// PCIE replay accumulated count
uint64_t m_pcie_replay_count_acc;
// PCIE replay rollover accumulated count
uint64_t m_pcie_replay_rover_count_acc;
// XGMI accumulated data transfer size(KiloBytes)
uint64_t m_xgmi_read_data_acc[kRSMI_MAX_NUM_XGMI_LINKS];
uint64_t m_xgmi_write_data_acc[kRSMI_MAX_NUM_XGMI_LINKS];
@@ -371,33 +385,52 @@ struct AMDGpuMetrics_v14_t : AMDGpuMetricsBase_t
};
using AMGpuMetricsLatest_t = AMDGpuMetrics_v14_t;
/**
* This is GPU Metrics version that gets to public access.
* It is a unique/unified version (joined) of the previous
* versions (1.2 to latest 1.4). Data fields not used/relevant
* for the current driver version and GPU metrics version will
* not be populated, and therefore 0s (zeroes).
*
* If/in case anything new is added to a new version and there is
* a requirement to make it publicly available, into a single static
* table/form/struct, then it should be added here.
*
*/
using AMGpuMetricsPublicLatest_t = rsmi_gpu_metrics_t;
using AMGpuMetricsPublicLatestTupl_t = std::tuple<rsmi_status_t, AMGpuMetricsPublicLatest_t>;
using GpuMetricU16Tbl_t = std::vector<uint16_t>;
using GpuMetricU32Tbl_t = std::vector<uint32_t>;
using GpuMetricU64Tbl_t = std::vector<uint64_t>;
using GPUMetricTempHbm_t = decltype(AMDGpuMetrics_v13_t::m_temperature_hbm);
using GPUMetricTempHbmTbl_t = std::array<uint16_t, kRSMI_MAX_NUM_HBM_INSTANCES>;
using GPUMetricTempHbmTbl_t = GpuMetricU16Tbl_t;
using GPUMetricVcnActivity_t = decltype(AMDGpuMetrics_v14_t::m_vcn_activity);
using GPUMetricVcnActivityTbl_t = std::array<uint16_t, kRSMI_MAX_NUM_VCN>;
using GPUMetricVcnActivityTbl_t = GpuMetricU16Tbl_t;
using GPUMetricXgmiReadDataAcc_t = decltype(AMDGpuMetrics_v14_t::m_xgmi_read_data_acc);
using GPUMetricXgmiWriteDataAcc_t = decltype(AMDGpuMetrics_v14_t::m_xgmi_write_data_acc);
using GPUMetricXgmiAccTbl_t = std::array<uint64_t, kRSMI_MAX_NUM_XGMI_LINKS>;
using GPUMetricXgmiAccTbl_t = GpuMetricU64Tbl_t;
using GPUMetricCurrGfxClk_t = decltype(AMDGpuMetrics_v14_t::m_current_gfxclk);
using GPUMetricCurrGfxClkTbl_t = std::array<uint16_t, kRSMI_MAX_NUM_GFX_CLKS>;
using GPUMetricCurrGfxClkTbl_t = GpuMetricU16Tbl_t;
using GPUMetricCurrSocClk_t = decltype(AMDGpuMetrics_v14_t::m_current_socclk);
using GPUMetricCurrSocClkTbl_t = std::array<uint16_t, kRSMI_MAX_NUM_CLKS>;
using GPUMetricCurrSocClkTbl_t = GpuMetricU16Tbl_t;
using GPUMetricCurrVClk0_t = decltype(AMDGpuMetrics_v14_t::m_current_vclk0);
using GPUMetricCurrVClkTbl_t = std::array<uint16_t, kRSMI_MAX_NUM_CLKS>;
using GPUMetricCurrVClkTbl_t = GpuMetricU16Tbl_t;
using GPUMetricCurrDClk0_t = decltype(AMDGpuMetrics_v14_t::m_current_dclk0);
using GPUMetricCurrDClkTbl_t = std::array<uint16_t, kRSMI_MAX_NUM_CLKS>;
using GPUMetricCurrDClkTbl_t = GpuMetricU16Tbl_t;
/*
////
/************************************************************
* When a new metric table is released, we have to update: *
1. Constants related to the new metrics added;
1. Constants related to the new metrics added (if any);
(ie: kRSMI_MAX_NUM_XGMI_LINKS)
2. Constants related to new version:
(ie: kRSMI_GPU_METRICS_API_CONTENT_MAJOR_VER_1)
@@ -411,19 +444,35 @@ using GPUMetricCurrDClkTbl_t = std::array<uint16_t, kRSMI_MAX_NUM_CLKS>;
5. AMGpuMetricsLatest_t -> Newest AMDGpuMetrics_v1x_t
6. AMDGpuMetricVersionFlags_t
(ie: AMDGpuMetricVersionFlags_t::kGpuMetricV14)
7. Create the proper API using granular controls used by
rsmi_dev_gpu_metrics_info_query() (ie: rsmi_dev_temp_hotspot_get())
-> Remember to check/update:
- AMDGpuMetricsUnitType_t
- amdgpu_metrics_unit_type_translation_table
- AMDGpuMetrics_v1X_t structure in question
- populate_metrics_dynamic_tbl()
- copy_internal_to_external_metrics()
- init_max_public_gpu_matrics()
*/
using AMDGpuMetricTypeId_t = uint32_t;
using AMDGpuMetricTypeIdSeq_t = uint32_t;
using AMDGpuMetricVersionFlagId_t = uint32_t;
////
/*
*
* These are used as Metric class, so Metric Units can be properly grouped.
* Each Metric Unit (or a set of them) is related to a Metric class.
*
*/
enum class AMDGpuMetricsClassId_t : AMDGpuMetricTypeId_t
{
kGpuMetricHeader = 0,
kGpuMetricHeader,
kGpuMetricTemperature,
kGpuMetricUtilization,
kGpuMetricPowerEnergy,
kGpuMetricSystemClockCounter,
kGpuMetricAverageClock,
kGpuMetricCurrentClock,
kGpuMetricThrottleStatus,
@@ -435,6 +484,22 @@ enum class AMDGpuMetricsClassId_t : AMDGpuMetricTypeId_t
};
using AMDGpuMetricsClassIdTranslationTbl_t = std::map<AMDGpuMetricsClassId_t, std::string>;
/*
*
* These are the Metric units. Each one represents a specific metric we want
* to either store or retrieve.
*
* This also gives a more granular control over to what exactly is needed,
* helping to generalize metric queries.
*
* Each type a new (non-existing metric unit) metric is added, it should be
* updated here.
* - Their names matches (closely, regardless of their version) the name of
* the data structure members they represent.
*
* All metric units not flagged as v1.4 were either part of the base or
* added/changed up to v1.3
*/
enum class AMDGpuMetricsUnitType_t : AMDGpuMetricTypeId_t
{
// kGpuMetricTemperature counters
@@ -452,7 +517,7 @@ enum class AMDGpuMetricsUnitType_t : AMDGpuMetricTypeId_t
kMetricAvgMmActivity,
kMetricGfxActivityAccumulator,
kMetricMemActivityAccumulator,
kMetricVcnActivity,
kMetricVcnActivity, //v1.4
// kGpuMetricAverageClock counters
kMetricAvgGfxClockFrequency,
@@ -464,11 +529,11 @@ enum class AMDGpuMetricsUnitType_t : AMDGpuMetricTypeId_t
kMetricAvgDClock1Frequency,
// kGpuMetricCurrentClock counters
kMetricCurrGfxClock,
kMetricCurrSocClock,
kMetricCurrGfxClock, //v1.4: Changed to multi-valued
kMetricCurrSocClock, //v1.4: Changed to multi-valued
kMetricCurrUClock,
kMetricCurrVClock0,
kMetricCurrDClock0,
kMetricCurrVClock0, //v1.4: Changed to multi-valued
kMetricCurrDClock0, //v1.4: Changed to multi-valued
kMetricCurrVClock1,
kMetricCurrDClock1,
@@ -477,7 +542,7 @@ enum class AMDGpuMetricsUnitType_t : AMDGpuMetricTypeId_t
kMetricIndepThrottleStatus,
// kGpuMetricGfxClkLockStatus counters
kMetricGfxClkLockStatus,
kMetricGfxClkLockStatus, //v1.4
// kGpuMetricCurrentFanSpeed counters
kMetricCurrFanSpeed,
@@ -485,22 +550,25 @@ enum class AMDGpuMetricsUnitType_t : AMDGpuMetricTypeId_t
// kGpuMetricLinkWidthSpeed counters
kMetricPcieLinkWidth,
kMetricPcieLinkSpeed,
kMetricPcieBandwidthAccumulator,
kMetricPcieBandwidthInst,
kMetricXgmiLinkWidth,
kMetricXgmiLinkSpeed,
kMetricXgmiReadDataAccumulator,
kMetricXgmiWriteDataAccumulator,
kMetricPcieBandwidthAccumulator, //v1.4
kMetricPcieBandwidthInst, //v1.4
kMetricXgmiLinkWidth, //v1.4
kMetricXgmiLinkSpeed, //v1.4
kMetricXgmiReadDataAccumulator, //v1.4
kMetricXgmiWriteDataAccumulator, //v1.4
kMetricPcieL0RecovCountAccumulator, //v1.4
kMetricPcieReplayCountAccumulator, //v1.4
kMetricPcieReplayRollOverCountAccumulator, //v1.4
// kGpuMetricPowerEnergy counters
kMetricAvgSocketPower,
kMetricCurrSocketPower,
kMetricEnergyAccumulator,
kMetricCurrSocketPower, //v1.4
kMetricEnergyAccumulator, //v1.4
// kGpuMetricVoltage counters
kMetricVoltageSoc,
kMetricVoltageGfx,
kMetricVoltageMem,
kMetricVoltageSoc, //v1.3
kMetricVoltageGfx, //v1.3
kMetricVoltageMem, //v1.3
// kGpuMetricTimestamp counters
kMetricTSClockCounter,
@@ -526,8 +594,12 @@ struct AMDGpuDynamicMetricsValue_t
using AMDGpuDynamicMetricTblValues_t = std::vector<AMDGpuDynamicMetricsValue_t>;
using AMDGpuDynamicMetricsTbl_t = std::map<AMDGpuMetricsClassId_t, std::map<AMDGpuMetricsUnitType_t, AMDGpuDynamicMetricTblValues_t>>;
// Note: All supported metric versions are listed her
// If not here, they are not supported
/*
*
* Note: All supported metric versions are listed here, otherwise unsupported
*
*/
enum class AMDGpuMetricVersionFlags_t : AMDGpuMetricVersionFlagId_t
{
kGpuMetricNone = 0x0,
@@ -537,21 +609,19 @@ enum class AMDGpuMetricVersionFlags_t : AMDGpuMetricVersionFlagId_t
kGpuMetricV13 = (0x1 << 3),
kGpuMetricV14 = (0x1 << 4),
};
using AMDGpuMetricVersionTranslationTbl_t = std::map<uint64_t, AMDGpuMetricVersionFlags_t>;
class GpuMetricsBase_t;
using GpuMetricsBasePtr = std::shared_ptr<GpuMetricsBase_t>;
using AMDGpuMetricVersionTranslationTbl_t = std::map<uint16_t, AMDGpuMetricVersionFlags_t>;
using GpuMetricTypePtr_t = std::shared_ptr<void>;
class GpuMetricsBase_t
{
public:
virtual ~GpuMetricsBase_t() = default;
virtual size_t sizeof_metric_table() = 0;
virtual AMDGpuMetricsBaseRef get_metrics_table() = 0;
virtual GpuMetricTypePtr_t get_metrics_table() = 0;
virtual void dump_internal_metrics_table() = 0;
virtual AMDGpuMetricVersionFlags_t get_gpu_metrics_version_used() = 0;
virtual rsmi_status_t populate_metrics_dynamic_tbl() = 0;
virtual AMGpuMetricsPublicLatestTupl_t copy_internal_to_external_metrics() = 0;
virtual AMDGpuDynamicMetricsTbl_t get_metrics_dynamic_tbl() {
return m_metrics_dynamic_tbl;
}
@@ -561,21 +631,31 @@ class GpuMetricsBase_t
uint64_t m_metrics_timestamp;
};
using GpuMetricsBasePtr = std::shared_ptr<GpuMetricsBase_t>;
using AMDGpuMetricFactories_t = std::map<AMDGpuMetricVersionFlags_t, GpuMetricsBasePtr>;
class GpuMetricsBase_v11_t final : public GpuMetricsBase_t
{
public:
~GpuMetricsBase_v11_t() = default;
virtual ~GpuMetricsBase_v11_t() = default;
size_t sizeof_metric_table() override {
return sizeof(AMDGpuMetrics_v11_t);
}
AMDGpuMetricsBaseRef get_metrics_table() override
GpuMetricTypePtr_t get_metrics_table() override
{
return m_gpu_metrics_tbl;
if (!m_gpu_metric_ptr) {
m_gpu_metric_ptr.reset(&m_gpu_metrics_tbl, [](AMDGpuMetrics_v11_t*){});
}
assert(m_gpu_metric_ptr != nullptr);
return m_gpu_metric_ptr;
}
void dump_internal_metrics_table() override
{
return;
}
AMDGpuMetricVersionFlags_t get_gpu_metrics_version_used() override
@@ -584,10 +664,12 @@ class GpuMetricsBase_v11_t final : public GpuMetricsBase_t
}
rsmi_status_t populate_metrics_dynamic_tbl() override;
AMGpuMetricsPublicLatestTupl_t copy_internal_to_external_metrics() override;
private:
AMDGpuMetrics_v11_t m_gpu_metrics_tbl;
std::shared_ptr<AMDGpuMetrics_v11_t> m_gpu_metric_ptr;
};
@@ -600,9 +682,18 @@ class GpuMetricsBase_v12_t final : public GpuMetricsBase_t
return sizeof(AMDGpuMetrics_v12_t);
}
AMDGpuMetricsBaseRef get_metrics_table() override
GpuMetricTypePtr_t get_metrics_table() override
{
return m_gpu_metrics_tbl;
if (!m_gpu_metric_ptr) {
m_gpu_metric_ptr.reset(&m_gpu_metrics_tbl, [](AMDGpuMetrics_v12_t*){});
}
assert(m_gpu_metric_ptr != nullptr);
return m_gpu_metric_ptr;
}
void dump_internal_metrics_table() override
{
return;
}
AMDGpuMetricVersionFlags_t get_gpu_metrics_version_used() override
@@ -611,10 +702,11 @@ class GpuMetricsBase_v12_t final : public GpuMetricsBase_t
}
rsmi_status_t populate_metrics_dynamic_tbl() override;
AMGpuMetricsPublicLatestTupl_t copy_internal_to_external_metrics() override;
private:
AMDGpuMetrics_v12_t m_gpu_metrics_tbl;
std::shared_ptr<AMDGpuMetrics_v12_t> m_gpu_metric_ptr;
};
@@ -627,21 +719,29 @@ class GpuMetricsBase_v13_t final : public GpuMetricsBase_t
return sizeof(AMDGpuMetrics_v13_t);
}
AMDGpuMetricsBaseRef get_metrics_table() override
GpuMetricTypePtr_t get_metrics_table() override
{
return m_gpu_metrics_tbl;
if (!m_gpu_metric_ptr) {
m_gpu_metric_ptr.reset(&m_gpu_metrics_tbl, [](AMDGpuMetrics_v13_t*){});
}
assert(m_gpu_metric_ptr != nullptr);
return (m_gpu_metric_ptr);
}
void dump_internal_metrics_table() override;
AMDGpuMetricVersionFlags_t get_gpu_metrics_version_used() override
{
return AMDGpuMetricVersionFlags_t::kGpuMetricV13;
}
rsmi_status_t populate_metrics_dynamic_tbl() override;
AMGpuMetricsPublicLatestTupl_t copy_internal_to_external_metrics() override;
private:
AMDGpuMetrics_v13_t m_gpu_metrics_tbl;
std::shared_ptr<AMDGpuMetrics_v13_t> m_gpu_metric_ptr;
};
@@ -654,28 +754,41 @@ class GpuMetricsBase_v14_t final : public GpuMetricsBase_t
return sizeof(AMDGpuMetrics_v14_t);
}
AMDGpuMetricsBaseRef get_metrics_table() override
GpuMetricTypePtr_t get_metrics_table() override
{
return m_gpu_metrics_tbl;
if (!m_gpu_metric_ptr) {
m_gpu_metric_ptr.reset(&m_gpu_metrics_tbl, [](AMDGpuMetrics_v14_t*){});
}
assert(m_gpu_metric_ptr != nullptr);
return m_gpu_metric_ptr;
}
void dump_internal_metrics_table() override;
AMDGpuMetricVersionFlags_t get_gpu_metrics_version_used() override
{
return AMDGpuMetricVersionFlags_t::kGpuMetricV14;
}
rsmi_status_t populate_metrics_dynamic_tbl() override;
AMGpuMetricsPublicLatestTupl_t copy_internal_to_external_metrics() override;
private:
AMDGpuMetrics_v14_t m_gpu_metrics_tbl;
std::shared_ptr<AMDGpuMetrics_v14_t> m_gpu_metric_ptr;
};
template<typename T>
rsmi_status_t rsmi_dev_gpu_metrics_info_query(uint32_t dv_ind, AMDGpuMetricsUnitType_t metric_counter, T& metric_value);
} // namespace amd::smi
#endif // ROCM_SMI_ROCM_SMI_GPU_METRICS_H_
rsmi_status_t
rsmi_dev_gpu_metrics_header_info_get(uint32_t dv_ind, metrics_table_header_t& header_value);
#endif // ROCM_SMI_ROCM_SMI_GPU_METRICS_H_
projects/amdsmi/rocm_smi/python_smi_tools/README.md
+1 -3
Zobrazit soubor
@@ -1,6 +1,4 @@
## Synopsis
Radeon Open Compute Platform - System Management Interface - Command Line tool.
## Radeon Open Compute (ROCm) - System Management Interface - Command Line Tool
This tool acts as a command line interface for manipulating
and monitoring the amdgpu kernel, and is intended to replace
projects/amdsmi/rocm_smi/src/rocm_smi.cc
+1000 -64
Zobrazit soubor
Rozdílový obsah nebyl zobrazen, protože je příliš veliký Načíst rozdílové porovnání
projects/amdsmi/rocm_smi/src/rocm_smi_binary_parser.cc
Spustitelný soubor
+320
Zobrazit soubor
@@ -0,0 +1,320 @@
/*
* =============================================================================
* The University of Illinois/NCSA
* Open Source License (NCSA)
*
* Copyright (c) 2017-2023, Advanced Micro Devices, Inc.
* All rights reserved.
*
* Developed by:
*
* AMD Research and AMD ROC Software Development
*
* Advanced Micro Devices, Inc.
*
* www.amd.com
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal with the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimers.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimers in
* the documentation and/or other materials provided with the distribution.
* - Neither the names of <Name of Development Group, Name of Institution>,
* nor the names of its contributors may be used to endorse or promote
* products derived from this Software without specific prior written
* permission.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS WITH THE SOFTWARE.
*
*/
#include "rocm_smi/rocm_smi_binary_parser.h"
#include "rocm_smi/rocm_smi_common.h" // Should go before rocm_smi.h
#include "rocm_smi/rocm_smi.h"
#include "rocm_smi/rocm_smi_main.h"
#include "rocm_smi/rocm_smi_utils.h"
#include "rocm_smi/rocm_smi_exception.h"
#include "rocm_smi/rocm_smi_device.h"
#include "rocm_smi/rocm_smi_logger.h"
#include <dirent.h>
#include <pthread.h>
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <cstring>
#include <fstream>
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <variant>
#include <vector>
namespace amd::smi {
static uint64_t get_value(uint8_t **ptr, struct metric_field *field) {
uint64_t v;
switch (field->field_type) {
case FIELD_TYPE_U8:
v = *(uint8_t*)(*ptr);
++(*ptr);
break;
case FIELD_TYPE_U16:
v = *(uint16_t*)(*ptr);
(*ptr) += 2;
break;
case FIELD_TYPE_U32:
v = *(uint32_t*)(*ptr);
(*ptr) += 4;
break;
case FIELD_TYPE_U64:
v = *(uint64_t*)(*ptr);
(*ptr) += 8;
break;
}
return v;
}
static int parse_pmmetric_table(uint8_t *buf, struct metric_field *table,
int32_t buflen, rsmi_name_value_t **kv, uint32_t *kvnum) {
uint64_t v1;
int x, y;
uint8_t *origbuf = buf;
uint32_t kvsize = 64;
*kv = reinterpret_cast<rsmi_name_value_t*>(calloc(kvsize, sizeof **kv));
*kvnum = 0;
for (x = 0; table[x].field_name; x++) {
for (y = 0; y < table[x].field_arr_size; y++) {
v1 = get_value(&buf, &table[x]);
if ((intptr_t)(buf - origbuf) > buflen) {
fprintf(stderr,
"[ERROR]: Invalid buffer as buffer length exceeded\n");
return -1;
}
if (*kvnum == kvsize) {
kvsize += 64;
*kv = reinterpret_cast<rsmi_name_value_t*>
(realloc(*kv,kvsize * (sizeof **kv)));
}
if (table[x].field_arr_size == 1) {
sprintf((*kv)[*kvnum].name, "%s", table[x].field_name);
} else {
sprintf((*kv)[*kvnum].name, "%s[%d]", table[x].field_name, y);
}
(*kv)[*kvnum].value = v1;
++(*kvnum);
}
}
return 0;
}
/** present the PM metrics data
*
* @dri_instance: which card to pick under /sys/class/drm/card${instance}/device/
* @kv: pointer to pointer of rsmi_name_value pairs
* @kvnum: pointer to number of used rsmi_name_value pairs
*/
int present_pmmetrics(const char* fname,
rsmi_name_value_t **kv, uint32_t *kvnum)
{
uint8_t *buf1;
FILE *infile;
uint32_t pmmetrics_version;
metric_field *table;
int r;
int32_t len;
infile = fopen(fname, "rb");
if (!infile) {
fprintf(stderr, "[ERROR]: pm_metrics file not found \n");
return -1;
}
buf1 = reinterpret_cast<uint8_t *>(calloc(1, 65536));
if (!buf1) {
return -1;
}
table = NULL;
len = fread(buf1, 1, 65536, infile);
fseek(infile, 0, SEEK_SET);
memcpy(&pmmetrics_version, &buf1[12], 4);
switch (pmmetrics_version) {
case 4: // ??? why 4?
table = &smu_13_0_6_v8[0];
break;
default:
fprintf(stderr, "Metrics version %d not supported\n"
, pmmetrics_version);
return -1;
}
r = parse_pmmetric_table(buf1, table, len, kv, kvnum);
fclose(infile);
free(buf1);
return r;
}
static int parse_reg_state_table(uint8_t *buf, int32_t buflen,
struct metric_field *table,
rsmi_name_value_t **kv, uint32_t *kvnum) {
int skip_smn, x, y, cur_instance, cur_smn,
num_instance, num_smn, instance_start, smn_start;
uint64_t v;
uint8_t *obuf, *origbuf;
int kvsize = 64;
*kv = reinterpret_cast<rsmi_name_value_t*>(calloc(kvsize, sizeof **kv));
*kvnum = 0;
skip_smn = cur_instance = num_instance = num_smn = 0;
instance_start = smn_start = 0x1000;
x = 0;
origbuf = buf;
top:
while (table[x].field_name != NULL) {
for (y = 0; y < table[x].field_arr_size; y++) {
obuf = buf;
v = get_value(&buf, &table[x]);
if ((intptr_t)(buf - origbuf) > buflen) {
fprintf(stderr,
"[ERROR] Invalid buffer as read length was exceeded\n");
return -1;
}
switch (table[x].field_flag) {
case FIELD_FLAG_INSTANCE_START:
instance_start = x;
num_smn = cur_smn = 0;
break;
case FIELD_FLAG_SMN_START:
// if we hit an SMN start but there are no registers then skip back to the start
// of the instance block
if (skip_smn) {
// out of instances we're done so bail!
if (!num_instance)
return 0;
x = instance_start;
--num_instance;
++cur_instance;
// rewind the buffer since we didn't actually consume
// this word
buf = obuf;
goto top;
} else {
smn_start = x;
}
break;
case FIELD_FLAG_NUM_INSTANCE:
num_instance = v;
break;
case FIELD_FLAG_NUM_SMN:
num_smn = v;
if (v)
skip_smn = 0;
else
skip_smn = 1;
break;
}
if (*kvnum == kvsize) {
kvsize += 64;
*kv = reinterpret_cast<rsmi_name_value_t*>(
realloc(*kv, kvsize * (sizeof **kv)));
}
sprintf((*kv)[*kvnum].name, "%s", table[x].field_name);
if (table[x].field_arr_size > 1) {
sprintf((*kv)[*kvnum].name + strlen((*kv)[*kvnum].name), "[%d]", y);
}
if (x >= instance_start)
sprintf((*kv)[*kvnum].name + strlen((*kv)[*kvnum].name), ".instance[%d]", cur_instance);
if (x >= smn_start)
sprintf((*kv)[*kvnum].name + strlen((*kv)[*kvnum].name), ".smn[%d]", cur_smn);
(*kv)[*kvnum].value = v;
++(*kvnum);
}
// done move to next or loop
++x;
if (table[x].field_name == NULL && --num_smn) {
x = smn_start;
++cur_smn;
} else if (table[x].field_name == NULL && --num_instance) {
x = instance_start;
++cur_instance;
}
}
return 0;
}
/** present_reg_state: present register state data
*
* @dri_instance: The DRI instance to select under /sys/class/drm/card${instance}/device
* @table: Name of the table to read {"xgmi', "wafl", "pcie", "usr", "usr_1"}
* @kv: pointer to pointer of rsmi_name_value pairs
* @kvnum: pointer to number of used rsmi_name_value pairs
*/
int present_reg_state(const char* fname,
rsmi_reg_type_t reg_type, rsmi_name_value_t **kv, uint32_t *kvnum) {
uint8_t buf[4096];
FILE *infile;
struct metric_field *tab;
int32_t len;
infile = fopen(fname, "rb");
if (!infile) {
fprintf(stderr, "[ERROR]: reg_state file not found\n");
return -1;
}
tab = NULL;
if (reg_type == RSMI_REG_XGMI) {
fseek(infile, AMDGPU_SYS_REG_STATE_XGMI, SEEK_SET);
tab = &xgmi_regs[0];
}
if (reg_type == RSMI_REG_WAFL) {
fseek(infile, AMDGPU_SYS_REG_STATE_WAFL, SEEK_SET);
tab = &wafl_regs[0];
}
if (reg_type == RSMI_REG_PCIE) {
fseek(infile, AMDGPU_SYS_REG_STATE_PCIE, SEEK_SET);
tab = &pcie_regs[0];
}
if (reg_type == RSMI_REG_USR) {
fseek(infile, AMDGPU_SYS_REG_STATE_USR, SEEK_SET);
tab = &usr_regs[0];
}
if (reg_type == RSMI_REG_USR1) {
fseek(infile, AMDGPU_SYS_REG_STATE_USR_1, SEEK_SET);
tab = &usr_regs[0];
}
if (!tab) {
fprintf(stderr, "[ERROR]: Invalid register space named <%d>\n", reg_type);
fclose(infile);
return -2;
}
len = fread(buf, 1, sizeof buf, infile);
fclose(infile);
return parse_reg_state_table(buf, len, tab, kv, kvnum);
}
} // namespace amd::smi
projects/amdsmi/rocm_smi/src/rocm_smi_device.cc
+23 -2
Zobrazit soubor
@@ -130,6 +130,8 @@ static const char *kDevXGMIErrorFName = "xgmi_error";
static const char *kDevSerialNumberFName = "serial_number";
static const char *kDevNumaNodeFName = "numa_node";
static const char *kDevGpuMetricsFName = "gpu_metrics";
static const char *kDevPmMetricsFName = "pm_metrics"; // PM log
static const char *kDevRegMetricsFName = "reg_state"; // register table
static const char *kDevAvailableComputePartitionFName =
"available_compute_partition";
static const char *kDevComputePartitionFName = "current_compute_partition";
@@ -312,6 +314,8 @@ static const std::map<DevInfoTypes, const char *> kDevAttribNameMap = {
{kDevMemPageBad, kDevMemPageBadFName},
{kDevNumaNode, kDevNumaNodeFName},
{kDevGpuMetrics, kDevGpuMetricsFName},
{kDevPmMetrics, kDevPmMetricsFName},
{kDevRegMetrics, kDevRegMetricsFName},
{kDevGpuReset, kDevGpuResetFName},
{kDevAvailableComputePartition, kDevAvailableComputePartitionFName},
{kDevComputePartition, kDevComputePartitionFName},
@@ -445,6 +449,8 @@ static const std::map<const char *, dev_depends_t> kDevFuncDependsMap = {
{"rsmi_dev_memory_reserved_pages_get", {{kDevMemPageBadFName}, {}}},
{"rsmi_topo_numa_affinity_get", {{kDevNumaNodeFName}, {}}},
{"rsmi_dev_gpu_metrics_info_get", {{kDevGpuMetricsFName}, {}}},
{"rsmi_dev_pm_metrics_info_get", {{kDevPmMetricsFName}, {}}},
{"rsmi_dev_reg_table_info_get", {{kDevRegMetricsFName}, {}}},
{"rsmi_dev_gpu_reset", {{kDevGpuResetFName}, {}}},
{"rsmi_dev_compute_partition_get", {{kDevComputePartitionFName}, {}}},
{"rsmi_dev_compute_partition_set", {{kDevComputePartitionFName}, {}}},
@@ -543,7 +549,7 @@ static const std::map<const char *, dev_depends_t> kDevFuncDependsMap = {
Device::Device(std::string p, RocmSMI_env_vars const *e) :
monitor_(nullptr), path_(p), env_(e), evt_notif_anon_fd_(-1),
gpu_metrics_ver_{0, 0, 0} {
m_gpu_metrics_header{0, 0, 0} {
#ifndef DEBUG
env_ = nullptr;
#endif
@@ -594,6 +600,14 @@ int Device::openDebugFileStream(DevInfoTypes type, T *fs, const char *str) {
return 0;
}
std::string Device::get_sys_file_path_by_type(DevInfoTypes type) const {
auto sysfs_path = path_;
sysfs_path += "/device/";
sysfs_path += kDevAttribNameMap.at(type);
return sysfs_path;
}
template <typename T>
int Device::openSysfsFileStream(DevInfoTypes type, T *fs, const char *str) {
auto sysfs_path = path_;
@@ -902,7 +916,14 @@ int Device::readDevInfoBinary(DevInfoTypes type, std::size_t b_size,
if ((num*b_size) != b_size) {
ss << "Could not read DevInfoBinary for DevInfoType ("
<< RocmSMI::devInfoTypesStrings.at(type) << ") - SYSFS ("
<< sysfs_path << "), binary size error, "
<< sysfs_path << "), binary size error; "
<< "[buff: "
<< p_binary_data
<< " size: "
<< b_size
<< " read: "
<< num
<< "]"
<< ", returning ENOENT (" << std::strerror(ENOENT) << ")";
LOG_ERROR(ss);
return ENOENT;
projects/amdsmi/rocm_smi/src/rocm_smi_gpu_metrics.cc
+1891 -701
Zobrazit soubor
Rozdílový obsah nebyl zobrazen, protože je příliš veliký Načíst rozdílové porovnání
projects/amdsmi/rocm_smi/src/rocm_smi_main.cc
+2
Zobrazit soubor
@@ -154,6 +154,8 @@ amd::smi::RocmSMI::devInfoTypesStrings = {
{amd::smi::kDevMemPageBad, amdSMI + "kDevMemPageBad"},
{amd::smi::kDevNumaNode, amdSMI + "kDevNumaNode"},
{amd::smi::kDevGpuMetrics, amdSMI + "kDevGpuMetrics"},
{amd::smi::kDevPmMetrics, amdSMI + "kDevPmMetrics"},
{amd::smi::kDevRegMetrics, amdSMI + "kDevRegMetrics"},
{amd::smi::kDevGpuReset, amdSMI + "kDevGpuReset"},
{amd::smi::kDevAvailableComputePartition, amdSMI +
"kDevAvailableComputePartition"},
projects/amdsmi/src/amd_smi/amd_smi.cc
+624 -17
Zobrazit soubor
@@ -1019,7 +1019,7 @@ amdsmi_is_P2P_accessible(amdsmi_processor_handle processor_handle_src,
// Compute Partition functions
amdsmi_status_t
amdsmi_dev_compute_partition_get(amdsmi_processor_handle processor_handle,
amdsmi_get_gpu_compute_partition(amdsmi_processor_handle processor_handle,
char *compute_partition, uint32_t len) {
AMDSMI_CHECK_INIT();
return rsmi_wrapper(rsmi_dev_compute_partition_get, processor_handle,
@@ -1027,7 +1027,7 @@ amdsmi_dev_compute_partition_get(amdsmi_processor_handle processor_handle,
}
amdsmi_status_t
amdsmi_dev_compute_partition_set(amdsmi_processor_handle processor_handle,
amdsmi_set_gpu_compute_partition(amdsmi_processor_handle processor_handle,
amdsmi_compute_partition_type_t compute_partition) {
AMDSMI_CHECK_INIT();
return rsmi_wrapper(rsmi_dev_compute_partition_set, processor_handle,
@@ -1035,14 +1035,14 @@ amdsmi_dev_compute_partition_set(amdsmi_processor_handle processor_handle,
}
amdsmi_status_t
amdsmi_dev_compute_partition_reset(amdsmi_processor_handle processor_handle) {
amdsmi_reset_gpu_compute_partition(amdsmi_processor_handle processor_handle) {
AMDSMI_CHECK_INIT();
return rsmi_wrapper(rsmi_dev_compute_partition_reset, processor_handle);
}
// Memory Partition functions
amdsmi_status_t
amdsmi_dev_memory_partition_get(amdsmi_processor_handle processor_handle,
amdsmi_get_gpu_memory_partition(amdsmi_processor_handle processor_handle,
char *memory_partition, uint32_t len) {
AMDSMI_CHECK_INIT();
return rsmi_wrapper(rsmi_dev_memory_partition_get, processor_handle,
@@ -1050,7 +1050,7 @@ amdsmi_dev_memory_partition_get(amdsmi_processor_handle processor_handle,
}
amdsmi_status_t
amdsmi_dev_memory_partition_set(amdsmi_processor_handle processor_handle,
amdsmi_set_gpu_memory_partition(amdsmi_processor_handle processor_handle,
amdsmi_memory_partition_type_t memory_partition) {
AMDSMI_CHECK_INIT();
return rsmi_wrapper(rsmi_dev_memory_partition_set, processor_handle,
@@ -1058,7 +1058,7 @@ amdsmi_dev_memory_partition_set(amdsmi_processor_handle processor_handle,
}
amdsmi_status_t
amdsmi_dev_memory_partition_reset(amdsmi_processor_handle processor_handle) {
amdsmi_reset_gpu_memory_partition(amdsmi_processor_handle processor_handle) {
AMDSMI_CHECK_INIT();
return rsmi_wrapper(rsmi_dev_memory_partition_reset, processor_handle);
}
@@ -1157,6 +1157,31 @@ amdsmi_status_t amdsmi_get_gpu_metrics_info(
reinterpret_cast<rsmi_gpu_metrics_t*>(pgpu_metrics));
}
amdsmi_status_t amdsmi_get_gpu_pm_metrics_info(
amdsmi_processor_handle processor_handle,
amdsmi_name_value_t** pm_metrics,
uint32_t *num_of_metrics) {
AMDSMI_CHECK_INIT();
return rsmi_wrapper(rsmi_dev_pm_metrics_info_get, processor_handle,
reinterpret_cast<rsmi_name_value_t**>(pm_metrics),
num_of_metrics);
}
amdsmi_status_t amdsmi_get_gpu_reg_table_info(
amdsmi_processor_handle processor_handle,
amdsmi_reg_type_t reg_type,
amdsmi_name_value_t** reg_metrics,
uint32_t *num_of_metrics) {
AMDSMI_CHECK_INIT();
return rsmi_wrapper(rsmi_dev_reg_table_info_get, processor_handle,
static_cast<rsmi_reg_type_t>(reg_type),
reinterpret_cast<rsmi_name_value_t**>(reg_metrics),
num_of_metrics);
}
amdsmi_status_t
amdsmi_get_power_cap_info(amdsmi_processor_handle processor_handle,
uint32_t sensor_ind,
@@ -1834,22 +1859,21 @@ amdsmi_get_power_info(amdsmi_processor_handle processor_handle, amdsmi_power_inf
if (status != AMDSMI_STATUS_SUCCESS)
return status;
info->average_socket_power = 0xFFFFFFFF;
info->gfx_voltage = 0xFFFFFFFF;
info->soc_voltage = 0xFFFFFFFF; // Not implmented yet
info->mem_voltage = 0xFFFFFFFF; // Not implmented yet
info->power_limit = 0xFFFFFFFF;
info->current_socket_power = 0xFFFF;
info->average_socket_power = 0xFFFF;
info->gfx_voltage = 0xFFFF;
info->soc_voltage = 0xFFFF;
info->mem_voltage = 0xFFFF;
info->power_limit = 0xFFFF;
amdsmi_gpu_metrics_t metrics = {};
status = amdsmi_get_gpu_metrics_info(processor_handle, &metrics);
if (status == AMDSMI_STATUS_SUCCESS) {
info->current_socket_power = metrics.current_socket_power;
info->average_socket_power = metrics.average_socket_power;
}
int64_t voltage_read = 0;
status = amdsmi_get_gpu_volt_metric(processor_handle, AMDSMI_VOLT_TYPE_VDDGFX, AMDSMI_VOLT_CURRENT, &voltage_read);
if (status == AMDSMI_STATUS_SUCCESS) {
info->gfx_voltage = voltage_read;
info->gfx_voltage = metrics.voltage_gfx;
info->soc_voltage = metrics.voltage_soc;
info->mem_voltage = metrics.voltage_mem;
}
int power_limit = 0;
@@ -2130,6 +2154,589 @@ amdsmi_status_t amdsmi_get_processor_handle_from_bdf(amdsmi_bdf_t bdf,
return AMDSMI_STATUS_API_FAILED;
}
amdsmi_status_t
amdsmi_get_gpu_metrics_temp_hotspot(amdsmi_processor_handle processor_handle,
uint16_t *hotspot_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_temp_hotspot_get, processor_handle,
hotspot_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_temp_mem(amdsmi_processor_handle processor_handle,
uint16_t *mem_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_temp_mem_get, processor_handle,
mem_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_temp_vrsoc(amdsmi_processor_handle processor_handle,
uint16_t *vrsoc_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_temp_vrsoc_get, processor_handle,
vrsoc_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_curr_socket_power(amdsmi_processor_handle processor_handle,
uint16_t *socket_power_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_curr_socket_power_get, processor_handle,
socket_power_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_avg_gfx_activity(amdsmi_processor_handle processor_handle,
uint16_t *gfx_activity_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_avg_gfx_activity_get, processor_handle,
gfx_activity_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_avg_umc_activity(amdsmi_processor_handle processor_handle,
uint16_t *umc_activity_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_avg_umc_activity_get, processor_handle,
umc_activity_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_energy_acc(amdsmi_processor_handle processor_handle,
uint64_t *energy_acc_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_energy_acc_get, processor_handle,
energy_acc_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_system_clock_counter(amdsmi_processor_handle processor_handle,
uint64_t *system_clock_counter_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_system_clock_counter_get, processor_handle,
system_clock_counter_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_firmware_timestamp(amdsmi_processor_handle processor_handle,
uint64_t *firmware_timestamp_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_firmware_timestamp_get, processor_handle,
firmware_timestamp_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_throttle_status(amdsmi_processor_handle processor_handle,
uint32_t *throttle_status_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_throttle_status_get, processor_handle,
throttle_status_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_pcie_link_width(amdsmi_processor_handle processor_handle,
uint16_t *pcie_link_width_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_pcie_link_width_get, processor_handle,
pcie_link_width_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_pcie_link_speed(amdsmi_processor_handle processor_handle,
uint16_t *pcie_link_speed_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_pcie_link_speed_get, processor_handle,
pcie_link_speed_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_xgmi_link_width(amdsmi_processor_handle processor_handle,
uint16_t *xgmi_link_width_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_xgmi_link_width_get, processor_handle,
xgmi_link_width_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_xgmi_link_speed(amdsmi_processor_handle processor_handle,
uint16_t *xgmi_link_speed_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_xgmi_link_speed_get, processor_handle,
xgmi_link_speed_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_gfxclk_lock_status(amdsmi_processor_handle processor_handle,
uint32_t *gfxclk_lock_status_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_gfxclk_lock_status_get, processor_handle,
gfxclk_lock_status_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_gfx_activity_acc(amdsmi_processor_handle processor_handle,
uint32_t *gfx_activity_acc_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_gfx_activity_acc_get, processor_handle,
gfx_activity_acc_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_mem_activity_acc(amdsmi_processor_handle processor_handle,
uint32_t *mem_activity_acc_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_mem_activity_acc_get, processor_handle,
mem_activity_acc_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_pcie_bandwidth_acc(amdsmi_processor_handle processor_handle,
uint64_t *pcie_bandwidth_acc_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_pcie_bandwidth_acc_get, processor_handle,
pcie_bandwidth_acc_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_pcie_bandwidth_inst(amdsmi_processor_handle processor_handle,
uint64_t *pcie_bandwidth_inst_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_pcie_bandwidth_inst_get, processor_handle,
pcie_bandwidth_inst_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_pcie_l0_recov_count_acc(amdsmi_processor_handle processor_handle,
uint64_t *pcie_count_acc_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_pcie_l0_recov_count_acc_get, processor_handle,
pcie_count_acc_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_pcie_replay_count_acc(amdsmi_processor_handle processor_handle,
uint64_t *pcie_count_acc_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_pcie_replay_count_acc_get, processor_handle,
pcie_count_acc_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_pcie_replay_rover_count_acc(amdsmi_processor_handle processor_handle,
uint64_t *pcie_count_acc_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_pcie_replay_rover_count_acc_get, processor_handle,
pcie_count_acc_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_curr_uclk(amdsmi_processor_handle processor_handle,
uint16_t *uclk_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_curr_uclk_get, processor_handle,
uclk_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_temp_hbm(amdsmi_processor_handle processor_handle,
gpu_metric_temp_hbm_t *temp_hbm_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_temp_hbm_get, processor_handle,
reinterpret_cast<GPUMetricTempHbm_t*>(temp_hbm_value));
}
amdsmi_status_t
amdsmi_get_gpu_metrics_vcn_activity(amdsmi_processor_handle processor_handle,
gpu_metric_vcn_activity_t *vcn_activity_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_vcn_activity_get, processor_handle,
reinterpret_cast<GPUMetricVcnActivity_t*>(vcn_activity_value));
}
amdsmi_status_t
amdsmi_get_gpu_metrics_xgmi_read_data(amdsmi_processor_handle processor_handle,
gpu_metric_xgmi_read_data_acc_t *xgmi_read_data_acc_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_xgmi_read_data_get, processor_handle,
reinterpret_cast<GPUMetricXgmiReadDataAcc_t*>(xgmi_read_data_acc_value));
}
amdsmi_status_t
amdsmi_get_gpu_metrics_xgmi_write_data(amdsmi_processor_handle processor_handle,
gpu_metric_xgmi_write_data_acc_t *xgmi_write_data_acc_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_xgmi_write_data_get, processor_handle,
reinterpret_cast<GPUMetricXgmiWriteDataAcc_t*>(xgmi_write_data_acc_value));
}
amdsmi_status_t
amdsmi_get_gpu_metrics_curr_gfxclk(amdsmi_processor_handle processor_handle,
gpu_metric_curr_gfxclk_t *curr_gfxclk_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_curr_gfxclk_get, processor_handle,
reinterpret_cast<GPUMetricCurrGfxClk_t*>(curr_gfxclk_value));
}
amdsmi_status_t
amdsmi_get_gpu_metrics_curr_socclk(amdsmi_processor_handle processor_handle,
gpu_metric_curr_socclk_t *current_socclk_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_curr_socclk_get, processor_handle,
reinterpret_cast<GPUMetricCurrSocClk_t*>(current_socclk_value));
}
amdsmi_status_t
amdsmi_get_gpu_metrics_curr_vclk0(amdsmi_processor_handle processor_handle,
gpu_metric_curr_vclk0_t *current_vclk_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_curr_vclk0_get, processor_handle,
reinterpret_cast<GPUMetricCurrVClk0_t*>(current_vclk_value));
}
amdsmi_status_t
amdsmi_get_gpu_metrics_curr_dclk0(amdsmi_processor_handle processor_handle,
gpu_metric_curr_dclk0_t *current_dclk_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_curr_dclk0_get, processor_handle,
reinterpret_cast<GPUMetricCurrDClk0_t*>(current_dclk_value));
}
amdsmi_status_t
amdsmi_get_gpu_metrics_temp_edge(amdsmi_processor_handle processor_handle,
uint16_t *edge_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_temp_edge_get, processor_handle,
edge_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_temp_vrgfx(amdsmi_processor_handle processor_handle,
uint16_t *vrgfx_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_temp_vrgfx_get, processor_handle,
vrgfx_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_temp_vrmem(amdsmi_processor_handle processor_handle,
uint16_t *vrmem_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_temp_vrmem_get, processor_handle,
vrmem_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_avg_mm_activity(amdsmi_processor_handle processor_handle,
uint16_t *mm_activity_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_avg_mm_activity_get, processor_handle,
mm_activity_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_curr_vclk1(amdsmi_processor_handle processor_handle,
uint16_t *current_vclk_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_curr_vclk1_get, processor_handle,
current_vclk_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_curr_dclk1(amdsmi_processor_handle processor_handle,
uint16_t *current_dclk_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_curr_dclk1_get, processor_handle,
current_dclk_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_indep_throttle_status(amdsmi_processor_handle processor_handle,
uint64_t *throttle_status_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_indep_throttle_status_get, processor_handle,
throttle_status_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_avg_socket_power(amdsmi_processor_handle processor_handle,
uint16_t *socket_power_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_avg_socket_power_get, processor_handle,
socket_power_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_curr_fan_speed(amdsmi_processor_handle processor_handle,
uint16_t *fan_speed_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_curr_fan_speed_get, processor_handle,
fan_speed_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_avg_gfx_clock_frequency(amdsmi_processor_handle processor_handle,
uint16_t *clock_frequency_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_avg_gfx_clock_frequency_get, processor_handle,
clock_frequency_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_avg_soc_clock_frequency(amdsmi_processor_handle processor_handle,
uint16_t *clock_frequency_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_avg_soc_clock_frequency_get, processor_handle,
clock_frequency_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_avg_uclock_frequency(amdsmi_processor_handle processor_handle,
uint16_t *clock_frequency_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_avg_uclock_frequency_get, processor_handle,
clock_frequency_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_avg_vclock0_frequency(amdsmi_processor_handle processor_handle,
uint16_t *clock_frequency_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_avg_vclock0_frequency_get, processor_handle,
clock_frequency_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_avg_dclock0_frequency(amdsmi_processor_handle processor_handle,
uint16_t *clock_frequency_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_avg_dclock0_frequency_get, processor_handle,
clock_frequency_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_avg_vclock1_frequency(amdsmi_processor_handle processor_handle,
uint16_t *clock_frequency_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_avg_vclock1_frequency_get, processor_handle,
clock_frequency_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_avg_dclock1_frequency(amdsmi_processor_handle processor_handle,
uint16_t *clock_frequency_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_avg_dclock1_frequency_get, processor_handle,
clock_frequency_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_volt_soc(amdsmi_processor_handle processor_handle,
uint16_t *voltage_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_volt_soc_get, processor_handle,
voltage_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_volt_gfx(amdsmi_processor_handle processor_handle,
uint16_t *voltage_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_volt_gfx_get, processor_handle,
voltage_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_volt_mem(amdsmi_processor_handle processor_handle,
uint16_t *voltage_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_volt_mem_get, processor_handle,
voltage_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_header_info(amdsmi_processor_handle processor_handle,
amd_metrics_table_header_t *header_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_header_info_get, processor_handle,
reinterpret_cast<metrics_table_header_t*>(header_value));
}
amdsmi_status_t
amdsmi_get_gpu_metrics_xcd_counter(amdsmi_processor_handle processor_handle,
uint16_t *xcd_counter_value)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_xcd_counter_get, processor_handle,
xcd_counter_value);
}
amdsmi_status_t
amdsmi_get_gpu_metrics_log(amdsmi_processor_handle processor_handle)
{
AMDSMI_CHECK_INIT();
// nullptr api supported
return rsmi_wrapper(rsmi_dev_metrics_log_get, processor_handle);
}
#ifdef ENABLE_ESMI_LIB
amdsmi_status_t amdsmi_get_cpu_hsmp_proto_ver(amdsmi_cpusocket_handle socket_handle,
uint32_t *proto_ver)
projects/amdsmi/tests/amd_smi_test/functional/gpu_metrics_read.cc
+378 -1
Zobrazit soubor
@@ -100,7 +100,7 @@ void TestGpuMetricsRead::Run(void) {
PrintDeviceHeader(processor_handles_[i]);
IF_VERB(STANDARD) {
std::cout << "\t**GPU METRICS:\n";
std::cout << "\t**GPU METRICS: Using static struct (Backwards Compatibility):\n";
}
amdsmi_gpu_metrics_t smu;
err = amdsmi_get_gpu_metrics_info(processor_handles_[i], &smu);
@@ -191,4 +191,381 @@ void TestGpuMetricsRead::Run(void) {
err = amdsmi_get_gpu_metrics_info(processor_handles_[i], nullptr);
ASSERT_EQ(err, AMDSMI_STATUS_INVAL);
}
//
auto val_ui16 = uint16_t(0);
auto val_ui32 = uint32_t(0);
auto val_ui64 = uint64_t(0);
auto status_code(amdsmi_status_t::AMDSMI_STATUS_SUCCESS);
for (uint32_t i = 0; i < num_monitor_devs(); ++i) {
PrintDeviceHeader(processor_handles_[i]);
auto temp_edge_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_temp_edge(processor_handles_[i], &temp_edge_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_hotspot_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_temp_hotspot(processor_handles_[i], &temp_hotspot_value);
CHK_ERR_ASRT(status_code);
auto temp_mem_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_temp_mem(processor_handles_[i], &temp_mem_value);
CHK_ERR_ASRT(status_code);
auto temp_vrgfx_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_temp_vrgfx(processor_handles_[i], &temp_vrgfx_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_vrsoc_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_temp_vrsoc(processor_handles_[i], &temp_vrsoc_value);
CHK_ERR_ASRT(status_code);
auto temp_vrmem_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_temp_vrmem(processor_handles_[i], &temp_vrmem_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
gpu_metric_temp_hbm_t temp_hbm_values;
status_code = amdsmi_get_gpu_metrics_temp_hbm(processor_handles_[i], &temp_hbm_values);
CHK_ERR_ASRT(status_code);
auto temp_curr_socket_power_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_curr_socket_power(processor_handles_[i], &temp_curr_socket_power_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_energy_accum_value = val_ui64;
status_code = amdsmi_get_gpu_metrics_energy_acc(processor_handles_[i], &temp_energy_accum_value);
CHK_ERR_ASRT(status_code);
auto temp_avg_socket_power_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_avg_socket_power(processor_handles_[i], &temp_avg_socket_power_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_avg_gfx_activity_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_avg_gfx_activity(processor_handles_[i], &temp_avg_gfx_activity_value);
CHK_ERR_ASRT(status_code);
auto temp_avg_umc_activity_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_avg_umc_activity(processor_handles_[i], &temp_avg_umc_activity_value);
CHK_ERR_ASRT(status_code);
auto temp_avg_mm_activity_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_avg_mm_activity(processor_handles_[i], &temp_avg_mm_activity_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
gpu_metric_vcn_activity_t temp_vcn_values;
status_code = amdsmi_get_gpu_metrics_vcn_activity(processor_handles_[i], &temp_vcn_values);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_mem_activity_accum_value = val_ui32;
status_code = amdsmi_get_gpu_metrics_mem_activity_acc(processor_handles_[i], &temp_mem_activity_accum_value);
CHK_ERR_ASRT(status_code);
auto temp_gfx_activity_accum_value = val_ui32;
status_code = amdsmi_get_gpu_metrics_gfx_activity_acc(processor_handles_[i], &temp_gfx_activity_accum_value);
CHK_ERR_ASRT(status_code);
auto temp_avg_gfx_clock_freq_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_avg_gfx_clock_frequency(processor_handles_[i], &temp_avg_gfx_clock_freq_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_avg_soc_clock_freq_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_avg_soc_clock_frequency(processor_handles_[i], &temp_avg_soc_clock_freq_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_avg_uclock_freq_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_avg_uclock_frequency(processor_handles_[i], &temp_avg_uclock_freq_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_avg_vclock0_freq_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_avg_vclock0_frequency(processor_handles_[i], &temp_avg_vclock0_freq_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_avg_dclock0_freq_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_avg_dclock0_frequency(processor_handles_[i], &temp_avg_dclock0_freq_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_avg_vclock1_freq_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_avg_vclock1_frequency(processor_handles_[i], &temp_avg_vclock1_freq_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_avg_dclock1_freq_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_avg_dclock1_frequency(processor_handles_[i], &temp_avg_dclock1_freq_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_curr_vclk1_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_curr_vclk1(processor_handles_[i], &temp_curr_vclk1_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_curr_dclk1_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_curr_dclk1(processor_handles_[i], &temp_curr_dclk1_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_curr_uclk_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_curr_uclk(processor_handles_[i], &temp_curr_uclk_value);
CHK_ERR_ASRT(status_code);
gpu_metric_curr_dclk0_t temp_curr_dclk0_values;
status_code = amdsmi_get_gpu_metrics_curr_dclk0(processor_handles_[i], &temp_curr_dclk0_values);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
gpu_metric_curr_gfxclk_t temp_curr_gfxclk_values;
status_code = amdsmi_get_gpu_metrics_curr_gfxclk(processor_handles_[i], &temp_curr_gfxclk_values);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
gpu_metric_curr_socclk_t temp_curr_socclk_values;
status_code = amdsmi_get_gpu_metrics_curr_socclk(processor_handles_[i], &temp_curr_socclk_values);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
gpu_metric_curr_vclk0_t temp_curr_vclk0_values;
status_code = amdsmi_get_gpu_metrics_curr_vclk0(processor_handles_[i], &temp_curr_vclk0_values);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_indep_throttle_status_value = val_ui64;
status_code = amdsmi_get_gpu_metrics_indep_throttle_status(processor_handles_[i], &temp_indep_throttle_status_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_throttle_status_value = val_ui32;
status_code = amdsmi_get_gpu_metrics_throttle_status(processor_handles_[i], &temp_throttle_status_value);
CHK_ERR_ASRT(status_code);
auto temp_gfxclk_lock_status_value = val_ui32;
status_code = amdsmi_get_gpu_metrics_gfxclk_lock_status(processor_handles_[i], &temp_gfxclk_lock_status_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_curr_fan_speed_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_curr_fan_speed(processor_handles_[i], &temp_curr_fan_speed_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_pcie_link_width_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_pcie_link_width(processor_handles_[i], &temp_pcie_link_width_value);
CHK_ERR_ASRT(status_code);
auto temp_pcie_link_speed_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_pcie_link_speed(processor_handles_[i], &temp_pcie_link_speed_value);
CHK_ERR_ASRT(status_code);
auto temp_pcie_bandwidth_accum_value = val_ui64;
status_code = amdsmi_get_gpu_metrics_pcie_bandwidth_acc(processor_handles_[i], &temp_pcie_bandwidth_accum_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_pcie_bandwidth_inst_value = val_ui64;
status_code = amdsmi_get_gpu_metrics_pcie_bandwidth_inst(processor_handles_[i], &temp_pcie_bandwidth_inst_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_pcie_l0_recov_count_accum_value = val_ui64;
status_code = amdsmi_get_gpu_metrics_pcie_l0_recov_count_acc(processor_handles_[i], &temp_pcie_l0_recov_count_accum_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_pcie_replay_count_accum_value = val_ui64;
status_code = amdsmi_get_gpu_metrics_pcie_replay_count_acc(processor_handles_[i], &temp_pcie_replay_count_accum_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_pcie_replay_rover_count_accum_value = val_ui64;
status_code = amdsmi_get_gpu_metrics_pcie_replay_rover_count_acc(processor_handles_[i], &temp_pcie_replay_rover_count_accum_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_xgmi_link_width_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_xgmi_link_width(processor_handles_[i], &temp_xgmi_link_width_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_xgmi_link_speed_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_xgmi_link_speed(processor_handles_[i], &temp_xgmi_link_speed_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
gpu_metric_xgmi_read_data_acc_t temp_xgmi_read_values;
status_code = amdsmi_get_gpu_metrics_xgmi_read_data(processor_handles_[i], &temp_xgmi_read_values);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
gpu_metric_xgmi_write_data_acc_t temp_xgmi_write_values;
status_code = amdsmi_get_gpu_metrics_xgmi_write_data(processor_handles_[i], &temp_xgmi_write_values);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_voltage_soc_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_volt_soc(processor_handles_[i], &temp_voltage_soc_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_voltage_gfx_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_volt_gfx(processor_handles_[i], &temp_voltage_gfx_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_voltage_mem_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_volt_mem(processor_handles_[i], &temp_voltage_mem_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
auto temp_system_clock_counter_value = val_ui64;
status_code = amdsmi_get_gpu_metrics_system_clock_counter(processor_handles_[i], &temp_system_clock_counter_value);
CHK_ERR_ASRT(status_code);
auto temp_firmware_timestamp_value = val_ui64;
status_code = amdsmi_get_gpu_metrics_firmware_timestamp(processor_handles_[i], &temp_firmware_timestamp_value);
CHK_ERR_ASRT(status_code);
auto temp_xcd_counter_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_xcd_counter(processor_handles_[i], &temp_xcd_counter_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
IF_VERB(STANDARD) {
std::cout << "\n";
std::cout << "\t[Temperature]" << "\n";
std::cout << "\t -> temp_edge(): " << temp_edge_value << "\n";
std::cout << "\t -> temp_hotspot(): " << temp_hotspot_value << "\n";
std::cout << "\t -> temp_mem(): " << temp_mem_value << "\n";
std::cout << "\t -> temp_vrgfx(): " << temp_vrgfx_value << "\n";
std::cout << "\t -> temp_vrsoc(): " << temp_vrsoc_value << "\n";
std::cout << "\t -> temp_vrmem(): " << temp_vrmem_value << "\n";
std::cout << "\t -> temp_hbm(): " << temp_hbm_values << "\n";
std::cout << "\n";
std::cout << "\t[Power/Energy]" << "\n";
std::cout << "\t -> current_socket_power(): " << temp_curr_socket_power_value << "\n";
std::cout << "\t -> energy_accum(): " << temp_energy_accum_value << "\n";
std::cout << "\t -> average_socket_power(): " << temp_avg_socket_power_value << "\n";
std::cout << "\n";
std::cout << "\t[Utilization]" << "\n";
std::cout << "\t -> average_gfx_activity(): " << temp_avg_gfx_activity_value << "\n";
std::cout << "\t -> average_umc_activity(): " << temp_avg_umc_activity_value << "\n";
std::cout << "\t -> average_mm_activity(): " << temp_avg_mm_activity_value << "\n";
std::cout << "\t -> vcn_activity(): " << temp_vcn_values << "\n";
std::cout << "\t -> mem_activity_accum(): " << temp_mem_activity_accum_value << "\n";
std::cout << "\t -> gfx_activity_accum(): " << temp_gfx_activity_accum_value << "\n";
std::cout << "\n";
std::cout << "\t[Average Clock]" << "\n";
std::cout << "\t -> average_gfx_clock_frequency(): " << temp_avg_gfx_clock_freq_value << "\n";
std::cout << "\t -> average_soc_clock_frequency(): " << temp_avg_soc_clock_freq_value << "\n";
std::cout << "\t -> average_uclock_frequency(): " << temp_avg_uclock_freq_value << "\n";
std::cout << "\t -> average_vclock0_frequency(): " << temp_avg_vclock0_freq_value << "\n";
std::cout << "\t -> average_dclock0_frequency(): " << temp_avg_dclock0_freq_value << "\n";
std::cout << "\t -> average_vclock1_frequency(): " << temp_avg_vclock1_freq_value << "\n";
std::cout << "\t -> average_dclock1_frequency(): " << temp_avg_dclock1_freq_value << "\n";
std::cout << "\n";
std::cout << "\t[Current Clock]" << "\n";
std::cout << "\t -> current_vclock1(): " << temp_curr_vclk1_value << "\n";
std::cout << "\t -> current_dclock1(): " << temp_curr_dclk1_value << "\n";
std::cout << "\t -> current_uclock(): " << temp_curr_uclk_value << "\n";
std::cout << "\t -> current_dclk0(): " << temp_curr_dclk0_values << "\n";
std::cout << "\t -> current_gfxclk(): " << temp_curr_gfxclk_values << "\n";
std::cout << "\t -> current_soc_clock(): " << temp_curr_socclk_values << "\n";
std::cout << "\t -> current_vclk0(): " << temp_curr_vclk0_values << "\n";
std::cout << "\n";
std::cout << "\t[Throttle]" << "\n";
std::cout << "\t -> indep_throttle_status(): " << temp_indep_throttle_status_value << "\n";
std::cout << "\t -> throttle_status(): " << temp_throttle_status_value << "\n";
std::cout << "\n";
std::cout << "\t[Gfx Clock Lock]" << "\n";
std::cout << "\t -> gfxclk_lock_status(): " << temp_gfxclk_lock_status_value << "\n";
std::cout << "\n";
std::cout << "\t[Current Fan Speed]" << "\n";
std::cout << "\t -> current_fan_speed(): " << temp_curr_fan_speed_value << "\n";
std::cout << "\n";
std::cout << "\t[Link/Bandwidth/Speed]" << "\n";
std::cout << "\t -> pcie_link_width(): " << temp_pcie_link_width_value << "\n";
std::cout << "\t -> pcie_link_speed(): " << temp_pcie_link_speed_value << "\n";
std::cout << "\t -> pcie_bandwidth_accum(): " << temp_pcie_bandwidth_accum_value << "\n";
std::cout << "\t -> pcie_bandwidth_inst(): " << temp_pcie_bandwidth_inst_value << "\n";
std::cout << "\t -> pcie_l0_recov_count_accum(): " << temp_pcie_l0_recov_count_accum_value << "\n";
std::cout << "\t -> pcie_replay_count_accum(): " << temp_pcie_replay_count_accum_value << "\n";
std::cout << "\t -> pcie_replay_rollover_count_accum(): " << temp_pcie_replay_rover_count_accum_value << "\n";
std::cout << "\t -> xgmi_link_width(): " << temp_xgmi_link_width_value << "\n";
std::cout << "\t -> xgmi_link_speed(): " << temp_xgmi_link_speed_value << "\n";
std::cout << "\t -> xgmi_read_data(): " << temp_xgmi_read_values << "\n";
std::cout << "\t -> xgmi_write_data(): " << temp_xgmi_write_values << "\n";
std::cout << "\n";
std::cout << "\t[Voltage]" << "\n";
std::cout << "\t -> voltage_soc(): " << temp_voltage_soc_value << "\n";
std::cout << "\t -> voltage_gfx(): " << temp_voltage_gfx_value << "\n";
std::cout << "\t -> voltage_mem(): " << temp_voltage_mem_value << "\n";
std::cout << "\n";
std::cout << "\t[Timestamp]" << "\n";
std::cout << "\t -> system_clock_counter(): " << temp_system_clock_counter_value << "\n";
std::cout << "\t -> firmware_timestamp(): " << temp_firmware_timestamp_value << "\n";
std::cout << "\n";
std::cout << "\t[XCD CounterVoltage]" << "\n";
std::cout << "\t -> xcd_counter(): " << temp_xcd_counter_value << "\n";
std::cout << "\n\n";
}
}
}
projects/amdsmi/tests/amd_smi_test/functional/temp_read.cc
+1 -1
Zobrazit soubor
@@ -108,7 +108,7 @@ void TestTempRead::Run(void) {
return;
}
uint32_t type;
uint32_t type(0);
for (uint32_t x = 0; x < num_iterations(); ++x) {
for (uint32_t i = 0; i < num_monitor_devs(); ++i) {
PrintDeviceHeader(processor_handles_[i]);