AI/rocm-systems
2
0
Förgrening 0
Kod Ärenden Pull-förfrågningar Actions Packages Projekt Släpp Wiki Aktiviteter

Merge amd-dev into amd-master 20240201

Bläddra i källkod 
Signed-off-by: guanyu12 <guanyu12@amd.com>
Change-Id: I75565c99893266bcd3436f694880460deb56b353
This commit is contained in:
guanyu12
2024-02-01 14:43:10 +08:00
förälder fc5ecc166a 1e708aaad9
incheckning 3af2f1733b
8 ändrade filer med 164 tillägg och 2686 borttagningar
Download Patch File Download Diff File Expand all files Collapse all files
amdsmi_cli/amdsmi_commands.py
+3 -7
Visa fil
@@ -204,7 +204,7 @@ class AMDSMICommands():
try:
smu = amdsmi_interface.amdsmi_get_cpu_smu_fw_version(args.cpu)
static_dict["smu"] = {"FW_VERSION" : f"{ smu['smu_fw_major_ver_num']}"
f":{smu['smu_fw_minor_ver_num']}:{smu['smu_fw_debug_ver_num']}"}
f".{smu['smu_fw_minor_ver_num']}.{smu['smu_fw_debug_ver_num']}"}
except amdsmi_exception.AmdSmiLibraryException as e:
static_dict["smu"] = "N/A"
logging.debug("Failed to get SMU FW for cpu %s | %s", cpu_id, e.get_error_info())
@@ -1121,8 +1121,8 @@ class AMDSMICommands():
# Put the metrics table in the debug logs
try:
gpu_metric_debug_output = amdsmi_interface.amdsmi_get_gpu_metrics_info(args.gpu)
gpu_metric_str = json.dumps(gpu_metric_debug_output, indent=4)
gpu_metric_debug_info = amdsmi_interface.amdsmi_get_gpu_metrics_info(args.gpu)
gpu_metric_str = json.dumps(gpu_metric_debug_info, indent=4)
logging.debug("GPU Metrics table for %s | %s", gpu_id, gpu_metric_str)
except amdsmi_exception.AmdSmiLibraryException as e:
logging.debug("Unabled to load GPU Metrics table for %s | %s", gpu_id, e.err_info)
@@ -1152,10 +1152,6 @@ class AMDSMICommands():
engine_usage['jpeg_activity'] = gpu_metric_info.pop('jpeg_activity')
for key, value in engine_usage.items():
if not isinstance(value, list) and value > 100:
engine_usage[key] = "N/A"
elif isinstance(value, list):
engine_usage[key] = ["N/A" if v > 100 else v for v in value]
if self.logger.is_human_readable_format():
unit = '%'
include/amd_smi/amdsmi.h
-1056
Visa fil
Filskillnaden har hållits tillbaka eftersom den är för stor Load Diff
py-interface/README.md
+37 -39
Visa fil
@@ -598,7 +598,7 @@ Input parameters:
* `processor_handle` device which to query
Output: Dictionary with fields
Output: Dictionary of activites to their respective usage percentage or 'N/A' if not supported
Field | Description
---|---
@@ -2136,8 +2136,6 @@ Output: Dictionary with fields
`current_socclks` | List of current soc clock frequencies | MHz
`current_vclk0s` | List of current v0 clock frequencies | MHz
`current_dclk0s` | List of current d0 clock frequencies | MHz
`mem_bandwidth_acc` | Memory bandwidth usage accumulated | GB/s
`mem_max_bandwidth` | Maximum memory bandwidth usage accumulated | GB/s
`pcie_nak_sent_count_acc` | PCIe NAC sent count accumulated |
`pcie_nak_rcvd_count_acc` | PCIe NAC received count accumulated |
`jpeg_activity` | List of JPEG engine activity | %
@@ -5128,7 +5126,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5153,7 +5151,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5180,7 +5178,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5205,7 +5203,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5232,7 +5230,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5257,7 +5255,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5284,7 +5282,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5311,7 +5309,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpucore_handles()
if len(processor_handles) == 0:
print("No CPU cores on machine")
else:
@@ -5336,7 +5334,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5361,7 +5359,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5386,7 +5384,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5411,7 +5409,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5436,7 +5434,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5460,7 +5458,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5484,7 +5482,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpucore_handles()
if len(processor_handles) == 0:
print("No CPU cores on machine")
else:
@@ -5509,7 +5507,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5534,7 +5532,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpucore_handles()
if len(processor_handles) == 0:
print("No CPU cores on machine")
else:
@@ -5558,7 +5556,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5582,7 +5580,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5609,7 +5607,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5634,7 +5632,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5660,7 +5658,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5687,7 +5685,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5715,7 +5713,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5739,7 +5737,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5763,7 +5761,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5787,7 +5785,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5811,7 +5809,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5835,7 +5833,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5861,7 +5859,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5885,7 +5883,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5909,7 +5907,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5934,7 +5932,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5959,7 +5957,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -5984,7 +5982,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
@@ -6015,7 +6013,7 @@ Example:
```python
try:
processor_handles = amdsmi_get_processor_handles()
processor_handles = amdsmi_get_cpusocket_handles()
if len(processor_handles) == 0:
print("No CPU sockets on machine")
else:
py-interface/amdsmi_interface.py
+11 -8
Visa fil
@@ -1697,12 +1697,18 @@ def amdsmi_get_gpu_activity(
)
)
return {
activity_dict = {
"gfx_activity": engine_usage.gfx_activity,
"umc_activity": engine_usage.umc_activity,
"mm_activity": engine_usage.mm_activity,
}
for key, value in activity_dict.items():
if value == 0xFFFF:
activity_dict[key] = "N/A"
return activity_dict
def amdsmi_get_clock_info(
processor_handle: amdsmi_wrapper.amdsmi_processor_handle,
@@ -3290,8 +3296,6 @@ def amdsmi_get_gpu_metrics_info(
"current_socclks": list(gpu_metrics.current_socclks),
"current_vclk0s": list(gpu_metrics.current_vclk0s),
"current_dclk0s": list(gpu_metrics.current_dclk0s),
"mem_bandwidth_acc": gpu_metrics.mem_bandwidth_acc,
"mem_max_bandwidth": gpu_metrics.mem_max_bandwidth,
"pcie_nak_sent_count_acc": gpu_metrics.pcie_nak_sent_count_acc,
"pcie_nak_rcvd_count_acc": gpu_metrics.pcie_nak_rcvd_count_acc,
"jpeg_activity": list(gpu_metrics.jpeg_activity),
@@ -3313,8 +3317,7 @@ def amdsmi_get_gpu_metrics_info(
if gpu_metrics_output[value] == 0xFFFF:
gpu_metrics_output[value] = "N/A"
uint_32_values = ['gfx_activity_acc', 'mem_activity_acc', 'mem_max_bandwidth',
'pcie_nak_sent_count_acc', 'pcie_nak_rcvd_count_acc']
uint_32_values = ['gfx_activity_acc','mem_activity_acc', 'pcie_nak_sent_count_acc', 'pcie_nak_rcvd_count_acc']
for value in uint_32_values:
if gpu_metrics_output[value] == 0xFFFFFFFF:
@@ -3323,7 +3326,7 @@ def amdsmi_get_gpu_metrics_info(
uint_64_values = ['energy_accumulator', 'system_clock_counter', 'firmware_timestamp',
'pcie_bandwidth_acc', 'pcie_bandwidth_inst',
'pcie_l0_to_recov_count_acc', 'pcie_replay_count_acc',
'pcie_replay_rover_count_acc', 'mem_bandwidth_acc']
'pcie_replay_rover_count_acc']
for value in uint_64_values:
if gpu_metrics_output[value] == 0xFFFFFFFFFFFFFFFF:
@@ -3345,7 +3348,7 @@ def amdsmi_get_gpu_metrics_info(
gpu_metrics_output['indep_throttle_status'] = bool(gpu_metrics_output['indep_throttle_status'])
for idx, activity in enumerate(gpu_metrics_output['vcn_activity']):
if activity == 0xFFFF:
if activity == 0xFFFF or activity > 100:
gpu_metrics_output['vcn_activity'][idx] = "N/A"
if gpu_metrics_output['gfxclk_lock_status'] == 0xFFFFFFFF:
@@ -3378,7 +3381,7 @@ def amdsmi_get_gpu_metrics_info(
gpu_metrics_output['current_dclk0s'][idx] = "N/A"
for idx, activity in enumerate(gpu_metrics_output['jpeg_activity']):
if activity == 0xFFFF:
if activity == 0xFFFF or activity > 100:
gpu_metrics_output['jpeg_activity'][idx] = "N/A"
return gpu_metrics_output
py-interface/amdsmi_wrapper.py
+12 -238
Visa fil
@@ -1012,16 +1012,6 @@ amdsmi_process_handle_t = ctypes.c_uint32
class struct_amdsmi_proc_info_t(Structure):
pass
class struct_engine_usage_(Structure):
pass
struct_engine_usage_._pack_ = 1 # source:False
struct_engine_usage_._fields_ = [
('gfx', ctypes.c_uint64),
('enc', ctypes.c_uint64),
('reserved', ctypes.c_uint32 * 12),
]
class struct_memory_usage_(Structure):
pass
@@ -1033,6 +1023,16 @@ struct_memory_usage_._fields_ = [
('reserved', ctypes.c_uint32 * 10),
]
class struct_engine_usage_(Structure):
pass
struct_engine_usage_._pack_ = 1 # source:False
struct_engine_usage_._fields_ = [
('gfx', ctypes.c_uint64),
('enc', ctypes.c_uint64),
('reserved', ctypes.c_uint32 * 12),
]
struct_amdsmi_proc_info_t._pack_ = 1 # source:False
struct_amdsmi_proc_info_t._fields_ = [
('name', ctypes.c_char * 32),
@@ -1620,11 +1620,8 @@ struct_amdsmi_gpu_metrics_t._fields_ = [
('current_vclk0s', ctypes.c_uint16 * 4),
('current_dclk0s', ctypes.c_uint16 * 4),
('jpeg_activity', ctypes.c_uint16 * 32),
('mem_bandwidth_acc', ctypes.c_uint64),
('mem_max_bandwidth', ctypes.c_uint32),
('pcie_nak_sent_count_acc', ctypes.c_uint32),
('pcie_nak_rcvd_count_acc', ctypes.c_uint32),
('PADDING_4', ctypes.c_ubyte * 4),
]
amdsmi_gpu_metrics_t = struct_amdsmi_gpu_metrics_t
@@ -2182,173 +2179,6 @@ 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, ctypes.POINTER(ctypes.c_uint64)]
@@ -2690,59 +2520,7 @@ __all__ = \
'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_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_metrics_info',
'amdsmi_get_gpu_od_volt_curve_regions',
'amdsmi_get_gpu_od_volt_info', 'amdsmi_get_gpu_overdrive_level',
'amdsmi_get_gpu_pci_bandwidth',
@@ -2826,11 +2604,7 @@ __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', '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',
'amdsmi_xgmi_status_t', 'processor_type_t', 'size_t',
'struct__links', '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',
rocm_smi/src/rocm_smi.cc
+1 -1
Visa fil
@@ -736,7 +736,7 @@ rsmi_dev_ecc_count_get(uint32_t dv_ind, rsmi_gpu_block_t block,
DEVICE_MUTEX
ret = GetDevValueVec(type, dv_ind, &val_vec);
if (val_vec.size() != 2 ) ret = RSMI_STATUS_FILE_ERROR;
if (val_vec.size() < 2 ) ret = RSMI_STATUS_FILE_ERROR;
if (ret == RSMI_STATUS_FILE_ERROR || val_vec.size() != 2) {
ss << __PRETTY_FUNCTION__ << " | ======= end ======="
src/amd_smi/amd_smi.cc
-586
Visa fil
@@ -1140,10 +1140,6 @@ amdsmi_status_t amdsmi_get_gpu_metrics_info(
(sizeof(pgpu_metrics->jpeg_activity) /
sizeof(pgpu_metrics->jpeg_activity[0])),
std::numeric_limits<uint16_t>::max());
pgpu_metrics->mem_bandwidth_acc =
static_cast<uint64_t>(std::numeric_limits<uint64_t>::max());
pgpu_metrics->mem_max_bandwidth =
static_cast<uint32_t>(std::numeric_limits<uint32_t>::max());
pgpu_metrics->pcie_nak_sent_count_acc =
static_cast<uint32_t>(std::numeric_limits<uint32_t>::max());
pgpu_metrics->pcie_nak_rcvd_count_acc =
@@ -2123,588 +2119,6 @@ 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
static amdsmi_status_t amdsmi_errno_to_esmi_status(amdsmi_status_t status)
tests/amd_smi_test/functional/gpu_metrics_read.cc
+100 -751
Visa fil
@@ -135,65 +135,77 @@ void TestGpuMetricsRead::Run(void) {
<< smu.firmware_timestamp << '\n';
std::cout << "\n";
std::cout << "TEMPERATURES (C):\n";
std::cout << std::dec << "temperature_edge="
<< smu.temperature_edge << '\n';
std::cout << std::dec << "temperature_hotspot="
<< smu.temperature_hotspot << '\n';
std::cout << std::dec << "temperature_mem="
<< smu.temperature_mem << '\n';
std::cout << std::dec << "temperature_vrgfx="
<< smu.temperature_vrgfx << '\n';
std::cout << std::dec << "temperature_vrsoc="
<< smu.temperature_vrsoc << '\n';
std::cout << std::dec << "temperature_vrmem="
<< smu.temperature_vrmem << '\n';
std::cout << std::dec << "temperature_edge= "
<< static_cast<uint16_t>(smu.temperature_edge) << '\n';
std::cout << std::dec << "temperature_hotspot= "
<< static_cast<uint16_t>(smu.temperature_hotspot) << '\n';
std::cout << std::dec << "temperature_mem= "
<< static_cast<uint16_t>(smu.temperature_mem) << '\n';
std::cout << std::dec << "temperature_vrgfx= "
<< static_cast<uint16_t>(smu.temperature_vrgfx) << '\n';
std::cout << std::dec << "temperature_vrsoc= "
<< static_cast<uint16_t>(smu.temperature_vrsoc) << '\n';
std::cout << std::dec << "temperature_vrmem= "
<< static_cast<uint16_t>(smu.temperature_vrmem) << '\n';
for (int i = 0; i < AMDSMI_NUM_HBM_INSTANCES; ++i) {
std::cout << "temperature_hbm[" << i << "]=" << std::dec <<
smu.temperature_hbm[i] << '\n';
std::cout << "temperature_hbm[" << i << "]= " << std::dec
<< static_cast<uint16_t>(smu.temperature_hbm[i]) << '\n';
}
std::cout << "\n";
std::cout << "UTILIZATION (%):\n";
std::cout << std::dec << "average_gfx_activity="
<< smu.average_gfx_activity << '\n';
<< static_cast<uint16_t>(smu.average_gfx_activity) << '\n';
std::cout << std::dec << "average_umc_activity="
<< smu.average_umc_activity << '\n';
<< static_cast<uint16_t>(smu.average_umc_activity) << '\n';
std::cout << std::dec << "average_mm_activity="
<< smu.average_mm_activity << '\n';
std::cout << std::dec << "jpeg_activity= [";
<< static_cast<uint16_t>(smu.average_mm_activity) << '\n';
std::cout << std::dec << "vcn_activity= [";
uint16_t size = static_cast<uint16_t>(
sizeof(smu.vcn_activity)/sizeof(smu.vcn_activity[0]));
for (uint16_t i= 0; i < size; i++) {
if (i+1 < size) {
std::cout << std::dec << static_cast<uint16_t>(smu.vcn_activity[i]) << ", ";
} else {
std::cout << std::dec << static_cast<uint16_t>(smu.vcn_activity[i]);
}
}
std::cout << std::dec << "]\n";
std::cout << "\n";
std::cout << std::dec << "jpeg_activity= [";
size = static_cast<uint16_t>(
sizeof(smu.jpeg_activity)/sizeof(smu.jpeg_activity[0]));
for (uint16_t i= 0; i < size; i++) {
if (i+1 < size) {
std::cout << std::dec << smu.jpeg_activity[i] << ", ";
std::cout << std::dec << static_cast<uint16_t>(smu.jpeg_activity[i]) << ", ";
} else {
std::cout << std::dec << smu.jpeg_activity[i];
std::cout << std::dec << static_cast<uint16_t>(smu.jpeg_activity[i]);
}
}
std::cout << std::dec << "]\n";
std::cout << "\n";
std::cout << "POWER (W)/ENERGY (15.259uJ per 1ns):\n";
std::cout << std::dec << "average_socket_power="
<< smu.average_socket_power << '\n';
<< static_cast<uint16_t>(smu.average_socket_power) << '\n';
std::cout << std::dec << "current_socket_power="
<< smu.current_socket_power << '\n';
<< static_cast<uint16_t>(smu.current_socket_power) << '\n';
std::cout << std::dec << "energy_accumulator="
<< smu.energy_accumulator << '\n';
<< static_cast<uint16_t>(smu.energy_accumulator) << '\n';
std::cout << "\n";
std::cout << "AVG CLOCKS (MHz):\n";
std::cout << std::dec << "average_gfxclk_frequency="
<< smu.average_gfxclk_frequency << '\n';
<< static_cast<uint16_t>(smu.average_gfxclk_frequency) << '\n';
std::cout << std::dec << "average_gfxclk_frequency="
<< smu.average_gfxclk_frequency << '\n';
<< static_cast<uint16_t>(smu.average_gfxclk_frequency) << '\n';
std::cout << std::dec << "average_uclk_frequency="
<< smu.average_uclk_frequency << '\n';
<< static_cast<uint16_t>(smu.average_uclk_frequency) << '\n';
std::cout << std::dec << "average_vclk0_frequency="
<< smu.average_vclk0_frequency << '\n';
<< static_cast<uint16_t>(smu.average_vclk0_frequency) << '\n';
std::cout << std::dec << "average_dclk0_frequency="
<< smu.average_dclk0_frequency << '\n';
<< static_cast<uint16_t>(smu.average_dclk0_frequency) << '\n';
std::cout << std::dec << "average_vclk1_frequency="
<< smu.average_vclk1_frequency << '\n';
<< static_cast<uint16_t>(smu.average_vclk1_frequency) << '\n';
std::cout << std::dec << "average_dclk1_frequency="
<< smu.average_dclk1_frequency << '\n';
<< static_cast<uint16_t>(smu.average_dclk1_frequency) << '\n';
std::cout << "\n";
std::cout << "CURRENT CLOCKS (MHz):\n";
std::cout << std::dec << "current_gfxclk="
@@ -203,9 +215,9 @@ void TestGpuMetricsRead::Run(void) {
sizeof(smu.current_gfxclks)/sizeof(smu.current_gfxclks[0]));
for (uint16_t i= 0; i < size; i++) {
if (i+1 < size) {
std::cout << std::dec << smu.current_gfxclks[i] << ", ";
std::cout << std::dec << static_cast<uint16_t>(smu.current_gfxclks[i]) << ", ";
} else {
std::cout << std::dec << smu.current_gfxclks[i];
std::cout << std::dec << static_cast<uint16_t>(smu.current_gfxclks[i]);
}
}
std::cout << std::dec << "]\n";
@@ -216,24 +228,24 @@ void TestGpuMetricsRead::Run(void) {
sizeof(smu.current_socclks)/sizeof(smu.current_socclks[0]));
for (uint16_t i= 0; i < size; i++) {
if (i+1 < size) {
std::cout << std::dec << smu.current_socclks[i] << ", ";
std::cout << std::dec << static_cast<uint16_t>(smu.current_socclks[i]) << ", ";
} else {
std::cout << std::dec << smu.current_socclks[i];
std::cout << std::dec << static_cast<uint16_t>(smu.current_socclks[i]);
}
}
std::cout << std::dec << "]\n";
std::cout << std::dec << "current_uclk="
<< smu.current_uclk << '\n';
<< static_cast<uint16_t>(smu.current_uclk) << '\n';
std::cout << std::dec << "current_vclk0="
<< smu.current_vclk0 << '\n';
<< static_cast<uint16_t>(smu.current_vclk0) << '\n';
std::cout << std::dec << "current_vclk0s= [";
size = static_cast<uint16_t>(
sizeof(smu.current_vclk0s)/sizeof(smu.current_vclk0s[0]));
for (uint16_t i= 0; i < size; i++) {
if (i+1 < size) {
std::cout << std::dec << smu.current_vclk0s[i] << ", ";
std::cout << std::dec << static_cast<uint16_t>(smu.current_vclk0s[i]) << ", ";
} else {
std::cout << std::dec << smu.current_vclk0s[i];
std::cout << std::dec << static_cast<uint16_t>(smu.current_vclk0s[i]);
}
}
std::cout << std::dec << "]\n";
@@ -244,24 +256,24 @@ void TestGpuMetricsRead::Run(void) {
sizeof(smu.current_dclk0s)/sizeof(smu.current_dclk0s[0]));
for (uint16_t i= 0; i < size; i++) {
if (i+1 < size) {
std::cout << std::dec << smu.current_dclk0s[i] << ", ";
std::cout << std::dec << static_cast<uint16_t>(smu.current_dclk0s[i]) << ", ";
} else {
std::cout << std::dec << smu.current_dclk0s[i];
std::cout << std::dec << static_cast<uint16_t>(smu.current_dclk0s[i]);
}
}
std::cout << std::dec << "]\n";
std::cout << std::dec << "current_vclk1="
<< smu.current_vclk1 << '\n';
<< static_cast<uint16_t>(smu.current_vclk1) << '\n';
std::cout << std::dec << "current_dclk1="
<< smu.current_dclk1 << '\n';
<< static_cast<uint16_t>(smu.current_dclk1) << '\n';
std::cout << "\n";
std::cout << "TROTTLE STATUS:\n";
std::cout << std::dec << "throttle_status="
<< smu.throttle_status << '\n';
<< static_cast<uint32_t>(smu.throttle_status) << '\n';
std::cout << "\n";
std::cout << "FAN SPEED:\n";
std::cout << std::dec << "current_fan_speed="
<< smu.current_fan_speed << '\n';
<< static_cast<uint16_t>(smu.current_fan_speed) << '\n';
std::cout << "\n";
std::cout << "LINK WIDTH (number of lanes) /SPEED (0.1 GT/s):\n";
std::cout << "pcie_link_width="
@@ -276,9 +288,9 @@ void TestGpuMetricsRead::Run(void) {
std::cout << "\n";
std::cout << "Utilization Accumulated(%):\n";
std::cout << "gfx_activity_acc="
<< std::dec << smu.gfx_activity_acc << '\n';
<< std::dec << static_cast<uint32_t>(smu.gfx_activity_acc) << '\n';
std::cout << "mem_activity_acc="
<< std::dec << smu.mem_activity_acc << '\n';
<< std::dec << static_cast<uint32_t>(smu.mem_activity_acc) << '\n';
std::cout << "\n";
std::cout << "XGMI ACCUMULATED DATA TRANSFER SIZE (KB):\n";
@@ -287,9 +299,9 @@ void TestGpuMetricsRead::Run(void) {
sizeof(smu.xgmi_read_data_acc)/sizeof(smu.xgmi_read_data_acc[0]));
for (uint16_t i= 0; i < size; i++) {
if (i+1 < size) {
std::cout << std::dec << smu.xgmi_read_data_acc[i] << ", ";
std::cout << std::dec << static_cast<uint64_t>(smu.xgmi_read_data_acc[i]) << ", ";
} else {
std::cout << std::dec << smu.xgmi_read_data_acc[i];
std::cout << std::dec << static_cast<uint64_t>(smu.xgmi_read_data_acc[i]);
}
}
std::cout << std::dec << "]\n";
@@ -298,718 +310,55 @@ void TestGpuMetricsRead::Run(void) {
sizeof(smu.xgmi_write_data_acc)/sizeof(smu.xgmi_write_data_acc[0]));
for (uint16_t i= 0; i < size; i++) {
if (i+1 < size) {
std::cout << std::dec << smu.xgmi_write_data_acc[i] << ", ";
std::cout << std::dec << static_cast<uint64_t>(smu.xgmi_write_data_acc[i]) << ", ";
} else {
std::cout << std::dec << smu.xgmi_write_data_acc[i];
std::cout << std::dec << static_cast<uint64_t>(smu.xgmi_write_data_acc[i]);
}
}
std::cout << std::dec << "]\n";
std::cout << "mem_bandwidth_acc=" << std::dec
<< smu.mem_bandwidth_acc << "\n";
std::cout << "mem_max_bandwidth=" << std::dec
<< smu.mem_max_bandwidth << "\n";
std::cout << "pcie_nak_sent_count_acc=" << std::dec
<< smu.pcie_nak_sent_count_acc << "\n";
std::cout << "pcie_nak_rcvd_count_acc=" << std::dec
<< smu.pcie_nak_rcvd_count_acc << "\n";
// Voltage (mV)
std::cout << "voltage_soc = "
<< std::dec << static_cast<uint16_t>(smu.voltage_soc) << "\n";
std::cout << "voltage_soc = "
<< std::dec << static_cast<uint16_t>(smu.voltage_gfx) << "\n";
std::cout << "voltage_mem = "
<< std::dec << static_cast<uint16_t>(smu.voltage_mem) << "\n";
std::cout << "indep_throttle_status = "
<< std::dec << static_cast<uint64_t>(smu.indep_throttle_status) << "\n";
// Clock Lock Status. Each bit corresponds to clock instance
std::cout << "gfxclk_lock_status (in hex) = "
<< std::hex << static_cast<uint32_t>(smu.gfxclk_lock_status) << std::dec <<"\n";
// Bandwidth (GB/sec)
std::cout << "pcie_bandwidth_acc=" << std::dec
<< static_cast<uint64_t>(smu.pcie_bandwidth_acc) << "\n";
std::cout << "pcie_bandwidth_inst=" << std::dec
<< static_cast<uint64_t>(smu.pcie_bandwidth_inst) << "\n";
// Counts
std::cout << "pcie_l0_to_recov_count_acc= " << std::dec
<< static_cast<uint64_t>(smu.pcie_l0_to_recov_count_acc) << "\n";
std::cout << "pcie_replay_count_acc= " << std::dec
<< static_cast<uint64_t>(smu.pcie_replay_count_acc) << "\n";
std::cout << "pcie_replay_rover_count_acc= " << std::dec
<< static_cast<uint64_t>(smu.pcie_replay_rover_count_acc) << "\n";
std::cout << "pcie_nak_rcvd_count_acc= " << std::dec
<< static_cast<uint32_t>(smu.pcie_nak_rcvd_count_acc) << "\n";
std::cout << "pcie_replay_rover_count_acc= " << std::dec
<< static_cast<uint64_t>(smu.pcie_replay_rover_count_acc) << "\n";
}
}
// Verify api support checking functionality is working
err = amdsmi_get_gpu_metrics_info(processor_handles_[i], nullptr);
DISPLAY_AMDSMI_ERR(err);
if (err !=AMDSMI_STATUS_INVAL) {
DISPLAY_AMDSMI_ERR(err);
}
amdsmi_status_code_to_string(err, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_info(nullptr check): " << status_string << "\n";
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]);
std::cout << "Device #" << std::to_string(i) << "\n";
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_temp_edge(): " << status_string << "\n";
}
auto temp_hotspot_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_temp_hotspot(processor_handles_[i], &temp_hotspot_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_temp_hotspot(): " << status_string << "\n";
}
auto temp_mem_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_temp_mem(processor_handles_[i], &temp_mem_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_temp_mem(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_temp_vrgfx(): " << status_string << "\n";
}
auto temp_vrsoc_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_temp_vrsoc(processor_handles_[i], &temp_vrsoc_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_temp_vrsoc(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_temp_vrmem(): " << status_string << "\n";
}
gpu_metric_temp_hbm_t temp_hbm_values;
status_code = amdsmi_get_gpu_metrics_temp_hbm(processor_handles_[i], &temp_hbm_values);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_temp_hbm(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_curr_socket_power(): " << status_string << "\n";
}
auto temp_energy_accum_value = val_ui64;
status_code = amdsmi_get_gpu_metrics_energy_acc(processor_handles_[i], &temp_energy_accum_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_energy_acc(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_temp_edge(): " << status_string << "\n";
}
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);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_avg_gfx_activity(): " << status_string << "\n";
}
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);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_avg_umc_activity(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_avg_mm_activity(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_vcn_activity(): " << status_string << "\n";
}
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);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_mem_activity_acc(): " << status_string << "\n";
}
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);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_gfx_activity_acc(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_avg_gfx_clock_frequency(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_avg_soc_clock_frequency(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_avg_uclock_frequency(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_avg_vclock0_frequency(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_avg_dclock0_frequency(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_avg_vclock1_frequency(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_avg_dclock1_frequency(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_curr_vclk1(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_curr_dclk1(): " << status_string << "\n";
}
auto temp_curr_uclk_value = val_ui16;
status_code = amdsmi_get_gpu_metrics_curr_uclk(processor_handles_[i], &temp_curr_uclk_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_curr_uclk(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_curr_dclk0(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_curr_gfxclk(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_curr_socclk(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_curr_vclk0(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_indep_throttle_status(): " << status_string << "\n";
}
auto temp_throttle_status_value = val_ui32;
status_code = amdsmi_get_gpu_metrics_throttle_status(processor_handles_[i], &temp_throttle_status_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_throttle_status(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_gfxclk_lock_status(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_curr_fan_speed(): " << status_string << "\n";
}
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);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_pcie_link_width(): " << status_string << "\n";
}
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);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_pcie_link_speed(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_pcie_bandwidth_acc(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_pcie_bandwidth_inst(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_pcie_l0_recov_count_acc(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_pcie_replay_count_acc(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_pcie_replay_rover_count_acc(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_xgmi_link_width(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_xgmi_link_speed(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_xgmi_read_data(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_xgmi_write_data(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_volt_soc(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_volt_gfx(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_volt_mem(): " << status_string << "\n";
}
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);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_system_clock_counter(): " << status_string << "\n";
}
auto temp_firmware_timestamp_value = val_ui64;
status_code = amdsmi_get_gpu_metrics_firmware_timestamp(processor_handles_[i], &temp_firmware_timestamp_value);
if (status_code != AMDSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_firmware_timestamp(): " << status_string << "\n";
}
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);
} else {
const char *status_string;
amdsmi_status_code_to_string(status_code, &status_string);
std::cout << "\t\t** amdsmi_get_gpu_metrics_xcd_counter(): " << status_string << "\n";
}
IF_VERB(STANDARD) {
std::cout << "\n";
std::cout << "\t[Temperature]" << "\n";
std::cout << "\t -> temp_edge(): " << std::dec << temp_edge_value << "\n";
std::cout << "\t -> temp_hotspot(): " << std::dec << temp_hotspot_value << "\n";
std::cout << "\t -> temp_mem(): " << std::dec << temp_mem_value << "\n";
std::cout << "\t -> temp_vrgfx(): " << std::dec << temp_vrgfx_value << "\n";
std::cout << "\t -> temp_vrsoc(): " << std::dec << temp_vrsoc_value << "\n";
std::cout << "\t -> temp_vrmem(): " << std::dec << temp_vrmem_value << "\n";
std::cout << "\t -> temp_hbm(temp_hbm_values): [";
uint16_t size = static_cast<uint16_t>(
sizeof(temp_hbm_values) / sizeof(temp_hbm_values[0]));
for (uint16_t i = 0; i < size; i++) {
if (i + 1 < size) {
std::cout << std::dec << temp_hbm_values[i] << ", ";
} else {
std::cout << std::dec << temp_hbm_values[i];
}
}
std::cout << std::dec << "]\n";
std::cout << "\n";
std::cout << "\t[Power/Energy]" << "\n";
std::cout << "\t -> current_socket_power(): " << std::dec << temp_curr_socket_power_value << "\n";
std::cout << "\t -> energy_accum(): " << std::dec << temp_energy_accum_value << "\n";
std::cout << "\t -> average_socket_power(): " << std::dec << temp_avg_socket_power_value << "\n";
std::cout << "\n";
std::cout << "\t[Utilization]" << "\n";
std::cout << "\t -> average_gfx_activity(): " << std::dec << temp_avg_gfx_activity_value << "\n";
std::cout << "\t -> average_umc_activity(): " << std::dec << temp_avg_umc_activity_value << "\n";
std::cout << "\t -> average_mm_activity(): " << std::dec << temp_avg_mm_activity_value << "\n";
std::cout << "\t -> vcn_activity(temp_vcn_values): [";
size = static_cast<uint16_t>(
sizeof(temp_vcn_values) / sizeof(temp_vcn_values[0]));
for (uint16_t i = 0; i < size; i++) {
if (i + 1 < size) {
std::cout << std::dec << temp_vcn_values[i] << ", ";
} else {
std::cout << std::dec << temp_vcn_values[i];
}
}
std::cout << std::dec << "]\n";
std::cout << "\t -> mem_activity_accum(): " << std::dec << temp_mem_activity_accum_value << "\n";
std::cout << "\t -> gfx_activity_accum(): " << std::dec << temp_gfx_activity_accum_value << "\n";
std::cout << "\n";
std::cout << "\t[Average Clock]" << "\n";
std::cout << "\t -> average_gfx_clock_frequency(): " << std::dec << temp_avg_gfx_clock_freq_value << "\n";
std::cout << "\t -> average_soc_clock_frequency(): " << std::dec << temp_avg_soc_clock_freq_value << "\n";
std::cout << "\t -> average_uclock_frequency(): " << std::dec << temp_avg_uclock_freq_value << "\n";
std::cout << "\t -> average_vclock0_frequency(): " << std::dec << std::dec << temp_avg_vclock0_freq_value << "\n";
std::cout << "\t -> average_dclock0_frequency(): " << std::dec << temp_avg_dclock0_freq_value << "\n";
std::cout << "\t -> average_vclock1_frequency(): " << std::dec << temp_avg_vclock1_freq_value << "\n";
std::cout << "\t -> average_dclock1_frequency(): " << std::dec << temp_avg_dclock1_freq_value << "\n";
std::cout << "\n";
std::cout << "\t[Current Clock]" << "\n";
std::cout << "\t -> current_vclock1(): " << std::dec << temp_curr_vclk1_value << "\n";
std::cout << "\t -> current_dclock1(): " << std::dec << temp_curr_dclk1_value << "\n";
std::cout << "\t -> current_uclock(): " << std::dec << temp_curr_uclk_value << "\n";
std::cout << "\t -> current_dclk0(temp_curr_dclk0_values): [";
size = static_cast<uint16_t>(
sizeof(temp_curr_dclk0_values) / sizeof(temp_curr_dclk0_values[0]));
for (uint16_t i = 0; i < size; i++) {
if (i + 1 < size) {
std::cout << std::dec << temp_curr_dclk0_values[i] << ", ";
} else {
std::cout << std::dec << temp_curr_dclk0_values[i];
}
}
std::cout << std::dec << "]\n";
std::cout << "\t -> current_gfxclk(temp_curr_gfxclk_values): [";
size = static_cast<uint16_t>(
sizeof(temp_curr_gfxclk_values) / sizeof(temp_curr_gfxclk_values[0]));
for (uint16_t i = 0; i < size; i++) {
if (i + 1 < size) {
std::cout << std::dec << temp_curr_gfxclk_values[i] << ", ";
} else {
std::cout << std::dec << temp_curr_gfxclk_values[i];
}
}
std::cout << std::dec << "]\n";
std::cout << "\t -> current_soc_clock(temp_curr_socclk_values): [";
size = static_cast<uint16_t>(
sizeof(temp_curr_socclk_values) / sizeof(temp_curr_socclk_values[0]));
for (uint16_t i = 0; i < size; i++) {
if (i + 1 < size) {
std::cout << std::dec << temp_curr_socclk_values[i] << ", ";
} else {
std::cout << std::dec << temp_curr_socclk_values[i];
}
}
std::cout << std::dec << "]\n";
std::cout << "\t -> current_vclk0(temp_curr_vclk0_values): [";
size = static_cast<uint16_t>(
sizeof(temp_curr_vclk0_values) / sizeof(temp_curr_vclk0_values[0]));
for (uint16_t i = 0; i < size; i++) {
if (i + 1 < size) {
std::cout << std::dec << temp_curr_vclk0_values[i] << ", ";
} else {
std::cout << std::dec << temp_curr_vclk0_values[i];
}
}
std::cout << std::dec << "]\n";
std::cout << "\n";
std::cout << "\t[Throttle]" << "\n";
std::cout << "\t -> indep_throttle_status(): " << std::dec << temp_indep_throttle_status_value << "\n";
std::cout << "\t -> throttle_status(): " << std::dec << temp_throttle_status_value << "\n";
std::cout << "\n";
std::cout << "\t[Gfx Clock Lock]" << "\n";
std::cout << "\t -> gfxclk_lock_status(): " << std::dec << temp_gfxclk_lock_status_value << "\n";
std::cout << "\n";
std::cout << "\t[Current Fan Speed]" << "\n";
std::cout << "\t -> current_fan_speed(): " << std::dec << temp_curr_fan_speed_value << "\n";
std::cout << "\n";
std::cout << "\t[Link/Bandwidth/Speed]" << "\n";
std::cout << "\t -> pcie_link_width(): " << std::dec << temp_pcie_link_width_value << "\n";
std::cout << "\t -> pcie_link_speed(): " << std::dec << temp_pcie_link_speed_value << "\n";
std::cout << "\t -> pcie_bandwidth_accum(): " << std::dec << std::dec << temp_pcie_bandwidth_accum_value << "\n";
std::cout << "\t -> pcie_bandwidth_inst(): " << std::dec << temp_pcie_bandwidth_inst_value << "\n";
std::cout << "\t -> pcie_l0_recov_count_accum(): " << std::dec << std::dec << temp_pcie_l0_recov_count_accum_value << "\n";
std::cout << "\t -> pcie_replay_count_accum(): " << std::dec << temp_pcie_replay_count_accum_value << "\n";
std::cout << "\t -> pcie_replay_rollover_count_accum(): " << std::dec << temp_pcie_replay_rover_count_accum_value << "\n";
std::cout << "\t -> xgmi_link_width(): " << std::dec << temp_xgmi_link_width_value << "\n";
std::cout << "\t -> xgmi_link_speed(): " << std::dec << std::dec << temp_xgmi_link_speed_value << "\n";
std::cout << "\t -> xgmi_read_data(temp_xgmi_read_values): ";
size = static_cast<uint16_t>(
sizeof(temp_xgmi_read_values) / sizeof(temp_xgmi_read_values[0]));
for (uint16_t i = 0; i < size; i++) {
if (i + 1 < size) {
std::cout << std::dec << temp_xgmi_read_values[i] << ", ";
} else {
std::cout << std::dec << temp_xgmi_read_values[i];
}
}
std::cout << std::dec << "]\n";
std::cout << "\t -> xgmi_write_data(temp_xgmi_write_values): [";
size = static_cast<uint16_t>(
sizeof(temp_xgmi_write_values) / sizeof(temp_xgmi_write_values[0]));
for (uint16_t i = 0; i < size; i++) {
if (i + 1 < size) {
std::cout << std::dec << temp_xgmi_write_values[i] << ", ";
} else {
std::cout << std::dec << temp_xgmi_write_values[i];
}
}
std::cout << std::dec << "]\n";
std::cout << "\n";
std::cout << "\t[Voltage]" << "\n";
std::cout << "\t -> voltage_soc(): " << std::dec << temp_voltage_soc_value << "\n";
std::cout << "\t -> voltage_gfx(): " << std::dec << temp_voltage_gfx_value << "\n";
std::cout << "\t -> voltage_mem(): " << std::dec << temp_voltage_mem_value << "\n";
std::cout << "\n";
std::cout << "\t[Timestamp]" << "\n";
std::cout << "\t -> system_clock_counter(): " << std::dec << temp_system_clock_counter_value << "\n";
std::cout << "\t -> firmware_timestamp(): " << std::dec << temp_firmware_timestamp_value << "\n";
std::cout << "\n";
std::cout << "\t[XCD Counter]" << "\n";
std::cout << "\t -> xcd_counter(): " << std::dec << temp_xcd_counter_value << "\n";
std::cout << "\n\n";
}
}
}