From 6f778a4c628da3e4958fa9c4b03177827e7d0eb8 Mon Sep 17 00:00:00 2001 From: Maisam Arif Date: Wed, 6 Dec 2023 16:57:26 -0600 Subject: [PATCH] SWDEV-413122 - Initial Monitor subcommand Change-Id: Iaeaef77efeaa4289b19f1f676dcae6245f0e0c9e [ROCm/amdsmi commit: f91fc97fedd0cf56b6a22987f956816136e49974] --- projects/amdsmi/amdsmi_cli/amdsmi_cli.py | 1 + projects/amdsmi/amdsmi_cli/amdsmi_commands.py | 349 ++++++++++++++++++ projects/amdsmi/amdsmi_cli/amdsmi_logger.py | 55 ++- projects/amdsmi/amdsmi_cli/amdsmi_parser.py | 52 ++- .../amdsmi/py-interface/amdsmi_interface.py | 18 +- 5 files changed, 457 insertions(+), 18 deletions(-) diff --git a/projects/amdsmi/amdsmi_cli/amdsmi_cli.py b/projects/amdsmi/amdsmi_cli/amdsmi_cli.py index 3bafe179ca..263bd0c794 100755 --- a/projects/amdsmi/amdsmi_cli/amdsmi_cli.py +++ b/projects/amdsmi/amdsmi_cli/amdsmi_cli.py @@ -68,6 +68,7 @@ if __name__ == "__main__": amd_smi_commands.topology, amd_smi_commands.set_value, amd_smi_commands.reset, + amd_smi_commands.monitor, amd_smi_commands.rocm_smi) try: try: diff --git a/projects/amdsmi/amdsmi_cli/amdsmi_commands.py b/projects/amdsmi/amdsmi_cli/amdsmi_commands.py index c09b1633b9..21145bc272 100644 --- a/projects/amdsmi/amdsmi_cli/amdsmi_commands.py +++ b/projects/amdsmi/amdsmi_cli/amdsmi_commands.py @@ -2254,6 +2254,355 @@ class AMDSMICommands(): self.logger.print_output() + def monitor(self, args, multiple_devices=False, watching_output=False, gpu=None, + watch=None, watch_time=None, iterations=None, power_usage=None, + temperature=None, gfx_util=None, mem_util=None, encoder=None, decoder=None, + throttle_status=None, ecc=None, vram_usage=None, pcie=None): + """ Populate a table with each GPU as an index to rows of targeted data + + Args: + args (Namespace): Namespace containing the parsed CLI args + multiple_devices (bool, optional): True if checking for multiple devices. Defaults to False. + gpu (device_handle, optional): device_handle for target device. Defaults to None. + watch (bool, optional): Value override for args.watch. Defaults to None. + watch_time (int, optional): Value override for args.watch_time. Defaults to None. + iterations (int, optional): Value override for args.iterations. Defaults to None. + power_usage (bool, optional): Value override for args.power_usage. Defaults to None. + temperature (bool, optional): Value override for args.temperature. Defaults to None. + gfx (bool, optional): Value override for args.gfx. Defaults to None. + mem (bool, optional): Value override for args.mem. Defaults to None. + encoder (bool, optional): Value override for args.encoder. Defaults to None. + decoder (bool, optional): Value override for args.decoder. Defaults to None. + throttle_status (bool, optional): Value override for args.throttle_status. Defaults to None. + ecc (bool, optional): Value override for args.ecc. Defaults to None. + vram_usage (bool, optional): Value override for args.vram_usage. Defaults to None. + pcie (bool, optional): Value override for args.pcie. Defaults to None. + + Raises: + ValueError: Value error if no gpu value is provided + IndexError: Index error if gpu list is empty + + Return: + Nothing + """ + # Set args.* to passed in arguments + if gpu: + args.gpu = gpu + if watch: + args.watch = watch + if watch_time: + args.watch_time = watch_time + if iterations: + args.iterations = iterations + + # monitor args + if power_usage: + args.power_usage = power_usage + if temperature: + args.temperature = temperature + if gfx_util: + args.gfx = gfx_util + if mem_util: + args.mem = mem_util + if encoder: + args.encoder = encoder + if decoder: + args.decoder = decoder + if throttle_status: + args.throttle_status = throttle_status + if ecc: + args.ecc = ecc + if vram_usage: + args.vram_usage = vram_usage + if pcie: + args.pcie = pcie + + # Handle No GPU passed + if args.gpu == None: + args.gpu = self.device_handles + + # If all arguments are False, the print all values + if not any([args.power_usage, args.temperature, args.gfx, args.mem, + args.encoder, args.decoder, args.throttle_status, args.ecc, + args.vram_usage, args.pcie]): + args.power_usage = args.temperature = args.gfx = args.mem = \ + args.encoder = args.decoder = args.throttle_status = args.ecc = \ + args.vram_usage = args.pcie = True + + # Handle watch logic, will only enter this block once + if args.watch: + self.helpers.handle_watch(args=args, subcommand=self.monitor, logger=self.logger) + return + + # Handle multiple GPUs + if isinstance(args.gpu, list): + if len(args.gpu) > 1: + # Deepcopy gpus as recursion will destroy the gpu list + stored_gpus = [] + for gpu in args.gpu: + stored_gpus.append(gpu) + + # Store output from multiple devices + for device_handle in args.gpu: + self.monitor(args, multiple_devices=True, watching_output=watching_output, gpu=device_handle) + + # Reload original gpus + args.gpu = stored_gpus + + # Print multiple device output + self.logger.print_output(multiple_device_enabled=True, watching_output=watching_output, tabular=True) + + # Add output to total watch output and clear multiple device output + if watching_output: + self.logger.store_watch_output(multiple_device_enabled=True) + + # Flush the watching output + self.logger.print_output(multiple_device_enabled=True, watching_output=watching_output, tabular=True) + + return + elif len(args.gpu) == 1: + args.gpu = args.gpu[0] + else: + raise IndexError("args.gpu should not be an empty list") + + monitor_values = {} + + # Get gpu_id for logging + gpu_id = self.helpers.get_gpu_id_from_device_handle(args.gpu) + + # Clear the table header; TODO make this a function + self.logger.table_header = '' + + # Store timestamp for watch output + if watching_output: + self.logger.store_output(args.gpu, 'timestamp', int(time.time())) + self.logger.table_header += 'TIMESTAMP'.rjust(10) + + self.logger.table_header += 'GPU'.rjust(3) + + if args.power_usage: + try: + gpu_metrics_info = amdsmi_interface.amdsmi_get_gpu_metrics_info(args.gpu) + power_usage = gpu_metrics_info['current_socket_power'] + if power_usage >= 0xFFFFFFFF: + power_usage = gpu_metrics_info['average_socket_power'] + if power_usage >= 0xFFFFFFFF: + power_usage = "N/A" + monitor_values['power_usage'] = power_usage + if self.logger.is_human_readable_format() and monitor_values['power_usage'] != "N/A": + monitor_values['power_usage'] = f"{monitor_values['power_usage']} W" + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['power_usage'] = "N/A" + logging.debug("Failed to get power usage on gpu %s | %s", gpu_id, e.get_error_info()) + + self.logger.table_header += 'POWER'.rjust(7) + if args.temperature: + try: + temperature = amdsmi_interface.amdsmi_get_gpu_metrics_info(args.gpu)['temperature_hotspot'] + monitor_values['hotspot_temperature'] = temperature + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['hotspot_temperature'] = "N/A" + logging.debug("Failed to get hotspot temperature on gpu %s | %s", gpu_id, e.get_error_info()) + + try: + temperature = amdsmi_interface.amdsmi_get_gpu_metrics_temp_mem(args.gpu) + monitor_values['memory_temperature'] = temperature + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['memory_temperature'] = "N/A" + logging.debug("Failed to get memory temperature on gpu %s | %s", gpu_id, e.get_error_info()) + + if self.logger.is_human_readable_format() and monitor_values['hotspot_temperature'] != "N/A": + monitor_values['hotspot_temperature'] = f"{monitor_values['hotspot_temperature']} \N{DEGREE SIGN}C" + + if self.logger.is_human_readable_format() and monitor_values['memory_temperature'] != "N/A": + monitor_values['memory_temperature'] = f"{monitor_values['memory_temperature']} \N{DEGREE SIGN}C" + + self.logger.table_header += 'GPU_TEMP'.rjust(10) + self.logger.table_header += 'MEM_TEMP'.rjust(10) + if args.gfx: + try: + gfx_util = amdsmi_interface.amdsmi_get_gpu_metrics_avg_gfx_activity(args.gpu) + monitor_values['gfx'] = gfx_util + if self.logger.is_human_readable_format(): + monitor_values['gfx'] = f"{monitor_values['gfx']} %" + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['gfx'] = "N/A" + logging.debug("Failed to get gfx utilization on gpu %s | %s", gpu_id, e.get_error_info()) + + self.logger.table_header += 'GFX_UTIL'.rjust(10) + + try: + gfx_clock = amdsmi_interface.amdsmi_get_gpu_metrics_info(args.gpu)['current_gfxclk'] + monitor_values['gfx_clock'] = gfx_clock + if self.logger.is_human_readable_format(): + monitor_values['gfx_clock'] = f"{monitor_values['gfx_clock']} MHz" + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['gfx_clock'] = "N/A" + logging.debug("Failed to get gfx clock on gpu %s | %s", gpu_id, e.get_error_info()) + + self.logger.table_header += 'GFX_CLOCK'.rjust(11) + if args.mem: + try: + mem_util = amdsmi_interface.amdsmi_get_gpu_metrics_avg_umc_activity(args.gpu) + monitor_values['mem'] = mem_util + if self.logger.is_human_readable_format(): + monitor_values['mem'] = f"{monitor_values['mem']} %" + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['mem'] = "N/A" + logging.debug("Failed to get mem utilization on gpu %s | %s", gpu_id, e.get_error_info()) + + self.logger.table_header += 'MEM_UTIL'.rjust(10) + + try: + mem_clock = amdsmi_interface.amdsmi_get_gpu_metrics_info(args.gpu)['current_uclk'] + monitor_values['mem_clock'] = mem_clock + if self.logger.is_human_readable_format(): + monitor_values['mem_clock'] = f"{monitor_values['mem_clock']} MHz" + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['mem_clock'] = "N/A" + logging.debug("Failed to get mem clock on gpu %s | %s", gpu_id, e.get_error_info()) + + self.logger.table_header += 'MEM_CLOCK'.rjust(11) + if args.encoder: + try: + # Get List of vcn activity values + encoder_util = amdsmi_interface.amdsmi_get_gpu_metrics_vcn_activity(args.gpu) + encoding_activity_avg = [] + for value in encoder_util: + if value < 150: # each encoder chiplet's value range should be a percent + encoding_activity_avg.append(value) + # Averaging the possible encoding activity values + if encoding_activity_avg: + encoding_activity_avg = sum(encoding_activity_avg) / len(encoding_activity_avg) + else: + encoding_activity_avg = "N/A" + monitor_values['encoder'] = encoding_activity_avg + if self.logger.is_human_readable_format() and monitor_values['encoder'] != "N/A": + monitor_values['encoder'] = f"{monitor_values['encoder']} %" + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['encoder'] = "N/A" + logging.debug("Failed to get encoder utilization on gpu %s | %s", gpu_id, e.get_error_info()) + + self.logger.table_header += 'ENC_UTIL'.rjust(10) + + try: + encoder_clock = amdsmi_interface.amdsmi_get_gpu_metrics_info(args.gpu)['current_vclk0'] + monitor_values['encoder_clock'] = encoder_clock + if self.logger.is_human_readable_format(): + monitor_values['encoder_clock'] = f"{monitor_values['encoder_clock']} MHz" + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['encoder_clock'] = "N/A" + logging.debug("Failed to get encoder clock on gpu %s | %s", gpu_id, e.get_error_info()) + + self.logger.table_header += 'ENC_CLOCK'.rjust(11) + if args.decoder: + try: + decoder_util = "N/A" # Not yet implemented + monitor_values['decoder'] = decoder_util + # if self.logger.is_human_readable_format(): + # monitor_values['decoder'] = f"{monitor_values['decoder']} %" + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['decoder'] = "N/A" + logging.debug("Failed to get decoder utilization on gpu %s | %s", gpu_id, e.get_error_info()) + + self.logger.table_header += 'DEC_UTIL'.rjust(10) + + try: + decoder_clock = amdsmi_interface.amdsmi_get_gpu_metrics_info(args.gpu)['current_dclk0'] + monitor_values['decoder_clock'] = decoder_clock + if self.logger.is_human_readable_format(): + monitor_values['decoder_clock'] = f"{monitor_values['decoder_clock']} MHz" + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['decoder_clock'] = "N/A" + logging.debug("Failed to get decoder clock on gpu %s | %s", gpu_id, e.get_error_info()) + + self.logger.table_header += 'DEC_CLOCK'.rjust(11) + if args.throttle_status: + try: + throttle_status = amdsmi_interface.amdsmi_get_gpu_metrics_throttle_status(args.gpu) + if throttle_status: + throttle_status = "THROTTLED" + else: + throttle_status = "UNTHROTTLED" + monitor_values['throttle_status'] = throttle_status + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['throttle_status'] = "N/A" + logging.debug("Failed to get throttle status on gpu %s | %s", gpu_id, e.get_error_info()) + + self.logger.table_header += 'THROTTLE'.rjust(13) + if args.ecc: + try: + ecc = amdsmi_interface.amdsmi_get_gpu_total_ecc_count(args.gpu) + monitor_values['single_bit_ecc'] = ecc['correctable_count'] + monitor_values['double_bit_ecc'] = ecc['uncorrectable_count'] + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['ecc'] = "N/A" + logging.debug("Failed to get ecc on gpu %s | %s", gpu_id, e.get_error_info()) + + self.logger.table_header += 'SINGLE_ECC'.rjust(12) + self.logger.table_header += 'DOUBLE_ECC'.rjust(12) + + try: + pcie_replay = amdsmi_interface.amdsmi_get_gpu_pci_replay_counter(args.gpu) + monitor_values['pcie_replay'] = pcie_replay + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['pcie_replay'] = "N/A" + logging.debug("Failed to get pcie replay counter on gpu %s | %s", gpu_id, e.get_error_info()) + + self.logger.table_header += 'PCIE_REPLAY'.rjust(13) + if args.vram_usage: + try: + vram_usage = amdsmi_interface.amdsmi_get_gpu_vram_usage(args.gpu) + monitor_values['vram_used'] = vram_usage['vram_used'] + monitor_values['vram_total'] = vram_usage['vram_total'] + if self.logger.is_human_readable_format(): + monitor_values['vram_used'] = f"{monitor_values['vram_used']} MB" + monitor_values['vram_total'] = f"{monitor_values['vram_total']} MB" + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['vram_used'] = "N/A" + monitor_values['vram_total'] = "N/A" + logging.debug("Failed to get vram memory usage on gpu %s | %s", gpu_id, e.get_error_info()) + + self.logger.table_header += 'VRAM_USED'.rjust(11) + self.logger.table_header += 'VRAM_TOTAL'.rjust(12) + if args.pcie: + try: + pcie_bw = amdsmi_interface.amdsmi_get_gpu_pci_throughput(args.gpu) + sent = pcie_bw['sent'] * pcie_bw['max_pkt_sz'] + received = pcie_bw['received'] * pcie_bw['max_pkt_sz'] + + if self.logger.is_human_readable_format(): + if sent > 0: + sent = sent // 1024 // 1024 + sent = f"{sent} MB/s" + + if received > 0: + received = received // 1024 // 1024 + received = f"{received} MB/s" + pcie_bw['max_pkt_sz'] = f"{pcie_bw['max_pkt_sz']} B" + + monitor_values['pcie_tx'] = sent + monitor_values['pcie_rx'] = received + except amdsmi_exception.AmdSmiLibraryException as e: + monitor_values['pcie_tx'] = "N/A" + monitor_values['pcie_rx'] = "N/A" + logging.debug("Failed to get pci throughput on gpu %s | %s", gpu_id, e.get_error_info()) + + self.logger.table_header += 'PCIE_TX'.rjust(10) + self.logger.table_header += 'PCIE_RX'.rjust(10) + + self.logger.store_output(args.gpu, 'values', monitor_values) + + if multiple_devices: + self.logger.store_multiple_device_output() + return # Skip printing when there are multiple devices + + self.logger.print_output(watching_output=watching_output, tabular=True) + + if watching_output: # End of single gpu add to watch_output + self.logger.store_watch_output(multiple_device_enabled=False) + + def rocm_smi(self, args): print("Placeholder for rocm-smi legacy commands") diff --git a/projects/amdsmi/amdsmi_cli/amdsmi_logger.py b/projects/amdsmi/amdsmi_cli/amdsmi_logger.py index 3ebf11981c..dc688bb2db 100644 --- a/projects/amdsmi/amdsmi_cli/amdsmi_logger.py +++ b/projects/amdsmi/amdsmi_cli/amdsmi_logger.py @@ -24,6 +24,7 @@ import csv import json import re import time +from typing import Dict import yaml from enum import Enum @@ -37,6 +38,8 @@ class AMDSMILogger(): self.watch_output = [] self.format = format # csv, json, or human_readable self.destination = destination # stdout, path to a file (append) + self.table_header = "" + self.added_table_header = False self.helpers = AMDSMIHelpers() @@ -95,7 +98,32 @@ class AMDSMILogger(): return output_dict - def _convert_json_to_human_readable(self, json_object): + def _convert_json_to_human_readable(self, json_object: Dict[str, any], tabular=False): + # TODO make dynamic + if tabular: + table_values = '' + for key, value in json_object.items(): + value = str(value) + if key == 'gpu': + table_values += value.rjust(3) + elif key == 'power_usage': + table_values += value.rjust(7) + elif key in ('gfx_clock', 'mem_clock', 'encoder_clock', 'decoder_clock'): + table_values += value.rjust(11) + elif key == 'throttle_status': + table_values += value.rjust(13) + elif key == 'pcie_replay': + table_values += value.rjust(13) + elif key == 'vram_total': + table_values += value.rjust(12) + elif key == 'vram_used': + table_values += value.rjust(11) + elif 'ecc' in key: + table_values += value.rjust(12) + else: + table_values += value.rjust(10) + return table_values.rstrip() + # First Capitalize all keys in the json object capitalized_json = self._capitalize_keys(json_object) json_string = json.dumps(capitalized_json, indent=4) @@ -266,7 +294,7 @@ class AMDSMILogger(): self.output = {} - def print_output(self, multiple_device_enabled=False, watching_output=False): + def print_output(self, multiple_device_enabled=False, watching_output=False, tabular=False): """ Print current output acording to format and then destination params: multiple_device_enabled (bool) - True if printing output from @@ -280,10 +308,11 @@ class AMDSMILogger(): watching_output=watching_output) elif self.is_csv_format(): self._print_csv_output(multiple_device_enabled=multiple_device_enabled, - watching_output=watching_output) + watching_output=watching_output) elif self.is_human_readable_format(): self._print_human_readable_output(multiple_device_enabled=multiple_device_enabled, - watching_output=watching_output) + watching_output=watching_output, + tabular=tabular) def _print_json_output(self, multiple_device_enabled=False, watching_output=False): @@ -360,14 +389,18 @@ class AMDSMILogger(): writer.writerows(stored_csv_output) - def _print_human_readable_output(self, multiple_device_enabled=False, watching_output=False): + def _print_human_readable_output(self, multiple_device_enabled=False, watching_output=False, tabular=False): + human_readable_output = '' + if tabular and not self.added_table_header: + human_readable_output += self.table_header + '\n' + self.added_table_header = True + if multiple_device_enabled: - human_readable_output = '' for output in self.multiple_device_output: - human_readable_output += self._convert_json_to_human_readable(output) + human_readable_output += self._convert_json_to_human_readable(output, tabular=tabular) human_readable_output += '\n' else: - human_readable_output = self._convert_json_to_human_readable(self.output) + human_readable_output += self._convert_json_to_human_readable(self.output, tabular=tabular) if self.destination == 'stdout': try: @@ -380,9 +413,13 @@ class AMDSMILogger(): if watching_output: with self.destination.open('w') as output_file: human_readable_output = '' + if tabular: + human_readable_output += self.table_header + '\n' for output in self.watch_output: - human_readable_output += self._convert_json_to_human_readable(output) + human_readable_output += self._convert_json_to_human_readable(output, tabular=tabular) output_file.write(human_readable_output + '\n') else: with self.destination.open('a') as output_file: + if tabular: + human_readable_output += self.table_header + '\n' output_file.write(human_readable_output + '\n') diff --git a/projects/amdsmi/amdsmi_cli/amdsmi_parser.py b/projects/amdsmi/amdsmi_cli/amdsmi_parser.py index 262b2358bc..4828854cd6 100644 --- a/projects/amdsmi/amdsmi_cli/amdsmi_parser.py +++ b/projects/amdsmi/amdsmi_cli/amdsmi_parser.py @@ -66,7 +66,8 @@ class AMDSMIParser(argparse.ArgumentParser): argparse (ArgumentParser): argparse.ArgumentParser """ def __init__(self, version, list, static, firmware, bad_pages, metric, - process, profile, event, topology, set_value, reset, rocmsmi): + process, profile, event, topology, set_value, reset, monitor, + rocmsmi): # Helper variables self.helpers = AMDSMIHelpers() @@ -105,6 +106,7 @@ class AMDSMIParser(argparse.ArgumentParser): self._add_topology_parser(self.subparsers, topology) self._add_set_value_parser(self.subparsers, set_value) self._add_reset_parser(self.subparsers, reset) + self._add_monitor_parser(self.subparsers, monitor) self._add_rocm_smi_parser(self.subparsers, rocmsmi) @@ -813,6 +815,54 @@ class AMDSMIParser(argparse.ArgumentParser): reset_parser.add_argument('-o', '--power-cap', action='store_true', required=False, help=reset_power_cap_help) + def _add_monitor_parser(self, subparsers, func): + if not(self.helpers.is_baremetal() and self.helpers.is_linux()): + # This subparser is only applicable to Baremetal Linux + return + + # Subparser help text + monitor_help = "Monitor metrics for target devices" + monitor_subcommand_help = "Monitor a target device for the specified arguments.\ + \nIf no arguments are provided, all arguments will be enabled.\ + \nUse the watch arguments to run continuously" + monitor_optionals_title = "Monitor Arguments" + + # Help text for Arguments only on Guest and BM platforms + power_usage_help = "Monitor power usage in Watts" + temperature_help = "Monitor temperature in Celsius" + gfx_util_help = "Monitor graphics utilization (%%) and clock (MHz)" + mem_util_help = "Monitor memory utilization (%%) and clock (MHz)" + encoder_util_help = "Monitor encoder utilization (%%) and clock (MHz)" + decoder_util_help = "Monitor decoder utilization (%%) and clock (MHz)" + throttle_help = "Monitor thermal throttle status" + ecc_help = "Monitor ECC single bit, ECC double bit, and PCIe replay error counts" + mem_usage_help = "Monitor memory usage in MB" + pcie_throughput_help = "Monitor PCIe Tx/Rx in MB/s" + + # Create monitor subparser + monitor_parser = subparsers.add_parser('monitor', help=monitor_help, description=monitor_subcommand_help) + monitor_parser._optionals.title = monitor_optionals_title + monitor_parser.formatter_class=lambda prog: AMDSMISubparserHelpFormatter(prog) + monitor_parser.set_defaults(func=func) + + # Add Universal Arguments + self._add_command_modifiers(monitor_parser) + self._add_device_arguments(monitor_parser, required=False) + self._add_watch_arguments(monitor_parser) + + # Add monitor arguments + monitor_parser.add_argument('-p', '--power-usage', action='store_true', required=False, help=power_usage_help) + monitor_parser.add_argument('-t', '--temperature', action='store_true', required=False, help=temperature_help) + monitor_parser.add_argument('-u', '--gfx', action='store_true', required=False, help=gfx_util_help) + monitor_parser.add_argument('-m', '--mem', action='store_true', required=False, help=mem_util_help) + monitor_parser.add_argument('-n', '--encoder', action='store_true', required=False, help=encoder_util_help) + monitor_parser.add_argument('-d', '--decoder', action='store_true', required=False, help=decoder_util_help) + monitor_parser.add_argument('-s', '--throttle-status', action='store_true', required=False, help=throttle_help) + monitor_parser.add_argument('-e', '--ecc', action='store_true', required=False, help=ecc_help) + monitor_parser.add_argument('-v', '--vram-usage', action='store_true', required=False, help=mem_usage_help) + monitor_parser.add_argument('-r', '--pcie', action='store_true', required=False, help=pcie_throughput_help) + + def _add_rocm_smi_parser(self, subparsers, func): return # Subparser help text diff --git a/projects/amdsmi/py-interface/amdsmi_interface.py b/projects/amdsmi/py-interface/amdsmi_interface.py index c8361d6b3f..acd7ecb80b 100644 --- a/projects/amdsmi/py-interface/amdsmi_interface.py +++ b/projects/amdsmi/py-interface/amdsmi_interface.py @@ -3244,7 +3244,7 @@ def amdsmi_get_gpu_metrics_temp_hotspot( processor_handle, amdsmi_wrapper.amdsmi_processor_handle ) - hotspot_value = ctypes.c_int16() + hotspot_value = ctypes.c_uint16() _check_res( amdsmi_wrapper.amdsmi_get_gpu_metrics_temp_hotspot( processor_handle, ctypes.byref(hotspot_value) @@ -3265,7 +3265,7 @@ def amdsmi_get_gpu_metrics_temp_mem( processor_handle, amdsmi_wrapper.amdsmi_processor_handle ) - mem_value = ctypes.c_int16() + mem_value = ctypes.c_uint16() _check_res( amdsmi_wrapper.amdsmi_get_gpu_metrics_temp_mem( processor_handle, ctypes.byref(mem_value) @@ -3286,7 +3286,7 @@ def amdsmi_get_gpu_metrics_temp_vrsoc( processor_handle, amdsmi_wrapper.amdsmi_processor_handle ) - vrsoc_value = ctypes.c_int16() + vrsoc_value = ctypes.c_uint16() _check_res( amdsmi_wrapper.amdsmi_get_gpu_metrics_temp_vrsoc( processor_handle, ctypes.byref(vrsoc_value) @@ -3754,7 +3754,7 @@ def amdsmi_get_gpu_metrics_vcn_activity( ) ) - return [vcn_activity.value for vcn_activity in vcn_activity_value] + return vcn_activity_value def amdsmi_get_gpu_metrics_xgmi_read_data( @@ -3811,7 +3811,9 @@ def amdsmi_get_gpu_metrics_curr_gfxclk( ) ) - return [curr_gfxclk.value for curr_gfxclk in current_gfxclk_value] + print([curr_gfxclk for curr_gfxclk in current_gfxclk_value]) + + return [curr_gfxclk for curr_gfxclk in current_gfxclk_value] def amdsmi_get_gpu_metrics_curr_socclk( @@ -3879,7 +3881,7 @@ def amdsmi_get_gpu_metrics_temp_edge( processor_handle, amdsmi_wrapper.amdsmi_processor_handle ) - edge_value = ctypes.c_int16() + edge_value = ctypes.c_uint16() _check_res( amdsmi_wrapper.amdsmi_get_gpu_metrics_temp_edge( @@ -3901,7 +3903,7 @@ def amdsmi_get_gpu_metrics_temp_vrgfx( processor_handle, amdsmi_wrapper.amdsmi_processor_handle ) - vrgfx_value = ctypes.c_int16() + vrgfx_value = ctypes.c_uint16() _check_res( amdsmi_wrapper.amdsmi_get_gpu_metrics_temp_vrgfx( @@ -3923,7 +3925,7 @@ def amdsmi_get_gpu_metrics_temp_vrmem( processor_handle, amdsmi_wrapper.amdsmi_processor_handle ) - vrmem_value = ctypes.c_int16() + vrmem_value = ctypes.c_uint16() _check_res( amdsmi_wrapper.amdsmi_get_gpu_metrics_temp_vrmem(