AMD SMI Python API reference

AMD SMI Python API reference#

The AMD SMI Python interface provides a convenient way to interact with AMD hardware through a simple and accessible API. Compatible with Python 3.6 and higher, this library requires the AMD driver to be loaded for initialization – review the prerequisites.

This section provides comprehensive documentation for the AMD SMI Python API. Explore these sections to understand the full scope of available functionalities and how to implement them in your applications.

API#

amdsmi_init#

Description: Initialize amdsmi with AmdSmiInitFlags

Input parameters: AmdSmiInitFlags

Output: None

Exceptions that can be thrown by amdsmi_init function:

AmdSmiLibraryException
AmdSmiTimeoutException

Possible Library Exceptions#

AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Initialize GPUs only example:

try:
    # by default we initialize with AmdSmiInitFlags.INIT_AMD_GPUS
    ret = amdsmi_init()
    # continue with amdsmi
except AmdSmiException as e:
    print("Init GPUs failed")
    print(e)

Initialize CPUs only example:

try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    # continue with amdsmi
except AmdSmiException as e:
    print("Init CPUs failed")
    print(e)

Initialize both GPUs and CPUs example:

try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_APUS)
    # continue with amdsmi
except AmdSmiException as e:
    print("Init both GPUs & CPUs failed")
    print(e)

amdsmi_shut_down#

Description: Finalize and close connection to driver

Input parameters: None

Output: None

Exceptions that can be thrown by amdsmi_shut_down function:

AmdSmiLibraryException
AmdSmiTimeoutException

Possible Library Exceptions#

AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    amdsmi_init()
    amdsmi_shut_down()
except AmdSmiException as e:
    print("Shut down failed")
    print(e)

amdsmi_get_processor_type#

Description: Checks the type of device with provided handle.

Input parameters: device handle as an instance of amdsmi_processor_handle

Output: Dictionary with fields

Field	Content
`processor_type`	A string representing the processor type name.

Possible processor_type values include:
- "AMD_GPU" - AMD GPU processor
- "AMD_CPU" - AMD CPU processor
- "AMD_CPU_CORE" - AMD CPU core processor
- "UNKNOWN" - Unknown processor type

Exceptions that can be thrown by amdsmi_get_processor_type function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported

Example:

try:
    info = amdsmi_get_processor_type(processor_handle)
    processor_type = info["processor_type"]
    if processor_type == AmdSmiProcessorType.AMD_GPU.name:
        print("This is an AMD GPU")
except AmdSmiException as e:
    print(e)

amdsmi_get_processor_handles#

Description: Returns list of GPU device handle objects on current machine

Input parameters: None

Output: List of GPU device handle objects

Exceptions that can be thrown by amdsmi_get_processor_handles function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_INIT - Device not initialized
AMDSMI_STATUS_DRIVER_NOT_LOADED - Driver not loaded
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            print(amdsmi_get_gpu_device_uuid(device))
except AmdSmiException as e:
    print(e)

amdsmi_get_socket_handles#

Note: CURRENTLY HARDCODED TO RETURN DUMMY DATA

Description: Returns list of socket device handle objects on current machine

Input parameters: None

Output: List of socket device handle objects

Exceptions that can be thrown by amdsmi_get_socket_handles function:

AmdSmiLibraryException

Example:

try:
    sockets = amdsmi_get_socket_handles()
    print('Socket numbers: {}'.format(len(sockets)))
except AmdSmiException as e:
    print(e)

amdsmi_get_socket_info#

Note: CURRENTLY HARDCODED TO RETURN EMPTY VALUES

Description: Return socket name

Input parameters: socket_handle socket handle

Output: Socket name

Exceptions that can be thrown by amdsmi_get_socket_info function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    socket_handles = amdsmi_get_socket_handles()
    if len(socket_handles) == 0:
        print("No sockets on machine")
    else:
        for socket in socket_handles:
            print(amdsmi_get_socket_info(socket))
except AmdSmiException as e:
    print(e)

amdsmi_get_processor_handle_from_bdf#

Description: Returns device handle from the given BDF

Input parameters: bdf string in form of either <domain>:<bus>:<device>.<function> or <bus>:<device>.<function> in hexcode format. Where:

<domain> is 4 hex digits long from 0000-FFFF interval
<bus> is 2 hex digits long from 00-FF interval
<device> is 2 hex digits long from 00-1F interval
<function> is 1 hex digit long from 0-7 interval

Output: device handle object

Exceptions that can be thrown by amdsmi_get_processor_handle_from_bdf function:

AmdSmiLibraryException
AmdSmiBdfFormatException

Possible Library Exceptions#

AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    device = amdsmi_get_processor_handle_from_bdf("0000:23:00.0")
    print(amdsmi_get_gpu_device_uuid(device))
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_device_bdf#

Description: Returns BDF of the given device

Input parameters:

processor_handle dev for which to query

Output: BDF string in form of <domain>:<bus>:<device>.<function> in hexcode format. Where:

<domain> is 4 hex digits long from 0000-FFFF interval
<bus> is 2 hex digits long from 00-FF interval
<device> is 2 hex digits long from 00-1F interval
<function> is 1 hex digit long from 0-7 interval

Exceptions that can be thrown by amdsmi_get_gpu_device_bdf function:

AmdSmiParameterException
AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    device = amdsmi_get_processor_handles()[0]
    print("Device's bdf:", amdsmi_get_gpu_device_bdf(device))
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_device_uuid#

Description: Returns the UUID of the device

Input parameters:

processor_handle dev for which to query

Output: UUID string unique to the device

Exceptions that can be thrown by amdsmi_get_gpu_device_uuid function:

AmdSmiParameterException
AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    device = amdsmi_get_processor_handles()[0]
    print("Device UUID: ", amdsmi_get_gpu_device_uuid(device))
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_enumeration_info#

Description: Returns enumeration information for the given GPU

Input parameters:

processor_handle device which to query

Output: Dictionary with fields

Field	Content
`drm_render`	DRM render ID
`drm_card`	DRM card ID
`hsa_id`	HSA ID
`hip_id`	HIP ID
`hip_uuid`	HIP UUID

Exceptions that can be thrown by amdsmi_get_gpu_enumeration_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported

Example:

try:
    devices = amdsmi_get_processor_handles()
    for device in devices:
        info = amdsmi_get_gpu_enumeration_info(device)
        print("DRM Render ID:", info['drm_render'])
        print("DRM Card ID:", info['drm_card'])
        print("HSA ID:", info['hsa_id'])
        print("HIP ID:", info['hip_id'])
        print("HIP UUID:", info['hip_uuid'])
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_driver_info#

Description: Returns the info of the driver

Input parameters:

processor_handle dev for which to query

Output: Dictionary with fields

Field	Content
`driver_name`	driver name
`driver_version`	driver_version
`driver_date`	driver_date

Exceptions that can be thrown by amdsmi_get_gpu_driver_info function:

AmdSmiParameterException
AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_DRIVER_NOT_LOADED - Driver not loaded
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported

Example:

try:
    device = amdsmi_get_processor_handles()[0]
    print("Driver info: ", amdsmi_get_gpu_driver_info(device))
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_asic_info#

Description: Returns asic information for the given GPU

Input parameters:

processor_handle device which to query

Output: Dictionary with fields

Field	Content
`market_name`	market name
`vendor_id`	vendor id
`vendor_name`	vendor name
`device_id`	device id
`rev_id`	revision id
`asic_serial`	asic serial
`oam_id`	oam id
`num_of_compute_units`	number of compute units on asic
`target_graphics_version`	hardware graphics version
`subsystem_id`	subsystem id

Exceptions that can be thrown by amdsmi_get_gpu_asic_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_FILE_ERROR - Problem accessing a file
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            asic_info = amdsmi_get_gpu_asic_info(device)
            print(asic_info)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_kfd_info#

Description: Returns KFD (kernel driver) information for the given GPU This correlates to GUID in rocm-smi

Input parameters:

processor_handle device which to query

Output: Dictionary with fields

Field	Content
`kfd_id`	KFD’s unique GPU identifier
`node_id`	KFD’s internal GPU index

Exceptions that can be thrown by amdsmi_get_gpu_kfd_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            kfd_info = amdsmi_get_gpu_kfd_info(device)
            print(kfd_info)
except AmdSmiException as e:
    print(e)

amdsmi_get_power_cap_info#

Description: Returns dictionary of power capabilities as currently configured on the given GPU. It is not supported on virtual machine guest

Input parameters:

processor_handle device which to query

Output: Dictionary with fields

Field	Description	Units
`power_cap`	power capability	uW
`dpm_cap`	dynamic power management capability	MHz
`default_power_cap`	default power capability	uW
`min_power_cap`	min power capability	uW
`max_power_cap`	max power capability	uW

Exceptions that can be thrown by amdsmi_get_power_cap_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            power_cap_info = amdsmi_get_power_cap_info(device)
            print(power_cap_info['power_cap'])
            print(power_cap_info['dpm_cap'])
            print(power_cap_info['default_power_cap'])
            print(power_cap_info['min_power_cap'])
            print(power_cap_info['max_power_cap'])
except AmdSmiException as e:
    print(e)

amdsmi_get_supported_power_cap#

Description: Returns dictionary of Package Power Tracking (PPT) types as currently configured on the given GPU. It is not supported on virtual machine guest

Input parameters:

processor_handle device which to query

Output: Dictionary with fields

Field | Description | Units —|— sensor_inds | List of integer indices of the supported ppt types. 0 indicates PPT0 and 1 indicates PPT1. Should be used as input for amdsmi_get_power_cap_info and amdsmi_set_power_cap_info. sensor_types | Enum AmdSmiPowerCapType that corresponds to the ppt types that are supported on the device.

Exceptions that can be thrown by amdsmi_get_supported_power_cap function:

AmdSmiLibraryException
AmdSmiParameterException

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            power_cap_types = amdsmi_get_supported_power_cap(device)
            print(power_cap_types['sensor_inds'])
            print(power_cap_types['sensor_types'])
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_vram_info#

Description: Returns dictionary of vram information for the given GPU.

Input parameters:

processor_handle device which to query

Output: Dictionary with fields

Field	Description
`vram_type`	vram type
`vram_vendor`	vram vendor
`vram_size`	vram size in mb
`vram_bit_width`	vram bit width

Exceptions that can be thrown by amdsmi_get_gpu_vram_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            vram_info = amdsmi_get_gpu_vram_info(device)
            print(vram_info['vram_type'])
            print(vram_info['vram_vendor'])
            print(vram_info['vram_size'])
            print(vram_info['vram_bit_width'])
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_board_info#

Description: Returns board info for the given GPU

Input parameters:

processor_handle device which to query

Output: Dictionary with fields correctable and uncorrectable

Field	Description
`model_number`	Board serial number
`product_serial`	Product serial
`fru_id`	FRU ID
`product_name`	Product name
`manufacturer_name`	Manufacturer name

Exceptions that can be thrown by amdsmi_get_gpu_board_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_BUSY - Processor busy

Example:

try:
    device = amdsmi_get_processor_handle_from_bdf("0000:23.00.0")
    board_info = amdsmi_get_gpu_board_info(device)
    print(board_info["model_number"])
    print(board_info["product_serial"])
    print(board_info["fru_id"])
    print(board_info["product_name"])
    print(board_info["manufacturer_name"])
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_revision#

Description: Returns the GPU revision for a given processor handle.

Input parameters:

processor_handle device which to query

Output: string hex value

Field	Description
`revision`	16 bit integer value returned as hex string.

Exceptions that can be thrown by amdsmi_get_gpu_revision function:

AmdSmiLibraryException If the processor handle is invalid.
AmdSmiParameterException If the underlying library call fails.

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            revision = amdsmi_get_gpu_revision(device)
            print(revision)
except AmdSmiLibraryException as e:
    print(e)
except AmdSmiParameterException as e:
    print(e)

amdsmi_get_gpu_cache_info#

Description: Returns a list of dictionaries containing cache information for the given GPU.

Input parameters:

processor_handle device which to query

Output: List of Dictionaries containing cache information following the schema below: Schema:

{
    "cache_properties":
        {
            "type" : "array",
            "items" : {"type" : "string"}
        },
    "cache_size": {"type" : "number"},
    "cache_level": {"type" : "number"},
    "max_num_cu_shared": {"type" : "number"},
    "num_cache_instance": {"type" : "number"}
}

Field	Description
`cache_properties`	list of up to 4 cache property type strings. Ex. data (“DATA_CACHE”), instruction (“INST_CACHE”), CPU (“CPU_CACHE”), or SIMD (“SIMD_CACHE”).
`cache_size`	size of cache in KB
`cache_level`	level of cache
`max_num_cu_shared`	max number of compute units shared
`num_cache_instance`	number of cache instances

Exceptions that can be thrown by amdsmi_get_gpu_cache_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            cache_info = amdsmi_get_gpu_cache_info(device)
            for cache_values in cache_info.values():
                for cache_value in cache_values:
                    print(cache_value['cache_properties'])
                    print(cache_value['cache_level'])
                    print(cache_value['max_num_cu_shared'])
                    print(cache_value['num_cache_instance'])
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_vbios_info#

Description: Returns the static information for the VBIOS/IFWI on the device.

Input parameters:

processor_handle device which to query

Output: Dictionary with fields

Field	Description
`name`	VBIOS/IFWI name
`build_date`	VBIOS/IFWI build date
`part_number`	VBIOS/IFWI part number
`version`	VBIOS/IFWI version string
`boot_firmware`	Unified BootLoader version if available; N/A otherwise

Exceptions that can be thrown by amdsmi_get_gpu_vbios_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_FILE_ERROR - Problem accessing a file
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            vbios_info = amdsmi_get_gpu_vbios_info(device)
            print(vbios_info['name'])
            print(vbios_info['build_date'])
            print(vbios_info['part_number'])
            print(vbios_info['version'])
            print(vbios_info['boot_firmware'])
except AmdSmiException as e:
    print(e)

amdsmi_get_fw_info#

Description: Returns GPU firmware related information.

Input parameters:

processor_handle device which to query

Output: Dictionary with fields

Field	Description
`fw_list`	List of dictionaries that contain information about a certain firmware block

Exceptions that can be thrown by amdsmi_get_fw_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            firmware_list = amdsmi_get_fw_info(device)['fw_list']
            for firmware_block in firmware_list:
                print(firmware_block['fw_name'])
                # String formatted hex or decimal value ie: 21.00.00.AC or 130
                print(firmware_block['fw_version'])
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_activity#

Description: Returns the engine usage for the given GPU. It is not supported on virtual machine guest

Input parameters:

processor_handle device which to query

Output: Dictionary of activities to their respective usage percentage or ‘N/A’ if not supported

Field	Description
`gfx_activity`	graphics engine usage percentage (0 - 100)
`umc_activity`	memory engine usage percentage (0 - 100)
`mm_activity`	average multimedia engine usages in percentage (0 - 100)

Exceptions that can be thrown by amdsmi_get_gpu_activity function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            engine_usage = amdsmi_get_gpu_activity(device)
            print(engine_usage['gfx_activity'])
            print(engine_usage['umc_activity'])
            print(engine_usage['mm_activity'])
except AmdSmiException as e:
    print(e)

amdsmi_get_power_info#

Description: Returns the current power and voltage for the given GPU. It is not supported on virtual machine guest

Input parameters:

processor_handle device which to query

Output: Dictionary with fields

Field	Description	Units
`socket_power`	socket power; matches current or average socket power	W
`current_socket_power`	current socket power; Mi300+ Series Cards	W
`average_socket_power`	average socket power; Navi + Mi 200 and earlier Series cards	W
`gfx_voltage`	voltage gfx	mV
`soc_voltage`	voltage soc	mV
`mem_voltage`	voltage mem	mV
`power_limit`	power limit	W
`ubb_power`	UBB (baseboard) node power	W

Exceptions that can be thrown by amdsmi_get_power_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            power_info = amdsmi_get_power_info(device)
            print(power_info['current_socket_power'])
            print(power_info['average_socket_power'])
            print(power_info['gfx_voltage'])
            print(power_info['soc_voltage'])
            print(power_info['mem_voltage'])
            print(power_info['power_limit'])
            print(power_info['ubb_power'])
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_vram_usage#

Description: Returns total VRAM and VRAM in use

Input parameters:

processor_handle device which to query

Output: Dictionary with fields

Field	Description
`vram_total`	VRAM total
`vram_used`	VRAM currently in use

Exceptions that can be thrown by amdsmi_get_gpu_vram_usage function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            vram_usage = amdsmi_get_gpu_vram_usage(device)
            print(vram_usage['vram_used'])
            print(vram_usage['vram_total'])
except AmdSmiException as e:
    print(e)

amdsmi_get_violation_status#

Description: Returns dictionary of violation status information for the given GPU.

Input parameters:

processor_handle The identifier of the given device as an instance of amdsmi_processor_handle.
*violation_status pointer to object of type amdsmi_violation_status_t to get the violation status information

Output: Dictionary with fields

Field	Description
`reference_timestamp`	CPU Time Since Epoch in Microseconds
`violation_timestamp`	Time of Violation in Nanoseconds
`acc_counter`	Current Accumulated Counter
`acc_prochot_thrm`	Current Accumulated Processor Hot Violation Count
`acc_ppt_pwr`	Current Accumulated Package Power Tracking (PPT) PVIOL
`acc_socket_thrm`	Current Accumulated Socket Thermal Count #TVIOL
`acc_vr_thrm`	Current Accumulated Voltage Regulator Count
`acc_hbm_thrm`	Current Accumulated High Bandwidth Memory (HBM) Thermal Count
`acc_gfx_clk_below_host_limit`	Current Graphic Clock Below Host Limit Count. UPDATED in new driver 1.8: use new acc_gfx_clk_below_host_limit_pwr, acc_gfx_clk_below_host_limit_thm, acc_gfx_clk_below_host_limit_total values
`acc_gfx_clk_below_host_limit_pwr`	2D array with Accumulated GFX Clk Below Host Limit (Power) per XCP/XCC
`acc_gfx_clk_below_host_limit_thm`	2D array with Accumulated GFX Clk Below Host Limit (Thermal) per XCP/XCC
`acc_low_utilization`	2D array with Accumulated Low Utilization per XCP/XCC
`acc_gfx_clk_below_host_limit_total`	2D array with Accumulated GFX Clk Below Host Limit (Total) per XCP/XCC
`per_prochot_thrm`	Processor hot violation % (greater than 0% is a violation)
`per_ppt_pwr`	PVIOL Package Power Tracking (PPT) violation % (greater than 0% is a violation)
`per_socket_thrm`	TVIOL; Socket thermal violation % (greater than 0% is a violation)
`per_vr_thrm`	Voltage regulator violation % (greater than 0% is a violation)
`per_hbm_thrm`	High Bandwidth Memory (HBM) thermal violation % (greater than 0% is a violation)
`per_gfx_clk_below_host_limit`	Graphics clock below host limit violation % (greater than 0% is a violation). UPDATED in new driver 1.8: use new per_gfx_clk_below_host_limit_pwr, per_gfx_clk_below_host_limit_thm, per_gfx_clk_below_host_limit_total values
`per_gfx_clk_below_host_limit_pwr`	2D array with GFX Clk Below Host Limit Violation % (Power) per XCP/XCC
`per_gfx_clk_below_host_limit_thm`	2D array with GFX Clk Below Host Limit Violation % (Thermal) per XCP/XCC
`per_low_utilization`	2D array with Low Utilization Violation % per XCP/XCC
`per_gfx_clk_below_host_limit_total`	2D array with GFX Clk Below Host Limit Violation % (Total) per XCP/XCC
`active_prochot_thrm`	Processor hot violation; 1 = active 0 = not active
`active_ppt_pwr`	Package Power Tracking (PPT) violation; 1 = active 0 = not active
`active_socket_thrm`	Socket thermal violation; 1 = active 0 = not active
`active_vr_thrm`	Voltage regulator violation; 1 = active 0 = not active
`active_hbm_thrm`	High Bandwidth Memory (HBM) thermal violation; 1 = active 0 = not active
`active_gfx_clk_below_host_limit`	Graphics Clock Below Host Limit Violation; 1 = Active 0 = Not Active. UPDATED in new driver 1.8: use new active_gfx_clk_below_host_limit_pwr, active_gfx_clk_below_host_limit_thm, active_gfx_clk_below_host_limit_total values
`active_gfx_clk_below_host_limit_pwr`	2D array with GFX Clk Below Host Limit Violation Active (Power) per XCP/XCC
`active_gfx_clk_below_host_limit_thm`	2D array with GFX Clk Below Host Limit Violation Active (Thermal) per XCP/XCC
`active_low_utilization`	2D array with Low Utilization Violation Active per XCP/XCC
`active_gfx_clk_below_host_limit_total`	2D array with GFX Clk Below Host Limit Violation Active (Total) per XCP/XCC

Exceptions that can be thrown by amdsmi_get_violation_status function:

AmdSmiLibraryException
AmdSmiParameterException
AmdSmiTimeoutException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    violation_status = amdsmi_interface.amdsmi_get_violation_status(args.gpu)
    throttle_status['accumulation_counter'] = violation_status['acc_counter']
    throttle_status['prochot_accumulated'] = violation_status['acc_prochot_thrm']
    throttle_status['ppt_accumulated'] = violation_status['acc_ppt_pwr']
    throttle_status['socket_thermal_accumulated'] = violation_status['acc_socket_thrm']
    throttle_status['vr_thermal_accumulated'] = violation_status['acc_vr_thrm']
    throttle_status['hbm_thermal_accumulated'] = violation_status['acc_hbm_thrm']
    throttle_status['gfx_clk_below_host_limit_accumulated'] = violation_status['acc_gfx_clk_below_host_limit']
    throttle_status['gfx_clk_below_host_limit_pwr_accumulated'] = violation_status['acc_gfx_clk_below_host_limit_pwr']
    throttle_status['gfx_clk_below_host_limit_thm_accumulated'] = violation_status['acc_gfx_clk_below_host_limit_thm']
    throttle_status['low_utilization_accumulated'] = violation_status['acc_low_utilization']
    throttle_status['gfx_clk_below_host_limit_total_accumulated'] = violation_status['acc_gfx_clk_below_host_limit_total']

    throttle_status['prochot_violation_status'] = violation_status['active_prochot_thrm']
    throttle_status['ppt_violation_status'] = violation_status['active_ppt_pwr']
    throttle_status['socket_thermal_violation_status'] = violation_status['active_socket_thrm']
    throttle_status['vr_thermal_violation_status'] = violation_status['active_vr_thrm']
    throttle_status['hbm_thermal_violation_status'] = violation_status['active_hbm_thrm']
    throttle_status['gfx_clk_below_host_limit_violation_status'] = violation_status['active_gfx_clk_below_host_limit']
    throttle_status['gfx_clk_below_host_limit_pwr_violation_status'] = violation_status['active_gfx_clk_below_host_limit_pwr']
    throttle_status['gfx_clk_below_host_limit_thm_violation_status'] = violation_status['active_gfx_clk_below_host_limit_thm']
    throttle_status['low_utilization_violation_status'] = violation_status['active_low_utilization']
    throttle_status['gfx_clk_below_host_limit_total_violation_status'] = violation_status['active_gfx_clk_below_host_limit_total']

    throttle_status['prochot_violation_activity'] = violation_status['per_prochot_thrm']
    throttle_status['ppt_violation_activity'] = violation_status['per_ppt_pwr']
    throttle_status['socket_thermal_violation_activity'] = violation_status['per_socket_thrm']
    throttle_status['vr_thermal_violation_activity'] = violation_status['per_vr_thrm']
    throttle_status['hbm_thermal_violation_activity'] = violation_status['per_hbm_thrm']
    throttle_status['gfx_clk_below_host_limit_violation_activity'] = violation_status['per_gfx_clk_below_host_limit']
    throttle_status['gfx_clk_below_host_limit_pwr_violation_activity'] = violation_status['per_gfx_clk_below_host_limit_pwr']
    throttle_status['gfx_clk_below_host_limit_thm_violation_activity'] = violation_status['per_gfx_clk_below_host_limit_thm']
    throttle_status['low_utilization_violation_activity'] = violation_status['per_low_utilization']
    throttle_status['gfx_clk_below_host_limit_total_violation_activity'] = violation_status['per_gfx_clk_below_host_limit_total']

except AmdSmiException as e:
    print(e)

amdsmi_get_clock_info#

Description: Returns the clock measure for the given GPU. It is not supported on virtual machine guest

Input parameters:

processor_handle device which to query
clock_type one of AmdSmiClkType enum values:

Field	Description
`SYS`	SYS clock type
`GFX`	GFX clock type
`DF`	DF clock type
`DCEF`	DCEF clock type
`SOC`	SOC clock type
`MEM`	MEM clock type
`PCIE`	PCIE clock type
`VCLK0`	VCLK0 clock type
`VCLK1`	VCLK1 clock type
`DCLK0`	DCLK0 clock type
`DCLK1`	DCLK1 clock type

Output: Dictionary with fields

Field	Description
`clk`	Current clock for given clock type
`min_clk`	Minimum clock for given clock type
`max_clk`	Maximum clock for given clock type
`clk_locked`	flag only supported on GFX clock domain
`clk_deep_sleep`	clock deep sleep mode flag

Exceptions that can be thrown by amdsmi_get_clock_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            clock_measure = amdsmi_get_clock_info(device, AmdSmiClkType.GFX)
            print(clock_measure['clk'])
            print(clock_measure['min_clk'])
            print(clock_measure['max_clk'])
            print(clock_measure['clk_locked'])
            print(clock_measure['clk_deep_sleep'])
except AmdSmiException as e:
    print(e)

amdsmi_get_pcie_info#

Description: Returns the pcie metric and static information for the given GPU. For accurate PCIe Bandwidth measurements it is recommended to use this function once per 1000ms It is not supported on virtual machine guest

Input parameters:

processor_handle device which to query

Output: Dictionary with 2 fields pcie_static and pcie_metric

Fields

Description

pcie_static

Subfield	Description
`max_pcie_width`	Maximum number of pcie lanes available
`max_pcie_speed`	Maximum capable pcie speed in GT/s
`pcie_interface_version`	PCIe generation ie. 3,4,5…
`slot_type`	The type of form factor of the slot: OAM, PCIE, CEM, or Unknown

pcie_metric

Subfield	Description
`pcie_width`	Current number of pcie lanes available
`pcie_speed`	Current pcie speed capable in GT/s
`pcie_bandwidth`	Current instantaneous bandwidth usage in Mb/s
`pcie_replay_count`	Total number of PCIe replays (NAKs)
`pcie_l0_to_recovery_count`	PCIE L0 to recovery state transition accumulated count
`pcie_replay_roll_over_count`	PCIe Replay accumulated count
`pcie_nak_sent_count`	PCIe NAK sent accumulated count
`pcie_nak_received_count`	PCIe NAK received accumulated count

Exceptions that can be thrown by amdsmi_get_pcie_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            pcie_info = amdsmi_get_pcie_info(device)
            print(pcie_info["pcie_static"])
            print(pcie_info["pcie_metric"])
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_bad_page_info#

Description: Returns bad page info for the given GPU. It is not supported on virtual machine guest

Input parameters:

processor_handle device which to query

Output: List consisting of dictionaries with fields for each bad page found; can be an empty list

Field	Description
`value`	Value of page
`page_address`	Address of bad page
`page_size`	Size of bad page
`status`	Status of bad page

Exceptions that can be thrown by amdsmi_get_gpu_bad_page_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            bad_page_info = amdsmi_get_gpu_bad_page_info(device)
            if not bad_page_info: # Can be empty list
                print("No bad pages found")
                continue
            for bad_page in bad_page_info:
                print(bad_page["value"])
                print(bad_page["page_address"])
                print(bad_page["page_size"])
                print(bad_page["status"])
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_bad_page_threshold#

Description: Returns bad page threshold for the given GPU; Requires root level access to display bad page threshold count; otherwise will return “N/A”. It is not supported on virtual machine guest

Input parameters:

processor_handle device which to query

Output: Bad page threshold value

Exceptions that can be thrown by amdsmi_get_gpu_bad_page_threshold function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            threshold = amdsmi_get_gpu_bad_page_threshold(device)
            print(bad_page["threshold"])
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_memory_reserved_pages#

Description: Returns reserved memory page info for the given GPU. It is not supported on virtual machine guest

Input parameters:

processor_handle device which to query

Output: List consisting of dictionaries with fields for each reserved memory page found; can be an empty list

Field	Description
`value`	Value of memory reserved page
`page_address`	Address of memory reserved page
`page_size`	Size of memory reserved page
`status`	Status of memory reserved page

Exceptions that can be thrown by amdsmi_get_gpu_memory_reserved_pages function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            reserved_memory_page_info = amdsmi_get_gpu_memory_reserved_pages(device)
            if not reserved_memory_page_info: # Can be empty list
                print("No memory reserved pages found")
                continue
            for reserved_memory_page in reserved_memory_page_info:
                print(reserved_memory_page["value"])
                print(reserved_memory_page["page_address"])
                print(reserved_memory_page["page_size"])
                print(reserved_memory_page["status"])
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_process_list#

Description: Returns the list of processes running on the target GPU; Requires root level access to display root process names; otherwise will return “N/A”

Input parameters:

processor_handle device which to query

Output: List of Dictionaries with the corresponding fields; empty list if no running process are detected

Field

Description

name

Name of process. If user does not have permission this will be “N/A”

pid

Process ID

mem

Total memory usage by GPU during process in Bytes (sum of the process memory is not expected to be the total memory usage.)

engine_usage

Subfield	Description
`gfx`	GFX engine usage in ns
`enc`	Encode engine usage in ns

memory_usage

Subfield	Description
`gtt_mem`	GTT memory usage in Bytes
`cpu_mem`	CPU memory usage in Bytes
`vram_mem`	Process VRAM memory usage in Bytes

cu_occupancy

Number of Compute Units utilized

evicted_time

Time that queues are evicted on a GPU in milliseconds

sdma_usage

SDMA usage in microseconds

Exceptions that can be thrown by amdsmi_get_gpu_process_list function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            processes = amdsmi_get_gpu_process_list(device)
            if len(processes) == 0:
                print("No processes running on this GPU")
            else:
                for process in processes:
                    print(process)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_total_ecc_count#

Description: Returns the ECC error count for the given GPU. It is not supported on virtual machine guest

See RAS Error Count sysfs Interface (AMDGPU RAS Support - Linux Kernel documentation) to learn how these error counts are accessed.

Input parameters:

processor_handle device which to query

Output: Dictionary with fields

Field	Description
`correctable_count`	Correctable ECC error count
`uncorrectable_count`	Uncorrectable ECC error count
`deferred_count`	Deferred ECC error count

Exceptions that can be thrown by amdsmi_get_gpu_total_ecc_count function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            ecc_error_count = amdsmi_get_gpu_total_ecc_count(device)
            print(ecc_error_count["correctable_count"])
            print(ecc_error_count["uncorrectable_count"])
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_cper_entries#

Description: Dump CPER entries for a given GPU in a file using from CPER header file from RAS tool.

Input parameters:

processor_handle device which to query
severity_mask the severity mask of the entries to be retrieved: 1:’nonfatal-uncorrected’, 2: ‘fatal’, 4: ‘nonfatal-corrected’, ‘corrected’, 7: ‘all’
buffer_size number of bytes that will be used to create a buffer for copying cper entries into; default is 1048576 bytes
cursor the zero based index at which to start retrieving cper entries; default value is 0; for example, if there are 10 cper entries available, then with a cursor value of 8, it will retrieve the last two cper entries only

Output: Dictionary with fields, updated cursor, and a dictionary of the cper_data, status_code status_code: AMDSMI_STATUS_SUCCESS: If all entries were retrieved successfully AMDSMI_STATUS_MORE_DATA: If some of the entries were retrieved and: * A subsequent call to the API with the updated cursor will result in the fetching the next batch of entries, or * Increasing the input buffer_size will allow more entries to be fetched with the same cursor

Field	Description
`error_severity`	The severity of the CPER error ex: `non_fatal_uncorrected`, `fatal`, `non_fatal_corrected`.
`notify_type`	The notification type associated with the CPER entry.
`timestamp`	The time when the CPER entry was recorded, formatted as `YYYY/MM/DD HH:MM:SS`.
`signature`	A 4-byte signature identifying the entry, typically `CPER`.
`revision`	The revision number of the CPER record format.
`signature_end`	A marker value (typically `0xFFFFFFFF`) confirming the integrity of the signature.
`sec_cnt`	The count of sections included in the CPER entry.
`record_length`	The total length in bytes of the CPER entry.
`platform_id`	A character array identifying the GPU or platform.
`creator_id`	A character array indicating the creator of the CPER entry.
`record_id`	A unique identifier for the CPER entry.
`flags`	Reserved flags related to the CPER entry.
`persistence_info`	Reserved information related to persistence.

Output2: Updated cursor (int type)

Cursor is the index of the next cper entry in the GPU ring buffer. For example, if 10 entries were fetched successfully, the value of cursor will be 11 upon return from the API. Subsequent call to the API with cursor value of 11 should fetch the next entry

Output3: A list of dictionaries, each dictionary containing the CPER record and its size:

{“bytes”: , “size”: }

Output4: status_code AMDSMI_STATUS_SUCCESS: If all entries were retrieved successfully AMDSMI_STATUS_MORE_DATA: If some of the entries were retrieved and: * A subsequent call to the API with the updated cursor will result in the fetching the next batch of entries, or * Increasing the input buffer_size will allow more entries to be fetched with the same cursor

Exceptions that can be thrown by amdsmi_get_gpu_cper_entries function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NO_PERM - Permission Denied
AMDSMI_STATUS_FILE_NOT_FOUND - File or directory not found
AMDSMI_STATUS_FILE_ERROR - Problem accessing a file

Example:

try:
    entries, new_cursor, cper_data, status_code = amdsmi_get_gpu_cper_entries(
        device, severity_mask, buffer_size, initial_cursor)
except AmdSmiException as e:
    print(e)

Refer to amd_smi_cper_example.py for a complete example.

amdsmi_get_afids_from_cper#

Description: Get the AFIDs from CPER buffer

Input parameters:

cper_afid_data: raw bytes of a single CPER record.

Output: Tuple[List[int], int]: A tuple containing: - A list of extracted AFIDs. - The total count of AFIDs.

status_code | Upon successful retrieval of data, status_code will be AMDSMI_STATUS_SUCCESS (0) or AMDSMI_STATUS_MORE_DATA (39) if more data can be retrieve by subsequent call to the amdsmi_get_gpu_cper_entries function. In the later case, the input parameter cursor should be set to the updated cursor that was returned from the previous call.

Exceptions that can be thrown by amdsmi_get_gpu_cper_entries function:

AmdSmiParameterException
AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_UNEXPECTED_SIZE - unexpected size of data was read
AMDSMI_STATUS_UNEXPECTED_DATA - The data read or provided was unexpected
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported

Example 1: Using a single CPER record as bytes

cper_bytes = b'\x43\x50\x45\x52...'  # Replace with actual bytes
afids, num_afids = amdsmi_get_afids_from_cper(cper_bytes)
print(f"AFIDs: {afids}\nTotal count: {num_afids}")

Example 2: Using a list of dicts

cper_record = {
'bytes': [67, 80, 69, 82, ...],  # Replace with actual byte values
'size': 376}
afids, num_afids = amdsmi_get_afids_from_cper([cper_record])
print(f"AFIDs: {afids}\nTotal count: {num_afids}")

Example 3: General Usage

try:
    with open(cper_file.path, "rb") as file:
        afids, num_afids = amdsmi_interface.amdsmi_get_afids_from_cper(file.read())
        print(f"AFIDs: {afids}\nTotal count: {num_afids}")

except AmdSmiException as e:
    print(e)

Refer to amd_smi_afid_example.py for a complete example.

amdsmi_get_gpu_ras_feature_info#

Description: Returns RAS version and schema information It is not supported on virtual machine guest

Input parameters:

processor_handle device which to query

Output: List containing dictionaries with fields

Field	Description
`eeprom_version`	eeprom version
`parity_schema`	parity schema
`single_bit_schema`	single bit schema
`double_bit_schema`	double bit schema
`poison_schema`	poison schema

Exceptions that can be thrown by amdsmi_get_gpu_ras_feature_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported”
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported”
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented”
AMDSMI_STATUS_INVAL - Invalid parameters”
AMDSMI_STATUS_TIMEOUT - Timeout in API call”

Example:

from amdsmi import *
import os

amdsmi_init()

def amdsmi_get_afids_from_cper():
    directory_path = "/tmp/cper_dump/"
    print(f"Searching for cper file in {directory_path}")
    with os.scandir(directory_path) as cper_files:
        for cper_file in cper_files:
            if cper_file.is_file():
                if ".bin" in cper_file.path:
                    print(f"Found {cper_file.path}")
                    with open(cper_file.path, "rb") as file:
                        raw = file.read()
                        afids, num_afids = amdsmi_interface.amdsmi_get_afids_from_cper(raw)
                        print(f"afids: {afids}")

amdsmi_get_afids_from_cper()

Output:

sudo python3 afid.py
Searching for cper file in /tmp/cper_dump/
Found /tmp/cper_dump/cper_entry_0.bin
afids: [17]
Found /tmp/cper_dump/cper_entry_1.bin
afids: [17]

amdsmi_get_gpu_ras_block_features_enabled#

Description: Returns status of each RAS block for the given GPU. It is not supported on virtual machine guest

Input parameters:

processor_handle device which to query

Output: List containing dictionaries with fields for each RAS block

Field	Description
`block`	RAS block
`status`	RAS block status

Exceptions that can be thrown by amdsmi_get_gpu_ras_block_features_enabled function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_API_FAILED - API call failed
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            ras_block_features = amdsmi_get_gpu_ras_block_features_enabled(device)
            print(ras_block_features)
except AmdSmiException as e:
    print(e)

AmdSmiEventReader class#

Description: Providing methods for event monitoring. This is context manager class. Can be used with with statement for automatic cleanup.

Methods:

Constructor#

Description: Allocates a new event reader notifier to monitor different types of events for the given GPU

Input parameters:

processor_handle device handle corresponding to the device on which to listen for events
event_types list of event types from AmdSmiEvtNotificationType enum. Specifying which events to collect for the given device.

Event Type	Description
`VMFAULT`	VM page fault
`THERMAL_THROTTLE`	thermal throttle
`GPU_PRE_RESET`	gpu pre reset; this event includes a message which indicates the cause of the reset. They are as follows: `job hang`, `RAS error`, `MES hang`, `HWS hang`, `user trigger`, and `unknown`
`GPU_POST_RESET`	gpu post reset
`MIGRATE_START`	migrate start
`MIGRATE_END`	migrate end
`PAGE_FAULT_START`	page fault start
`PAGE_FAULT_END`	page fault end
`QUEUE_EVICTION`	queue eviction
`QUEUE_RESTORE`	queue restore
`UNMAP_FROM_GPU`	unmap from GPU
`PROCESS_START`	KFD process start
`PROCESS_END`	KFD process end

read#

Description: Reads events on the given device. When event is caught, device handle, message and event type are returned. Reading events stops when timestamp passes without event reading.

Input parameters:

timestamp number of milliseconds to wait for an event to occur. If event does not happen monitoring is finished
num_elem number of events. This is optional parameter. Default value is 10.

stop#

Description: Any resources used by event notification for the the given device will be freed with this function. This can be used explicitly or automatically using with statement, like in the examples below. This should be called either manually or automatically for every created AmdSmiEventReader object.

Input parameters: None

Example with manual cleanup of AmdSmiEventReader:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        event = AmdSmiEventReader(devices[0], [AmdSmiEvtNotificationType.GPU_PRE_RESET, AmdSmiEvtNotificationType.GPU_POST_RESET])
        event.read(10000)
except AmdSmiException as e:
    print(e)
finally:
    event.stop()

Example with automatic cleanup using with statement:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        with AmdSmiEventReader(devices[0], [AmdSmiEvtNotificationType.GPU_PRE_RESET, AmdSmiEvtNotificationType.GPU_POST_RESET]) as event:
            event.read(10000)
except AmdSmiException as e:
    print(e)

amdsmi_set_gpu_pci_bandwidth#

Description: Control the set of allowed PCIe bandwidths that can be used It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
bw_bitmask A bitmask indicating the indices of the bandwidths that are to be enabled (1) and disabled (0)

Output: None

Exceptions that can be thrown by amdsmi_set_gpu_pci_bandwidth function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_NO_PERM - Permission Denied
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_set_gpu_pci_bandwidth(device, 0)
except AmdSmiException as e:
    print(e)

amdsmi_set_power_cap#

Description: Set the power cap value. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
sensor_ind a 0-based sensor index. Normally, this will be 0. If a device has more than one sensor, it could be greater than 0
cap int that indicates the desired power cap, in microwatts

Output: None

Exceptions that can be thrown by amdsmi_set_power_cap function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            power_cap = 250 * 1000000
             amdsmi_set_power_cap(device, 0, power_cap)
except AmdSmiException as e:
    print(e)

amdsmi_set_gpu_power_profile#

Description: Set the power profile. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
reserved Not currently used, set to 0
profile a amdsmi_power_profile_preset_masks_t that hold the mask of the desired new power profile

Output: None

Exceptions that can be thrown by amdsmi_set_gpu_power_profile function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            profile = AmdSmiPowerProfilePresetMasks.BOOTUP_DEFAULT
             amdsmi_set_gpu_power_profile(device, 0, profile)
except AmdSmiException as e:
    print(e)

amdsmi_set_gpu_clk_range#

Description: This function sets the clock range information. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
min_clk_value minimum clock value for desired clock range
max_clk_value maximum clock value for desired clock range
clk_type SYS | MEM range type

Output: None

Exceptions that can be thrown by amdsmi_set_gpu_clk_range function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_set_gpu_clk_range(device, 0, 1000, AmdSmiClkType.SYS)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_bdf_id#

Description: Get the unique PCI device identifier associated for a device

Input parameters:

processor_handle device which to query

Output: device bdf The format of bdfid will be as follows:

BDFID = ((DOMAIN & 0xffffffff) << 32) | ((BUS & 0xff) << 8) | ((DEVICE & 0x1f) <<3 ) | (FUNCTION & 0x7)

Name	Field
Domain	[64:32]
Reserved	[31:16]
Bus	[15: 8]
Device	[ 7: 3]
Function	[ 2: 0]

Exceptions that can be thrown by amdsmi_get_gpu_bdf_id function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            bdfid = amdsmi_get_gpu_bdf_id(device)
            print(bdfid)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_pci_bandwidth#

Description: Get the list of possible PCIe bandwidths that are available. It is not supported on virtual machine guest

Input parameters:

processor_handle device which to query

Output: Dictionary with the possible T/s values and associated number of lanes

Field	Content
`transfer_rate`	transfer_rate dictionary
`lanes`	lanes

transfer_rate dictionary

Field	Content
`num_supported`	num_supported
`current`	current
`frequency`	list of frequency

Exceptions that can be thrown by amdsmi_get_gpu_pci_bandwidth function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            bandwidth = amdsmi_get_gpu_pci_bandwidth(device)
            print(bandwidth)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_pci_throughput#

Description: Get PCIe traffic information. It is not supported on virtual machine guest

Input parameters:

processor_handle device which to query

Output: Dictionary with the fields

Field	Content
`sent`	number of bytes sent in 1 second
`received`	the number of bytes received
`max_pkt_sz`	maximum packet size

Exceptions that can be thrown by amdsmi_get_gpu_pci_throughput function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            pci = amdsmi_get_gpu_pci_throughput(device)
            print(pci)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_pci_replay_counter#

Description: Get PCIe replay counter

Input parameters:

processor_handle device which to query

Output: counter value The sum of the NAK’s received and generated by the GPU

Exceptions that can be thrown by amdsmi_get_gpu_pci_replay_counter function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            counter =  amdsmi_get_gpu_pci_replay_counter(device)
            print(counter)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_topo_numa_affinity#

Description: Get the NUMA node associated with a device

Input parameters:

processor_handle device which to query

Output: NUMA node value

Exceptions that can be thrown by amdsmi_get_gpu_topo_numa_affinity function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NOT_FOUND - Device Not found
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            numa_node = amdsmi_get_gpu_topo_numa_affinity(device)
            print(numa_node)
except AmdSmiException as e:
    print(e)

amdsmi_get_energy_count#

Description: Get the energy accumulator counter information of the device. energy_accumulator * counter_resolution = total_energy_consumption in micro-Joules It is not supported on virtual machine guest

Input parameters:

processor_handle device which to query

Output: Dictionary with fields

Field	Content
`power`	counter for energy accumulation since last restart/gpu rest (Deprecated in ROCm 6.4)
`energy_accumulator`	counter for energy accumulation since last restart/gpu rest
`counter_resolution`	counter resolution
`timestamp`	timestamp

Exceptions that can be thrown by amdsmi_get_energy_count function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            energy_dict = amdsmi_get_energy_count(device)
            print(energy_dict)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_memory_total#

Description: Get the total amount of memory that exists

Input parameters:

processor_handle device which to query
mem_type enum AmdSmiMemoryType

Output: total amount of memory

Exceptions that can be thrown by amdsmi_get_gpu_memory_total function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            vram_memory_total = amdsmi_get_gpu_memory_total(device, amdsmi_interface.AmdSmiMemoryType.VRAM)
            print(vram_memory_total)
            vis_vram_memory_total = amdsmi_get_gpu_memory_total(device, amdsmi_interface.AmdSmiMemoryType.VIS_VRAM)
            print(vis_vram_memory_total)
            gtt_memory_total = amdsmi_get_gpu_memory_total(device, amdsmi_interface.AmdSmiMemoryType.GTT)
            print(gtt_memory_total)
except AmdSmiException as e:
    print(e)

amdsmi_set_gpu_od_clk_info#

Description: This function sets the clock frequency information. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
level MIN | MAX to set the minimum (0) or maximum (1) speed
clk_value value to apply to the clock range
clk_type SYS | MEM range type

Output: None

Exceptions that can be thrown by amdsmi_set_gpu_od_clk_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_set_gpu_od_clk_info(
                device,
                AmdSmiFreqInd.MAX,
                1000,
                AmdSmiClkType.SYS
            )
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_memory_usage#

Description: Get the current memory usage

Input parameters:

processor_handle device which to query
mem_type enum AmdSmiMemoryType

Output: the amount of memory currently being used

Exceptions that can be thrown by amdsmi_get_gpu_memory_usage function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_FILE_ERROR - Problem accessing a file
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            vram_memory_usage = amdsmi_get_gpu_memory_usage(device, amdsmi_interface.AmdSmiMemoryType.VRAM)
            print(vram_memory_usage)
            vis_vram_memory_usage = amdsmi_get_gpu_memory_usage(device, amdsmi_interface.AmdSmiMemoryType.VIS_VRAM)
            print(vis_vram_memory_usage)
            gtt_memory_usage = amdsmi_get_gpu_memory_usage(device, amdsmi_interface.AmdSmiMemoryType.GTT)
            print(gtt_memory_usage)
except AmdSmiException as e:
    print(e)

amdsmi_set_gpu_od_volt_info#

Description: This function sets 1 of the 3 voltage curve points. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
vpoint voltage point [0|1|2] on the voltage curve
clk_value clock value component of voltage curve point
volt_value voltage value component of voltage curve point

Output: None

Exceptions that can be thrown by amdsmi_set_gpu_od_volt_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_set_gpu_od_volt_info(device, 1, 1000, 980)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_fan_rpms#

Description: Get the fan speed in RPMs of the device with the specified device handle and 0-based sensor index. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
sensor_idx a 0-based sensor index. Normally, this will be 0. If a device has more than one sensor, it could be greater than 0.

Output: Fan speed in rpms as integer

Exceptions that can be thrown by amdsmi_get_gpu_fan_rpms function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            fan_rpm = amdsmi_get_gpu_fan_rpms(device, 0)
            print(fan_rpm)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_fan_speed#

Description: Get the fan speed for the specified device as a value relative to AMDSMI_MAX_FAN_SPEED. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
sensor_idx a 0-based sensor index. Normally, this will be 0. If a device has more than one sensor, it could be greater than 0.

Output: Fan speed in relative to MAX

Exceptions that can be thrown by amdsmi_get_gpu_fan_speed function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            fan_speed = amdsmi_get_gpu_fan_speed(device, 0)
            print(fan_speed)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_fan_speed_max#

Description: Get the max fan speed of the device with provided device handle. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
sensor_idx a 0-based sensor index. Normally, this will be 0. If a device has more than one sensor, it could be greater than 0.

Output: Max fan speed as integer

Exceptions that can be thrown by amdsmi_get_gpu_fan_speed_max function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            max_fan_speed = amdsmi_get_gpu_fan_speed_max(device, 0)
            print(max_fan_speed)
except AmdSmiException as e:
    print(e)

amdsmi_is_gpu_power_management_enabled#

Description: Returns is power management enabled

Input parameters:

processor_handle GPU device which to query

Output: Bool true if power management enabled else false

Exceptions that can be thrown by amdsmi_is_gpu_power_management_enabled function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for processor in devices:
            is_power_management_enabled = amdsmi_is_gpu_power_management_enabled(processor)
            print(is_power_management_enabled)
except AmdSmiException as e:
    print(e)

amdsmi_get_npm_info#

Description: Returns Node Power Management (NPM) information including status, power limit, and UBB power threshold.

Input parameters:

node_handle node handle obtained from amdsmi_get_node_handle

Output: Dictionary with fields

Field	Description	Units
`status`	NPM status (AMDSMI_NPM_STATUS_ENABLED or AMDSMI_NPM_STATUS_DISABLED)	-
`limit`	Node-level power limit	W
`ubb_power_threshold`	UBB node power threshold	W

Exceptions that can be thrown by amdsmi_get_npm_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        node_handle = amdsmi_get_node_handle(devices[0])
        npm_info = amdsmi_get_npm_info(node_handle)
        print(npm_info['status'])
        print(npm_info['limit'])
        print(npm_info['ubb_power_threshold'])
except AmdSmiException as e:
    print(e)

amdsmi_get_temp_metric#

Description: Get the temperature metric value for the specified metric, from the specified temperature sensor on the specified device. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
sensor_type part of device from which temperature should be obtained
metric enum indicated which temperature value should be retrieved

Output: Temperature as integer in millidegrees Celsius

Exceptions that can be thrown by amdsmi_get_temp_metric function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            temp_metric =  amdsmi_get_temp_metric(device, AmdSmiTemperatureType.EDGE,
                            AmdSmiTemperatureMetric.CURRENT)
            print(temp_metric)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_volt_metric#

Description: Get the voltage metric value for the specified metric, from the specified voltage sensor on the specified device. It is not supported on virtual machine guest

Input parameters:

Parameters

Description

processor_handle

Handle for the given device

sensor_type

Possible Values	Description
`AmdSmiVoltageType.VDDGFX`	Represents the voltage supplied to the GPU’s graphics core.
`AmdSmiVoltageType.VDDBOARD`	Represents the voltage supplied to the entire GPU board, including auxiliary components. Intended for Mi300+

metric

Possible Values	Description
`AmdSmiVoltageMetric.CURRENT`	Represents the current voltage value measured at the specified sensor.
`AmdSmiVoltageMetric.MAX`	Represents the maximum voltage value recorded at the specified sensor.
`AmdSmiVoltageMetric.MIN`	Represents the minimum voltage value recorded at the specified sensor.
`AmdSmiVoltageMetric.AVERAGE`	Represents the average voltage value calculated over a period of time at the specified sensor.
`AmdSmiVoltageMetric.MAX_CRIT`	Represents the critical maximum voltage value that should not be exceeded.
`AmdSmiVoltageMetric.MIN_CRIT`	Represents the critical minimum voltage value that should not be dropped below.
`AmdSmiVoltageMetric.LOWEST`	Represents the lowest voltage value recorded during the monitoring period.
`AmdSmiVoltageMetric.HIGHEST`	Represents the highest voltage value recorded during the monitoring period.

Output: Voltage as integer in millivolts

Exceptions that can be thrown by amdsmi_get_gpu_volt_metric function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            voltage = amdsmi_get_gpu_volt_metric(
                device,
                AmdSmiVoltageType.VDDBOARD,
                AmdSmiVoltageMetric.AVERAGE
            )
            print(voltage)
except AmdSmiException as e:
    print(e)

amdsmi_get_utilization_count#

Description: Get coarse/fine grain utilization counter of the specified device

Input parameters:

processor_handle handle for the given device
counter_types List of AmdSmiUtilizationCounterType counters requested

Output: List containing dictionaries with fields

Field

Description

timestamp

The timestamp when the counter is retrieved - Resolution: 1 ns

Dictionary for each counter

Subfield	Description
`type`	Counter that was requested
`value`	Value gotten for utilization counter

Exceptions that can be thrown by amdsmi_get_utilization_count function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            utilization = amdsmi_get_utilization_count(
                            device,
                            AmdSmiUtilizationCounterType.COARSE_GRAIN_GFX_ACTIVITY
                        )
            print(utilization)
            utilization = amdsmi_get_utilization_count(
                            device,
                            [AmdSmiUtilizationCounterType.COARSE_GRAIN_GFX_ACTIVITY,
                            AmdSmiUtilizationCounterType.COARSE_GRAIN_MEM_ACTIVITY,
                            AmdSmiUtilizationCounterType.COARSE_DECODER_ACTIVITY,
                            AmdSmiUtilizationCounterType.FINE_GRAIN_GFX_ACTIVITY,
                            AmdSmiUtilizationCounterType.FINE_GRAIN_MEM_ACTIVITY,
                            AmdSmiUtilizationCounterType.FINE_DECODER_ACTIVITY]
                        )
            print(utilization)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_perf_level#

Description: Get the performance level of the device with provided device handle. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device

Output: Performance level as enum value of dev_perf_level_t

Exceptions that can be thrown by amdsmi_get_gpu_perf_level function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            perf_level = amdsmi_get_gpu_perf_level(device)
            print(perf_level)
except AmdSmiException as e:
    print(e)

amdsmi_set_gpu_perf_determinism_mode#

Description: Enter performance determinism mode with provided device handle. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
clkvalue softmax value for GFXCLK in MHz

Output: None

Exceptions that can be thrown by amdsmi_set_gpu_perf_determinism_mode function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_set_gpu_perf_determinism_mode(device, 1333)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_process_isolation#

Description: Get the status of the Process Isolation

Input parameters:

processor_handle handle for the given device

Output: integer corresponding to isolation_status; 0 - disabled, 1 - enabled

Exceptions that can be thrown by amdsmi_get_gpu_process_isolation function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            isolate = amdsmi_get_gpu_process_isolation(device)
            print("Process Isolation Status: ", isolate)
except AmdSmiException as e:
    print(e)

amdsmi_set_gpu_process_isolation#

Description: Enable/disable the system Process Isolation for the given device handle.

Input parameters:

processor_handle handle for the given device
pisolate the process isolation status to set. 0 is the process isolation disabled, and 1 is the process isolation enabled.

Output: None

Exceptions that can be thrown by amdsmi_set_gpu_process_isolation function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_set_gpu_process_isolation(device, 1)
except AmdSmiException as e:
    print(e)

amdsmi_clean_gpu_local_data#

Description: Clear the SRAM data of the given device. This can be called between user logins to prevent information leak.

Input parameters:

processor_handle handle for the given device

Output: None

Exceptions that can be thrown by amdsmi_clean_gpu_local_data function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_clean_gpu_local_data(device)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_overdrive_level#

Description: Get the overdrive percent associated with the device with provided device handle. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device

Output: Overdrive percentage as integer

Exceptions that can be thrown by amdsmi_get_gpu_overdrive_level function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            od_level = amdsmi_get_gpu_overdrive_level(dev)
            print(od_level)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_mem_overdrive_level#

Description: Get the GPU memory clock overdrive percent associated with the device with provided device handle. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device

Output: Overdrive percentage as integer

Exceptions that can be thrown by amdsmi_get_gpu_mem_overdrive_level function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            od_level = amdsmi_get_gpu_mem_overdrive_level(dev)
            print(od_level)
except AmdSmiException as e:
    print(e)

amdsmi_get_clk_freq#

Description: Get the list of possible system clock speeds of device for a specified clock type. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
clk_type the type of clock for which the frequency is desired

Output: Dictionary with fields

Field	Description
`num_supported`	The number of supported frequencies
`current`	The current frequency index
`frequency`	List of frequencies, only the first num_supported frequencies are valid

Exceptions that can be thrown by amdsmi_get_clk_freq function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_get_clk_freq(device, AmdSmiClkType.SYS)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_od_volt_info#

Description: This function retrieves the voltage/frequency curve information. If the num_regions is 0 then the voltage curve is not supported. It is not supported on virtual machine guest.

Input parameters:

processor_handle handle for the given device

Output: Dictionary with fields

Field

Description

curr_sclk_range

Subfield	Description
`lower_bound`	lower bound sclk range
`upper_bound`	upper bound sclk range

curr_mclk_range

Subfield	Description
`lower_bound`	lower bound mclk range
`upper_bound`	upper bound mclk range

sclk_freq_limits

Subfield	Description
`lower_bound`	lower bound sclk range limit
`upper_bound`	upper bound sclk range limit

mclk_freq_limits

Subfield	Description
`lower_bound`	lower bound mclk range limit
`upper_bound`	upper bound mclk range limit

curve.vc_points

List of voltage curve points

num_regions

The number of voltage curve regions

Exceptions that can be thrown by amdsmi_get_gpu_od_volt_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_get_gpu_od_volt_info(dev)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_metrics_info#

Description: This function retrieves the gpu metrics information. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device

Output: Dictionary with fields

Field	Description	Unit
`temperature_edge`	Edge temperature value	Celsius ©
`temperature_hotspot`	Hotspot (aka junction) temperature value	Celsius ©
`temperature_mem`	Memory temperature value	Celsius ©
`temperature_vrgfx`	vrgfx temperature value	Celsius ©
`temperature_vrsoc`	vrsoc temperature value	Celsius ©
`temperature_vrmem`	vrmem temperature value	Celsius ©
`average_gfx_activity`	Average gfx activity	%
`average_umc_activity`	Average umc (Universal Memory Controller) activity	%
`average_mm_activity`	Average mm (multimedia) engine activity	%
`average_socket_power`	Average socket power	W
`energy_accumulator`	Energy accumulated with a 15.3 uJ resolution over 1ns	uJ
`system_clock_counter`	System clock counter	ns
`average_gfxclk_frequency`	Average gfx clock frequency	MHz
`average_socclk_frequency`	Average soc clock frequency	MHz
`average_uclk_frequency`	Average uclk frequency	MHz
`average_vclk0_frequency`	Average vclk0 frequency	MHz
`average_dclk0_frequency`	Average dclk0 frequency	MHz
`average_vclk1_frequency`	Average vclk1 frequency	MHz
`average_dclk1_frequency`	Average dclk1 frequency	MHz
`current_gfxclk`	Current gfx clock	MHz
`current_socclk`	Current soc clock	MHz
`current_uclk`	Current uclk	MHz
`current_vclk0`	Current vclk0	MHz
`current_dclk0`	Current dclk0	MHz
`current_vclk1`	Current vclk1	MHz
`current_dclk1`	Current dclk1	MHz
`throttle_status`	Current throttle status	bool
`current_fan_speed`	Current fan speed	RPM
`pcie_link_width`	PCIe link width (number of lanes)	lanes
`pcie_link_speed`	PCIe link speed in 0.1 GT/s (Giga Transfers per second)	GT/s
`padding`	padding
`gfx_activity_acc`	gfx activity accumulated	%
`mem_activity_acc`	Memory activity accumulated	%
`temperature_hbm`	list of hbm temperatures	Celsius ©
`firmware_timestamp`	timestamp from PMFW (10ns resolution)	ns
`voltage_soc`	soc voltage	mV
`voltage_gfx`	gfx voltage	mV
`voltage_mem`	mem voltage	mV
`indep_throttle_status`	ASIC independent throttle status (see drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h for bit flags)
`current_socket_power`	Current socket power (also known as instant socket power)	W
`vcn_activity`	List of VCN encode/decode engine utilization per AID	%
`gfxclk_lock_status`	Clock lock status. Bits 0:7 correspond to each gfx clock engine instance. Bits 0:5 for APU/AID devices
`xgmi_link_width`	XGMI bus width	lanes
`xgmi_link_speed`	XGMI bitrate	GB/s
`pcie_bandwidth_acc`	PCIe accumulated bandwidth	GB/s
`pcie_bandwidth_inst`	PCIe instantaneous bandwidth	GB/s
`pcie_l0_to_recov_count_acc`	PCIe L0 to recovery state transition accumulated count
`pcie_replay_count_acc`	PCIe replay accumulated count
`pcie_replay_rover_count_acc`	PCIe replay rollover accumulated count
`xgmi_read_data_acc`	XGMI accumulated read data transfer size (KiloBytes)	KB
`xgmi_write_data_acc`	XGMI accumulated write data transfer size (KiloBytes)	KB
`current_gfxclks`	List of current gfx clock frequencies	MHz
`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
`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	%

Exceptions that can be thrown by amdsmi_get_gpu_metrics_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_get_gpu_metrics_info(dev)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_pm_metrics_info#

Description: This function will retrieve the name and value for each item in the pm metrics table with the given processor handle.

Input parameters:

processor_handle handle for the given device

Output: List containing dictionaries of pm metrics and their values

Field	Description
`name`	name of PM metric
`value`	value of pm metric

Exceptions that can be thrown by amdsmi_get_gpu_pm_metrics_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            print(amdsmi_get_gpu_pm_metrics_info(device))
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_reg_table_info#

Description: This function will retrieve register metrics table with provided device index and register type.

Input parameters:

processor_handle handle for the given device
reg_type register type

Output: List containing dictionaries of register metrics and their values

Field	Description
`name`	name of register metric
`value`	value of register metric

Exceptions that can be thrown by amdsmi_get_gpu_reg_table_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            print(amdsmi_get_gpu_reg_table_info(device, AmdSmiRegType.PCIE))
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_od_volt_curve_regions#

Description: This function will retrieve the current valid regions in the frequency/voltage space. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
num_regions number of freq volt regions

Output: List containing a dictionary with fields for each freq volt region

Field

Description

freq_range

Subfield	Description
`lower_bound`	lower bound freq range
`upper_bound`	upper bound freq range

volt_range

Subfield	Description
`lower_bound`	lower bound volt range
`upper_bound`	upper bound volt range

Exceptions that can be thrown by amdsmi_get_gpu_od_volt_curve_regions function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_UNEXPECTED_SIZE - unexpected size of data was read
AMDSMI_STATUS_UNEXPECTED_DATA - The data read or provided was unexpected
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_get_gpu_od_volt_curve_regions(device, 3)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_power_profile_presets#

Description: Get the list of available preset power profiles and an indication of which profile is currently active. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
sensor_idx number of freq volt regions

Output: Dictionary with fields

Field	Description
`available_profiles`	Which profiles are supported by this system
`current`	Which power profile is currently active
`num_profiles`	How many power profiles are available

Exceptions that can be thrown by amdsmi_get_gpu_power_profile_presets function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_get_gpu_power_profile_presets(device, 0)
except AmdSmiException as e:
    print(e)

amdsmi_gpu_counter_group_supported#

Description: Tell if an event group is supported by a given device. It is not supported on virtual machine guest

Input parameters:

processor_handle device which to query
event_group event group being checked for support

Output: None

Exceptions that can be thrown by amdsmi_gpu_counter_group_supported function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_gpu_counter_group_supported(device, AmdSmiEventGroup.XGMI)
except AmdSmiException as e:
    print(e)

amdsmi_gpu_create_counter#

Description: Creates a performance counter object

Input parameters:

processor_handle device which to query
event_type event group being checked for support

Output: An event handle of the newly created performance counter object

Exceptions that can be thrown by amdsmi_gpu_create_counter function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            event_handle = amdsmi_gpu_create_counter(device, AmdSmiEventType.XGMI_0_REQUEST_TX)
except AmdSmiException as e:
    print(e)

amdsmi_gpu_destroy_counter#

Description: Destroys a performance counter object

Input parameters:

event_handle event handle of the performance counter object

Output: None

Exceptions that can be thrown by amdsmi_gpu_destroy_counter function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            event_handle = amdsmi_gpu_create_counter(device, AmdSmiEventType.XGMI_0_REQUEST_TX)
            amdsmi_gpu_destroy_counter(event_handle)
except AmdSmiException as e:
    print(e)

amdsmi_gpu_control_counter#

Description: Issue performance counter control commands. It is not supported on virtual machine guest

Input parameters:

event_handle event handle of the performance counter object
counter_command command being passed to counter as AmdSmiCounterCommand

Output: None

Exceptions that can be thrown by amdsmi_gpu_control_counter function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            event_handle = amdsmi_gpu_create_counter(device, AmdSmiEventType.XGMI_1_REQUEST_TX)
            amdsmi_gpu_control_counter(event_handle, AmdSmiCounterCommand.CMD_START)
except AmdSmiException as e:
    print(e)

amdsmi_gpu_read_counter#

Description: Read the current value of a performance counter

Input parameters:

event_handle event handle of the performance counter object

Output: Dictionary with fields

Field	Description
`value`	Counter value
`time_enabled`	Time that the counter was enabled in nanoseconds
`time_running`	Time that the counter was running in nanoseconds

Exceptions that can be thrown by amdsmi_gpu_read_counter function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            event_handle = amdsmi_gpu_create_counter(device, AmdSmiEventType.XGMI_1_REQUEST_TX)
            amdsmi_gpu_control_counter(event_handle, AmdSmiCounterCommand.CMD_START)
            amdsmi_gpu_read_counter(event_handle)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_available_counters#

Description: Get the number of currently available counters. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
event_group event group being checked as AmdSmiEventGroup

Output: Number of available counters for the given device of the inputted event group

Exceptions that can be thrown by amdsmi_get_gpu_available_counters function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            available_counters =  amdsmi_get_gpu_available_counters(device, AmdSmiEventGroup.XGMI)
            print(available_counters)
except AmdSmiException as e:
    print(e)

amdsmi_set_gpu_perf_level#

Description: Set a desired performance level for given device. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
perf_level performance level being set as AmdSmiDevPerfLevel

Output: None

Exceptions that can be thrown by amdsmi_set_gpu_perf_level function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_set_gpu_perf_level(device, AmdSmiDevPerfLevel.STABLE_PEAK)
except AmdSmiException as e:
    print(e)

amdsmi_reset_gpu#

Description: Reset the gpu associated with the device with provided device handle It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device

Output: None

Exceptions that can be thrown by amdsmi_reset_gpu function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_reset_gpu(device)
except AmdSmiException as e:
    print(e)

amdsmi_set_gpu_fan_speed#

Description: Set the fan speed for the specified device with the provided speed, in RPMs. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
sensor_idx sensor index as integer
fan_speed the speed to which the function will attempt to set the fan

Output: None

Exceptions that can be thrown by amdsmi_set_gpu_fan_speed function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_set_gpu_fan_speed(device, 0, 1333)
except AmdSmiException as e:
    print(e)

amdsmi_reset_gpu_fan#

Description: Reset the fan to automatic driver control. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
sensor_idx sensor index as integer

Output: None

Exceptions that can be thrown by amdsmi_reset_gpu_fan function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_reset_gpu_fan(device, 0)
except AmdSmiException as e:
    print(e)

amdsmi_set_clk_freq#

Description: Control the set of allowed frequencies that can be used for the specified clock. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
clk_type the type of clock for which the set of frequencies will be modified as a string of AmdSmiClkType. Example AmdSmiClkType.SCLK becomes “SCLK”.
freq_bitmask bitmask indicating the indices of the frequencies that are to be enabled (1) and disabled (0). Only the lowest ::amdsmi_frequencies_t.num_supported bits of this mask are relevant.

Output: None

Exceptions that can be thrown by amdsmi_set_clk_freq function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NO_PERM - Permission Denied
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            freq_bitmask = 0
            amdsmi_set_clk_freq(device, "SCLK", freq_bitmask)
except AmdSmiException as e:
    print(e)

amdsmi_get_soc_pstate#

Description: Get dpm policy information.

Input parameters:

processor_handle handle for the given device
policy_id the policy id to set.

Output: Dictionary with fields

Field	Description
`num_supported`	total number of supported policies
`current_id`	current policy id
`policies`	list of dictionaries containing possible policies

Exceptions that can be thrown by amdsmi_get_soc_pstate function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_INIT - Device not initialized
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            dpm_policies = amdsmi_get_soc_pstate(device)
            print(dpm_policies)
except AmdSmiException as e:
    print(e)

amdsmi_set_soc_pstate#

Description: Set the dpm policy to corresponding policy_id. Typically following: 0(default),1,2,3

Input parameters:

processor_handle handle for the given device
policy_id the policy id to set.

Output: None

Exceptions that can be thrown by amdsmi_set_soc_pstate function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_set_soc_pstate(device, 0)
except AmdSmiException as e:
    print(e)

amdsmi_set_xgmi_plpd#

Description: Set the xgmi per-link power down policy parameter for the processor

Input parameters:

processor_handle handle for the given device
policy_id the xgmi plpd id to set.

Output: None

Exceptions that can be thrown by amdsmi_set_xgmi_plpd function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_set_xgmi_plpd(device, 0)
except AmdSmiException as e:
    print(e)

amdsmi_get_xgmi_plpd#

Description: Get the xgmi per-link power down policy parameter for the processor

Input parameters:

processor_handle handle for the given device

Output: Dict containing information about xgmi per-link power down policy

Field	Description
`num_supported`	The number of supported policies
`current_id`	The current policy index
`policies`	List of policies. (`plpds` marked for deprecation in next major release)

Exceptions that can be thrown by amdsmi_get_xgmi_plpd function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            xgmi_plpd =  amdsmi_get_xgmi_plpd(device)
            print(xgmi_plpd)
except AmdSmiException as e:
    print(e)

amdsmi_set_gpu_overdrive_level#

Description: deprecated Set the overdrive percent associated with the device with provided device handle with the provided value. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device
overdrive_value value to which the overdrive level should be set

Output: None

Exceptions that can be thrown by amdsmi_set_gpu_overdrive_level function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_set_gpu_overdrive_level(device, 0)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_ecc_count#

Description: Retrieve the error counts for a GPU block. It is not supported on virtual machine guest

See RAS Error Count sysfs Interface (AMDGPU RAS Support - Linux Kernel documentation) to learn how these error counts are accessed.

Input parameters:

processor_handle handle for the given device
block The block for which error counts should be retrieved

Output: Dict containing information about error counts

Field	Description
`correctable_count`	Count of correctable errors
`uncorrectable_count`	Count of uncorrectable errors
`deferred_count`	Count of deferred errors

Exceptions that can be thrown by amdsmi_get_gpu_ecc_count function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            ecc_count =  amdsmi_get_gpu_ecc_count(device, AmdSmiGpuBlock.UMC)
            print(ecc_count)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_ecc_enabled#

Description: Retrieve the enabled ECC bit-mask. It is not supported on virtual machine guest

See RAS Error Count sysfs Interface (AMDGPU RAS Support - Linux Kernel documentation) to learn how these error counts are accessed.

Input parameters:

processor_handle handle for the given device

Output: Enabled ECC bit-mask

Exceptions that can be thrown by amdsmi_get_gpu_ecc_enabled function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            enabled =  amdsmi_get_gpu_ecc_enabled(device)
            print(enabled)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_ecc_status#

Description: Retrieve the ECC status for a GPU block. It is not supported on virtual machine guest

See RAS Error Count sysfs Interface (AMDGPU RAS Support - Linux Kernel documentation) to learn how these error counts are accessed.

Input parameters:

processor_handle handle for the given device
block The block for which ECC status should be retrieved

Output: ECC status for a requested GPU block

Exceptions that can be thrown by amdsmi_get_gpu_ecc_status function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            status =  amdsmi_get_gpu_ecc_status(device, AmdSmiGpuBlock.UMC)
            print(status)
except AmdSmiException as e:
    print(e)

amdsmi_status_code_to_string#

Description: Get a description of a provided AMDSMI error status

Input parameters:

status The error status for which a description is desired

Output: String description of the provided error code

Exceptions that can be thrown by amdsmi_status_code_to_string function:

AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    status_str = amdsmi_status_code_to_string(ctypes.c_uint32(0))
    print(status_str)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_compute_process_info#

Description: Get process information about processes currently using GPU

Input parameters: None

Output: List of python dicts each containing a process information

Field	Description
`process_id`	Process ID
`pasid`	PASID (Not working in ROCm 6.4+, Deprecated in 7.0)
`vram_usage`	VRAM usage
`sdma_usage`	SDMA usage in microseconds
`cu_occupancy`	Compute Unit usage in percents
`evicted_time`	Time that queues are evicted on a GPU in milliseconds

note: Sum of the process memory is not expected to be the total memory usage.

Exceptions that can be thrown by amdsmi_get_gpu_compute_process_info function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INSUFFICIENT_SIZE - Insufficient size for operation
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    procs = amdsmi_get_gpu_compute_process_info()
    for proc in procs:
        print(proc)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_compute_process_info_by_pid#

Description: Get process information about processes currently using GPU

Input parameters:

pid The process ID for which process information is being requested

Output: Dict containing a process information

Field	Description
`process_id`	Process ID
`pasid`	PASID (Not working in ROCm 6.4+, deprecating in 7.0)
`vram_usage`	VRAM usage
`sdma_usage`	SDMA usage in microseconds
`cu_occupancy`	Compute Unit usage in percents
`evicted_time`	Time that queues are evicted on a GPU in milliseconds

Exceptions that can be thrown by amdsmi_get_gpu_compute_process_info_by_pid function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_FOUND - Device Not found
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    pid = 0 # << valid pid here
    proc = amdsmi_get_gpu_compute_process_info_by_pid(pid)
    print(proc)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_compute_process_gpus#

Description: Get the device indices currently being used by a process

Input parameters:

pid The process id of the process for which the number of gpus currently being used is requested

Output: List of indices of devices currently being used by the process

Exceptions that can be thrown by amdsmi_get_gpu_compute_process_gpus function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_NOT_FOUND - Device Not found
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    pid = 0 # << valid pid here
    indices = amdsmi_get_gpu_compute_process_gpus(pid)
    print(indices)
except AmdSmiException as e:
    print(e)

amdsmi_gpu_xgmi_error_status#

Description: Retrieve the XGMI error status for a device. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device

Output: XGMI error status for a requested device

Exceptions that can be thrown by amdsmi_gpu_xgmi_error_status function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            status = amdsmi_gpu_xgmi_error_status(device)
            print(status)
except AmdSmiException as e:
    print(e)

amdsmi_reset_gpu_xgmi_error#

Description: Reset the XGMI error status for a device. It is not supported on virtual machine guest

Input parameters:

processor_handle handle for the given device

Output: None

Exceptions that can be thrown by amdsmi_reset_gpu_xgmi_error function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_reset_gpu_xgmi_error(device)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_vendor_name#

Description: Returns the device vendor name

Input parameters:

processor_handle device which to query

Output: device vendor name

Exceptions that can be thrown by amdsmi_get_gpu_vendor_name function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            vendor_name = amdsmi_get_gpu_vendor_name(device)
            print(vendor_name)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_id#

Description: Get the device id associated with the device with provided device handler

Input parameters:

processor_handle device which to query

Output: device id

Exceptions that can be thrown by amdsmi_get_gpu_id function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            dev_id = amdsmi_get_gpu_id(device)
            print(dev_id)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_vram_vendor#

Description: Get the vram vendor string of a gpu device.

Input parameters:

processor_handle device which to query

Output: vram vendor

Exceptions that can be thrown by amdsmi_get_gpu_vram_vendor function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            vram_vendor = amdsmi_get_gpu_vram_vendor(device)
            print(vram_vendor)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_subsystem_id#

Description: Get the subsystem device id associated with the device with provided device handle.

Input parameters:

processor_handle device which to query

Output: subsystem device id

Exceptions that can be thrown by amdsmi_get_gpu_subsystem_id function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            id = amdsmi_get_gpu_subsystem_id(device)
            print(id)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_subsystem_name#

Description: Get the name string for the device subsystem

Input parameters:

processor_handle device which to query

Output: device subsystem

Exceptions that can be thrown by amdsmi_get_gpu_subsystem_name function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            subsystem_nam = amdsmi_get_gpu_subsystem_name(device)
            print(subsystem_nam)
except AmdSmiException as e:
    print(e)

amdsmi_topo_get_numa_node_number#

Description: Retrieve the NUMA CPU node number for a device

Input parameters:

processor_handle device which to query

Output: node number of NUMA CPU for the device

Exceptions that can be thrown by amdsmi_topo_get_numa_node_number function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            node_number = amdsmi_topo_get_numa_node_number(device)
            print(node_number)
except AmdSmiException as e:
    print(e)

amdsmi_topo_get_link_weight#

Description: Retrieve the weight for a connection between 2 GPUs.

Input parameters:

processor_handle_src the source device handle
processor_handle_dest the destination device handle

Output: the weight for a connection between 2 GPUs

Exceptions that can be thrown by amdsmi_topo_get_link_weight function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        processor_handle_src = devices[0]
        processor_handle_dest = devices[1]
        weight = amdsmi_topo_get_link_weight(processor_handle_src, processor_handle_dest)
        print(weight)
except AmdSmiException as e:
    print(e)

amdsmi_get_minmax_bandwidth_between_processors#

Description: Retrieve minimal and maximal io link bandwidth between 2 GPUs.

Input parameters:

processor_handle_src the source device handle
processor_handle_dest the destination device handle

Output: Dictionary with fields:

Field	Description
`min_bandwidth`	minimal bandwidth for the connection
`max_bandwidth`	maximal bandwidth for the connection

Exceptions that can be thrown by amdsmi_get_minmax_bandwidth_between_processors function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        processor_handle_src = devices[0]
        processor_handle_dest = devices[1]
        bandwidth =  amdsmi_get_minmax_bandwidth_between_processors(processor_handle_src, processor_handle_dest)
        print(bandwidth['min_bandwidth'])
        print(bandwidth['max_bandwidth'])
except AmdSmiException as e:
    print(e)

amdsmi_get_link_metrics#

Description: Returns XGMI link metrics information for the given GPU.

Input parameters:

processor_handle — The device handle for which to query link metrics.

Output: Dictionary with fields

Field	Description
`num_links`	Number of XGMI links reported
`bit_rate`	XGMI link bit rate (in appropriate units, e.g., Gbps)
`max_bandwidth`	Maximum XGMI bandwidth (in appropriate units, e.g., GB/s)
`links`	List of dictionaries, one per XGMI link, each with:
`bdf`	BDF string for the destination
`link_type`	The connection type as an int. This should be translated according to the enum amdsmi_link_type_t. Refer to the example below for more details.
`read`	Accumulated read data for this link (e.g., KB)
`write`	Accumulated write data for this link (e.g., KB)

Exceptions that can be thrown by amdsmi_get_link_metrics function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device_num, device in enumerate(devices):
            link_metrics = amdsmi_get_link_metrics(device)
            print(link_metrics['num_links'])
            for idx, links in enumerate(link_metrics['links']):
                print(f"{idx}: {links['bdf']}, {links['read']} KB, {links['write']} KB")
                if links['link_type'] == AmdSmiLinkType.AMDSMI_LINK_TYPE_INTERNAL:
                    print('internal')
                if links['link_type'] == AmdSmiLinkType.AMDSMI_LINK_TYPE_PCIE:
                    print('pcie')
                if links['link_type'] == AmdSmiLinkType.AMDSMI_LINK_TYPE_XGMI:
                    print('xgmi')
                if links['link_type'] == AmdSmiLinkType.AMDSMI_LINK_TYPE_NOT_APPLICABLE:
                    print('not applicable')
                if links['link_type'] == AmdSmiLinkType.AMDSMI_LINK_TYPE_UNKNOWN:
                    print('unknown')
except AmdSmiException as e:
    print(e)

amdsmi_topo_get_link_type#

Description: Retrieve the hops and the connection type between 2 GPUs

Input parameters:

processor_handle_src the source device handle
processor_handle_dest the destination device handle

Output: Dictionary with fields:

Field	Description
`hops`	Number of hops
`type`	The connection type as an int. This should be translated according to the enum amdsmi_link_type_t. Refer to the example below for more details.

Exceptions that can be thrown by amdsmi_topo_get_link_type function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        processor_handle_src = devices[0]
        processor_handle_dest = devices[1]
        link_type = amdsmi_topo_get_link_type(processor_handle_src, processor_handle_dest)
        print(link_type['hops'])
        if link_type['type'] == AmdSmiLinkType.AMDSMI_LINK_TYPE_INTERNAL:
            print('internal')
        if link_type['type'] == AmdSmiLinkType.AMDSMI_LINK_TYPE_PCIE:
            print('pcie')
        if link_type['type'] == AmdSmiLinkType.AMDSMI_LINK_TYPE_XGMI:
            print('xgmi')
        if link_type['type'] == AmdSmiLinkType.AMDSMI_LINK_TYPE_NOT_APPLICABLE:
            print('not applicable')
        if link_type['type'] == AmdSmiLinkType.AMDSMI_LINK_TYPE_UNKNOWN:
            print('unknown')
except AmdSmiException as e:
    print(e)

amdsmi_topo_get_p2p_status#

Description: Retrieve the connection type and P2P capabilities between 2 GPUs

Input parameters:

processor_handle_src the source device handle
processor_handle_dest the destination device handle

Output: Dictionary with fields:

Fields

Description

type

The connection type as an int. This should be translated according to the enum amdsmi_link_type_t. Refer to the example below for more details.

cap

Subfield	Description
`is_iolink_coherent`	1 == True; 0 == False; Uint_max = Undefined
`is_iolink_atomics_32bit`	Supports 32bit atomics
`is_iolink_atomics_64bit`	Supports 64bit atomics
`is_iolink_dma`	Supports DMA
`is_iolink_bi_directional`	Is the IOLink Bidirectional

Exceptions that can be thrown by amdsmi_topo_get_p2p_status function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        processor_handle_src = devices[0]
        processor_handle_dest = devices[1]
        link_type = amdsmi_topo_get_p2p_status(processor_handle_src, processor_handle_dest)
        if link_type['type'] == AmdSmiLinkType.AMDSMI_LINK_TYPE_INTERNAL:
            print('internal')
        if link_type['type'] == AmdSmiLinkType.AMDSMI_LINK_TYPE_PCIE:
            print('pcie')
        if link_type['type'] == AmdSmiLinkType.AMDSMI_LINK_TYPE_XGMI:
            print('xgmi')
        if link_type['type'] == AmdSmiLinkType.AMDSMI_LINK_TYPE_NOT_APPLICABLE:
            print('not applicable')
        if link_type['type'] == AmdSmiLinkType.AMDSMI_LINK_TYPE_UNKNOWN:
            print('unknown')
        print(link_type['caps'])
except AmdSmiException as e:
    print(e)

amdsmi_is_P2P_accessible#

Description: Return P2P availability status between 2 GPUs

Input parameters:

processor_handle_src the source device handle
processor_handle_dest the destination device handle

Output: P2P availability status between 2 GPUs

Exceptions that can be thrown by amdsmi_is_P2P_accessible function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        processor_handle_src = devices[0]
        processor_handle_dest = devices[1]
        accessible = amdsmi_is_P2P_accessible(processor_handle_src, processor_handle_dest)
        print(accessible)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_compute_partition#

Description: Get the compute partition from the given GPU

Input parameters:

processor_handle the device handle

Output: String of the partition type

Exceptions that can be thrown by amdsmi_get_gpu_compute_partition function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
AMDSMI_COMPUTE_PARTITION_INVALID - Invalid compute partition type

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            compute_partition_type = amdsmi_get_gpu_compute_partition(device)
            print(compute_partition_type)
except AmdSmiException as e:
    print(e)

amdsmi_set_gpu_compute_partition#

Description: Set the compute partition to the given GPU. This function does not allow any concurrent operations. Device must be idle and have no workloads when performing set partition operations.

Input parameters:

processor_handle the device handle
compute_partition the type of compute_partition to set

Output: String of the partition type

Exceptions that can be thrown by amdsmi_set_gpu_compute_partition function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NO_PERM - Permission Denied
AMDSMI_STATUS_SETTING_UNAVAILABLE - Setting is not available
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    compute_partition = AmdSmiComputePartitionType.SPX
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_set_gpu_compute_partition(device, compute_partition)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_memory_partition#

Description: Get the memory partition from the given GPU

Input parameters:

processor_handle the device handle

Output: String of the partition type

Exceptions that can be thrown by amdsmi_get_gpu_memory_partition function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            memory_partition_type = amdsmi_get_gpu_memory_partition(device)
            print(memory_partition_type)
except AmdSmiException as e:
    print(e)

amdsmi_set_gpu_memory_partition#

Description: Set the memory partition to the given GPU. This function does not allow any concurrent operations. Devices must be idle and have no workloads when performing set partition operations.

Input parameters:

processor_handle the device handle
memory_partition the type of memory_partition to set

Output: String of the partition type

Exceptions that can be thrown by amdsmi_set_gpu_memory_partition function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NO_PERM - Permission Denied
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    memory_partition = AmdSmiMemoryPartitionType.NPS1
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            amdsmi_set_gpu_memory_partition(device, memory_partition)
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_uma_carveout_info#

Note: This is a kernel UAPI feature (sysfs), not libdrm.

Description: Get UMA carveout (VRAM) configuration information for a GPU. Returns the current carveout index, total number of available options, and a list of option descriptions.

Input parameters:

processor_handle the device handle

Output: Dictionary with fields:

Field	Description
`current_index`	Index of the currently selected carveout option
`num_options`	Total number of available carveout options
`options`	List of dicts, each with `index` (int) and `description` (str)

Exceptions that can be thrown by amdsmi_get_gpu_uma_carveout_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            info = amdsmi_get_gpu_uma_carveout_info(device)
            print(f"Current index: {info['current_index']}")
            print(f"Number of options: {info['num_options']}")
            for opt in info['options']:
                print(f"  Option {opt['index']}: {opt['description']}")
except AmdSmiException as e:
    print(e)

amdsmi_set_gpu_uma_carveout#

Note: This is a kernel UAPI feature (sysfs), not libdrm.

Description: Set the UMA carveout (VRAM) size for a GPU by selecting one of the available option indices. A system reboot is required for the change to take effect.

Input parameters:

processor_handle the device handle
option_index index of the carveout option to set (from amdsmi_get_gpu_uma_carveout_info)

Output: None

Exceptions that can be thrown by amdsmi_set_gpu_uma_carveout function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            # Set carveout to option index 2
            amdsmi_set_gpu_uma_carveout(device, 2)
except AmdSmiException as e:
    print(e)

amdsmi_get_ttm_info#

Note: This is a kernel UAPI feature (modprobe.d), not libdrm.

Description: Get Translation Table Manager (TTM) memory information. TTM manages shared memory (GTT) between CPU and GPU. This is a system-wide setting, not per-GPU.

Input parameters: None

Output: Dictionary with fields:

Field	Description
`current_pages`	Current TTM pages limit

Exceptions that can be thrown by amdsmi_get_ttm_info function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported

Example:

try:
    info = amdsmi_get_ttm_info()
    print(f"Current TTM pages limit: {info['current_pages']}")
except AmdSmiException as e:
    print(e)

amdsmi_set_ttm_pages_limit#

Note: This is a kernel UAPI feature (modprobe.d), not libdrm.

Description: Set the TTM memory limit in pages. TTM manages shared memory (GTT) between CPU and GPU. This is a system-wide setting. A system reboot is required for the change to take effect.

Input parameters:

pages number of pages to set as TTM limit

Output: None

Exceptions that can be thrown by amdsmi_set_ttm_pages_limit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    # Set TTM limit to 1048576 pages (4 GB with 4K pages)
    amdsmi_set_ttm_pages_limit(1048576)
except AmdSmiException as e:
    print(e)

amdsmi_reset_ttm_pages_limit#

Note: This is a kernel UAPI feature (modprobe.d), not libdrm.

Description: Reset the TTM memory limit to the system default. This is a system-wide setting. A system reboot is required for the change to take effect.

Input parameters: None

Output: None

Exceptions that can be thrown by amdsmi_reset_ttm_pages_limit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NO_PERM - Permission Denied

Example:

try:
    amdsmi_reset_ttm_pages_limit()
except AmdSmiException as e:
    print(e)

amdsmi_get_gpu_accelerator_partition_profile#

Note: CURRENTLY HARDCODED TO RETURN EMPTY VALUES

Description: Get partition information for target device

Input parameters:

processor_handle the device handle

Output: Dictionary with fields:

Field	Description
`partition_id`	ID of the partition on the GPU provided
`partition_profile`	Dict containing partition data (TBD)

Exceptions that can be thrown by amdsmi_get_gpu_accelerator_partition_profile function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            partition_id = amdsmi_get_gpu_accelerator_partition_profile(device)["partition_id"]
            print(partition_id)
except AmdSmiException as e:
    print(e)

amdsmi_get_xgmi_info#

Description: Returns XGMI information for the GPU.

Input parameters:

processor_handle device handle

Output: Dictionary with fields:

Field	Description
`xgmi_lanes`	xgmi lanes
`xgmi_hive_id`	xgmi hive id
`xgmi_node_id`	xgmi node id
`index`	index

Exceptions that can be thrown by amdsmi_get_xgmi_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            xgmi_info = amdsmi_get_xgmi_info(device)
            print(xgmi_info['xgmi_lanes'])
            print(xgmi_info['xgmi_hive_id'])
            print(xgmi_info['xgmi_node_id'])
            print(xgmi_info['index'])
except AmdSmiException as e:
    print(e)

amdsmi_get_link_topology_nearest#

Description: Retrieve the set of GPUs that are nearest to a given device at a specific interconnectivity level.

Input parameters:

processor_handle The identifier of the given device.
link_type The AmdSmiLinkType level to search for nearest devices

Output: Dictionary holding the following fields.

processor_list list of all nearest device handlers found

Exceptions that can be thrown by amdsmi_get_link_topology_nearest function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    amdsmi_init()

    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs found on machine")
        exit()
    else:
        print(amdsmi_get_gpu_device_uuid(devices[0]))

    nearest_gpus = amdsmi_get_link_topology_nearest(devices[0], AmdSmiLinkType.AMDSMI_LINK_TYPE_PCIE)
    if (len(nearest_gpus['processor_list'])) == 0:
        print("No nearest GPUs found on machine")
    else:
        print("Nearest GPUs")
        for gpu in nearest_gpus['processor_list']:
            print(amdsmi_get_gpu_device_uuid(gpu))

except AmdSmiException as e:
    print(e)
finally:
    try:
        amdsmi_shut_down()
    except AmdSmiException as e:
        print(e)

amdsmi_get_gpu_virtualization_mode#

Description: Retrieve the virtualization mode for the selected GPU.

Input parameters:

processor_handle The identifier of the given device.

Output: Dictionary holding the following fields.

mode AmdSmiVirtualizationMode; an IntEnum denoting the possible virtualization modes Field | Description —|— UNKNOWN | Virtualization mode not detected BAREMETAL | Baremetal platform detected HOST | Host/Hypervisor platform detected GUEST | Guest/Virtual Machine detected PASSTHROUGH | GPU Passthrough mode detected

Exceptions that can be thrown by amdsmi_get_gpu_virtualization_mode function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    device_handles = amdsmi_interface.amdsmi_get_processor_handles()
    for dev in device_handles:
        virtualization_info = amdsmi_interface.amdsmi_get_gpu_virtualization_mode(dev)
        print(virtualization_info['mode'])
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_affinity_with_scope#

Description: Returns list of bitmask information for the given GPU.

Input parameters:

processor_handle device which to query

Output: List with fields

Field	Description
`array_size`	array size = (num of sockets * num of cores)/ size of 64-bit
`scope`	enum value for numa or socket affinity

Exceptions that can be thrown by amdsmi_get_gpu_vram_info function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_FOUND - Device Not found
AMDSMI_STATUS_INVAL - Invalid parameters

Example:

try:
    devices = amdsmi_get_processor_handles()
    if len(devices) == 0:
        print("No GPUs on machine")
    else:
        for device in devices:
            bitmask = amdsmi_get_cpu_affinity_with_scope(device)
            print(bitmask['size'])
except AmdSmiException as e:
    print(e)

CPU APIs#

amdsmi_get_processor_info#

Note: CURRENTLY HARDCODED TO RETURN EMPTY VALUES

Description: Return processor name

Input parameters: processor_handle processor handle

Output: Processor name

Exceptions that can be thrown by amdsmi_get_processor_info function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_processor_handles()
    if len(processor_handles) == 0:
        print("No processors on machine")
    else:
        for processor in processor_handles:
            print(amdsmi_get_processor_info(processor))
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_hsmp_proto_ver#

Description: Get the hsmp protocol version.

Output: amdsmi hsmp protocol version

Exceptions that can be thrown by amdsmi_get_cpu_hsmp_proto_ver function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            version = amdsmi_get_cpu_hsmp_proto_ver(processor)
            print(version)
except AmdSmiException as e:
    print(e)

amdsmi_get_threads_per_core#

Description: Get number of threads per core.

Output: cpu family

Exceptions that can be thrown by amdsmi_get_cpu_family function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
     threads_per_core = amdsmi_get_threads_per_core()
     print(threads_per_core)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_hsmp_driver_version#

Description: Get the HSMP Driver version.

Output: amdsmi HSMP Driver version

Exceptions that can be thrown by amdsmi_get_cpu_hsmp_driver_version function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            version = amdsmi_get_cpu_hsmp_driver_version(processor)
            print(version)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_smu_fw_version#

Description: Get the SMU Firmware version.

Output: amdsmi SMU Firmware version

Exceptions that can be thrown by amdsmi_get_cpu_smu_fw_version function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            version = amdsmi_get_cpu_smu_fw_version(processor)
            print(version)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_prochot_status#

Description: Get the CPU’s prochot status.

Output: amdsmi cpu prochot status

Exceptions that can be thrown by amdsmi_get_cpu_prochot_status function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            prochot = amdsmi_get_cpu_prochot_status(processor)
            print(prochot)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_fclk_mclk#

Description: Get the Data fabric clock and Memory clock in MHz.

Output: amdsmi data fabric clock and memory clock

Exceptions that can be thrown by amdsmi_get_cpu_fclk_mclk function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            clk = amdsmi_get_cpu_fclk_mclk(processor)
            for fclk, mclk in clk.items():
                print(fclk)
                print(mclk)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_cclk_limit#

Description: Get the core clock in MHz.

Output: amdsmi core clock

Exceptions that can be thrown by amdsmi_get_cpu_cclk_limit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            cclk_limit = amdsmi_get_cpu_cclk_limit(processor)
            print(cclk_limit)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_socket_current_active_freq_limit#

Description: Get current active frequency limit of the socket.

Output: amdsmi frequency value in MHz and frequency source name

Exceptions that can be thrown by amdsmi_get_cpu_socket_current_active_freq_limit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            freq_limit = amdsmi_get_cpu_socket_current_active_freq_limit(processor)
            for freq, src in freq_limit.items():
                print(freq)
                print(src)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_socket_freq_range#

Description: Get socket frequency range

Output: amdsmi maximum frequency and minimum frequency

Exceptions that can be thrown by amdsmi_get_cpu_socket_freq_range function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            freq_range = amdsmi_get_cpu_socket_freq_range(processor)
            for fmax, fmin in freq_range.items():
                print(fmax)
                print(fmin)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_core_current_freq_limit#

Description: Get socket frequency limit of the core

Output: amdsmi frequency

Exceptions that can be thrown by amdsmi_get_cpu_core_current_freq_limit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpucore_handles()
    if len(processor_handles) == 0:
        print("No CPU cores on machine")
    else:
        for processor in processor_handles:
            freq_limit = amdsmi_get_cpu_core_current_freq_limit(processor)
            print(freq_limit)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_socket_power#

Description: Get the socket power.

Output: amdsmi socket power

Exceptions that can be thrown by amdsmi_get_cpu_socket_power function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            sock_power = amdsmi_get_cpu_socket_power(processor)
            print(sock_power)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_socket_power_cap#

Description: Get the socket power cap.

Output: amdsmi socket power cap

Exceptions that can be thrown by amdsmi_get_cpu_socket_power_cap function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            sock_power = amdsmi_get_cpu_socket_power_cap(processor)
            print(sock_power)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_socket_power_cap_max#

Description: Get the socket power cap max.

Output: amdsmi socket power cap max

Exceptions that can be thrown by amdsmi_get_cpu_socket_power_cap_max function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            sock_power = amdsmi_get_cpu_socket_power_cap_max(processor)
            print(sock_power)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_pwr_svi_telemetry_all_rails#

Description: Get the SVI based power telemetry for all rails.

Output: amdsmi svi based power value

Exceptions that can be thrown by amdsmi_get_cpu_pwr_svi_telemetry_all_rails function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            power = amdsmi_get_cpu_pwr_svi_telemetry_all_rails(processor)
            print(power)
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_socket_power_cap#

Description: Set the power cap value for a given socket.

Input: amdsmi socket power cap value

Exceptions that can be thrown by amdsmi_set_cpu_socket_power_cap function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            power = amdsmi_set_cpu_socket_power_cap(processor, 1000)
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_pwr_efficiency_mode#

Description: Set the power efficiency profile policy.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to configure
power_efficiency_mode (int): Power efficiency mode to be set (0-5):
utilization (int, optional): Utilization for balanced core modes (0-100)(%). Valid only if mode is 4 or 5 and Family 1Ah Models 50h-57h onwards
ppt_limit (int, optional): PPT limit in mW. Valid only if mode is 4 or 5 and Family 1Ah Models 50h-57h onwards

Output: Dictionary containing the power efficiency mode information:

power_efficiency_mode (int): Mode value
utilization (int): Utilization point for balanced core modes (0-100)(%), if applicable
ppt_limit (float): PPT Limit value in Watts if applicable

Exceptions that can be thrown by amdsmi_set_cpu_pwr_efficiency_mode function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                # This has been tested on CPU family 0x1A model 0x50, so with power efficiency mode 4 , utilization and ppt limit are valid
                power_efficiency_mode = 4    # Use mode
                utilization = 100      # Use Util 100%
                ppt_limit = 1000  # Use PPT Limit 1000 mW
                updated_util, updated_ppt_limit = amdsmi_set_cpu_pwr_efficiency_mode(processor, power_efficiency_mode, utilization, ppt_limit)
                ppt_limit_watts = updated_ppt_limit/1000.0  # Convert milliwatts to watts
                print(f"CPU: {i}")
                print(f"    PWR_EFF_MODE:")
                print(f"    	MODE: {power_efficiency_mode}")
                # Only show utilization and ppt_limit for modes 4 and 5
                if power_efficiency_mode in [4, 5]:
                    print(f"        UTIL: {updated_util}%")
                    print(f"        PPT_LIMIT: {ppt_limit_watts:.3f} Watts")
                    print()
                else:
                    # For power efficiency mode 0-3, utilization and ppt_limit are not displayed
                    pass
                print(f"        RESPONSE: Set power efficiency mode operation successful")
            except AmdSmiException as e:
                print(f"Failed to set power efficiency mode for CPU {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_pwr_efficiency_mode#

Description: Get the power efficiency profile policy. This function retrieves the CPU Power efficiency mode.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to configure

Output: Dictionary containing the power efficiency mode information:

power_efficiency_mode (int): Power efficiency mode (0-5):
utilization (int, optional): Utilization point for balanced core modes (0-100)(%). Valid only if mode is set as 4 or 5 and Family 1Ah Models 50h-57h onwards
ppt_limit (int, optional): PPT limit in Watts. Valid only if mode is set as 4 or 5 and Family 1Ah Models 50h-57h onwards

Exceptions that can be thrown by amdsmi_get_cpu_pwr_efficiency_mode function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                # This has been tested on CPU family 0x1A model 0x50, so with mode 4 , utilization and ppt limit are valid
                power_efficiency_mode, utilization, ppt_limit = amdsmi_get_cpu_pwr_efficiency_mode(processor)
                print(f"CPU: {i}")
                print(f"    PWR_EFF_MODE:")
                print(f"    	MODE: {power_efficiency_mode}")
                # Only show utilization and ppt_limit for modes 4 and 5
                if power_efficiency_mode in [4, 5]:
                    print(f"    	UTIL: {utilization}%")
                    print(f"    	PPT_LIMIT: {ppt_limit:.3f} Watts")
                    print()
                else:
                    # For modes 0-3, utilization and ppt_limit are not displayed
                    pass
            except AmdSmiException as e:
                print(f"Failed to get power efficiency mode for CPU {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_core_boostlimit#

Description: Get boost limit of the cpu core

Output: amdsmi frequency

Exceptions that can be thrown by amdsmi_get_cpu_core_boostlimit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpucore_handles()
    if len(processor_handles) == 0:
        print("No CPU cores on machine")
    else:
        for processor in processor_handles:
            boost_limit = amdsmi_get_cpu_core_boostlimit(processor)
            print(boost_limit)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_socket_c0_residency#

Description: Get the cpu socket C0 residency.

Output: amdsmi C0 residency value

Exceptions that can be thrown by amdsmi_get_cpu_socket_c0_residency function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            c0_residency = amdsmi_get_cpu_socket_c0_residency(processor)
            print(c0_residency)
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_core_boostlimit#

Description: Set the cpu core boost limit.

Output: amdsmi boostlimit value

Exceptions that can be thrown by amdsmi_set_cpu_core_boostlimit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpucore_handles()
    if len(processor_handles) == 0:
        print("No CPU cores on machine")
    else:
        for processor in processor_handles:
            boost_limit = amdsmi_set_cpu_core_boostlimit(processor, 1000)
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_socket_boostlimit#

Description: Set the cpu socket boost limit.

Input: amdsmi boostlimit value

Exceptions that can be thrown by amdsmi_set_cpu_socket_boostlimit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            boost_limit = amdsmi_set_cpu_socket_boostlimit(processor, 1000)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_ddr_bw#

Description: Get the CPU DDR Bandwidth.

Output: amdsmi ddr bandwidth data

Exceptions that can be thrown by amdsmi_get_cpu_ddr_bw function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            ddr_bw = amdsmi_get_cpu_ddr_bw(processor)
            print(ddr_bw['max_bw'])
            print(ddr_bw['utilized_bw'])
            print(ddr_bw['utilized_pct'])
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_socket_temperature#

Description: Get the socket temperature.

Output: amdsmi temperature value

Exceptions that can be thrown by amdsmi_get_cpu_socket_temperature function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            ptmon = amdsmi_get_cpu_socket_temperature(processor)
            print(ptmon)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_dimm_temp_range_and_refresh_rate#

Description: Get DIMM temperature range and refresh rate.

Output: amdsmi dimm metric data

Exceptions that can be thrown by amdsmi_get_cpu_dimm_temp_range_and_refresh_rate function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    dimm_addr =0
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            dimm = amdsmi_get_cpu_dimm_temp_range_and_refresh_rate(processor, dimm_addr)
            print(dimm)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_dimm_power_consumption#

Description: amdsmi_get_cpu_dimm_power_consumption.

Output: amdsmi dimm power consumption value

Exceptions that can be thrown by amdsmi_get_cpu_dimm_power_consumption function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    dimm_addr = 0
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            dimm = amdsmi_get_cpu_dimm_power_consumption(processor, dimm_addr)
            print(dimm['power'])
            print(dimm['update_rate'])
            print(dimm['dimm_addr'])
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_dimm_thermal_sensor#

Description: Get DIMM thermal sensor value.

Output: amdsmi dimm temperature data

Exceptions that can be thrown by amdsmi_get_cpu_dimm_thermal_sensor function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    dimm_addr = 0
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            dimm = amdsmi_get_cpu_dimm_thermal_sensor(processor,dimm_addr)
            print(dimm['sensor'])
            print(dimm['update_rate'])
            print(dimm['dimm_addr'])
            print(dimm['temp'])
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_xgmi_width#

Description: Set xgmi width.

Input: amdsmi xgmi width

Exceptions that can be thrown by amdsmi_set_cpu_xgmi_width function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            xgmi_width = amdsmi_set_cpu_xgmi_width(processor, 0, 100)
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_gmi3_link_width_range#

Description: Set gmi3 link width range.

Input: minimum & maximum link width to be set.

Exceptions that can be thrown by amdsmi_set_cpu_gmi3_link_width_range function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            gmi_link_width = amdsmi_set_cpu_gmi3_link_width_range(processor, 0, 100)
except AmdSmiException as e:
    print(e)

amdsmi_cpu_apb_enable#

Description: Enable APB.

Input: amdsmi processor handle

Exceptions that can be thrown by amdsmi_cpu_apb_enable function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            apb_enable = amdsmi_cpu_apb_enable(processor)
except AmdSmiException as e:
    print(e)

amdsmi_cpu_apb_disable#

Description: Disable APB.

Input: pstate value

Exceptions that can be thrown by amdsmi_cpu_apb_disable function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            apb_disable = amdsmi_cpu_apb_disable(processor, 0)
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_socket_lclk_dpm_level#

Description: Set NBIO lclk dpm level value.

Input: nbio id, min value, max value

Exceptions that can be thrown by amdsmi_set_cpu_socket_lclk_dpm_level function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    socket_handles = amdsmi_get_cpusocket_handles()
    if len(socket_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for socket in socket_handles:
            nbio = amdsmi_set_cpu_socket_lclk_dpm_level(socket, 0, 0, 2)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_socket_lclk_dpm_level#

Description: Get NBIO LCLK dpm level.

Output: nbio id

Exceptions that can be thrown by amdsmi_get_cpu_socket_lclk_dpm_level function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            nbio = amdsmi_get_cpu_socket_lclk_dpm_level(processor, 0)
            print(nbio['nbio_max_dpm_level'])
            print(nbio['nbio_max_dpm_level'])
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_pcie_link_rate#

Description: Set pcie link rate.

Input: rate control value

Exceptions that can be thrown by amdsmi_set_cpu_pcie_link_rate function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            link_rate = amdsmi_set_cpu_pcie_link_rate(processor, 0)
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_df_pstate_range#

Description: Set df pstate range.

Input: max pstate, min pstate

Exceptions that can be thrown by amdsmi_set_cpu_df_pstate_range function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            pstate_range = amdsmi_set_cpu_df_pstate_range(processor, 0, 2)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_current_io_bandwidth#

Description: Get current input output bandwidth.

Output: link id and bw type to which io bandwidth to be obtained

Exceptions that can be thrown by amdsmi_get_cpu_current_io_bandwidth function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            io_bw = amdsmi_get_cpu_current_io_bandwidth(processor)
            print(io_bw)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_current_xgmi_bw#

Description: Get current xgmi bandwidth.

Output: amdsmi link id and bw type to which xgmi bandwidth to be obtained

Exceptions that can be thrown by amdsmi_get_cpu_current_xgmi_bw function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        encoding = 0
        link_name = "P0"
        for processor in processor_handles:
            xgmi_bw = amdsmi_get_cpu_current_xgmi_bw(processor, encoding, link_name)
            print(xgmi_bw)
except AmdSmiException as e:
    print(e)

amdsmi_get_hsmp_metrics_table_version#

Description: Get HSMP metrics table version.

Output: amdsmi HSMP metrics table version

Exceptions that can be thrown by amdsmi_get_hsmp_metrics_table_version function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            met_ver = amdsmi_get_hsmp_metrics_table_version(processor)
            print(met_ver)
except AmdSmiException as e:
    print(e)

amdsmi_get_hsmp_metrics_table#

Description: Get HSMP metrics table

Output: HSMP metric table data

Exceptions that can be thrown by amdsmi_get_hsmp_metrics_table function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            mtbl = amdsmi_get_hsmp_metrics_table(processor)
            print(mtbl['accumulation_counter'])
            print(mtbl['max_socket_temperature'])
            print(mtbl['max_vr_temperature'])
            print(mtbl['max_hbm_temperature'])
            print(mtbl['socket_power_limit'])
            print(mtbl['max_socket_power_limit'])
            print(mtbl['socket_power'])
except AmdSmiException as e:
    print(e)

amdsmi_first_online_core_on_cpu_socket#

Description: Get first online core on cpu socket.

Output: first online core on cpu socket

Exceptions that can be thrown by amdsmi_first_online_core_on_cpu_socket function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles:
            pcore_ind = amdsmi_first_online_core_on_cpu_socket(processor)
            print(pcore_ind)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_family#

Description: Get cpu family.

Output: cpu family

Exceptions that can be thrown by amdsmi_get_cpu_family function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
     cpu_family = amdsmi_get_cpu_family()
     print(cpu_family)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_model#

Description: Get cpu model.

Output: cpu model

Exceptions that can be thrown by amdsmi_get_cpu_model function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
     cpu_model = amdsmi_get_cpu_model()
     print(cpu_model)
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_model_name#

Description: Get cpu model name.

Output: cpu model name

Exceptions that can be thrown by amdsmi_get_cpu_model_name function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPU sockets on machine")
    else:
        for processor in processor_handles: 
            cpu_model_name = amdsmi_get_cpu_model_name(processor)
            print(cpu_model_name)
except AmdSmiException as e:
    print(e)

No amdsmi_init APIs#

amdsmi_get_lib_version#

Description: Get the build version information for the currently running build of AMDSMI. This function doesn’t require amdsmi library init.

Output: amdsmi build version

Exceptions that can be thrown by amdsmi_get_lib_version function:

AmdSmiLibraryException
AmdSmiParameterException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

try:
    version = amdsmi_get_lib_version()
    print(version)
except AmdSmiException as e:
    print(e)

amdsmi_get_rocm_version#

Description: This function attempts to retrieve the ROCm version by loading the librocm-core.so shared library. This function doesn’t require amdsmi library init.

Output: Tuple (bool, str) containing rocm_load_status and version_message

Exceptions that can be thrown by amdsmi_get_rocm_version function:

AmdSmiLibraryException

Example:

try:
    import amdsmi
    rocm_load_status, version_message = amdsmi_get_rocm_version()
    print(f"ROCm load status: {rocm_load_status}")
    print(f"ROCm version msg: {version_message}")
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_xgmi_pstate_range#

Description: Set the Min and Max XGMI PState Range. This API configures the XGMI P-State frequency range for the specified processor socket.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to configure
min_pstate (int): Minimum XGMI P-State value
max_pstate (int): Maximum XGMI P-State value

Output: None

Exceptions that can be thrown by amdsmi_set_cpu_xgmi_pstate_range function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
‘AMDSMI_STATUS_NO_PERM’ - Permission Denied

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                min_pstate = 1
                max_pstate = 1
                amdsmi_set_cpu_xgmi_pstate_range(processor, min_pstate, max_pstate)
                print(f"CPU: {i}")
                print(f"    XGMI_PSTATE_RANGE:")
                print(f"        RESPONSE: Set, MIN_PSTATE: {min_pstate}, MAX_PSTATE: {max_pstate}, successful")
                print()
            except AmdSmiException as e:
                print(f"Failed to set xgmi pstate range for cpu {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_xgmi_pstate_range#

Description: Get the Min and Max XGMI PState Range. This API retrieves the current XGMI P-State range configuration for the specified processor socket.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query

Output: Dictionary containing XGMI PState range values: - min_pstate: Current minimum XGMI P-State setting - max_pstate: Current maximum XGMI P-State setting

Exceptions that can be thrown by amdsmi_get_cpu_xgmi_pstate_range function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                pstate_range = amdsmi_get_cpu_xgmi_pstate_range(processor)

                print(f"CPU: {i}")
                print(f"    XGMI_PSTATE_RANGE:")
                print(f"        MIN_PSTATE: {pstate_range['min_pstate']}")
                print(f"        MAX_PSTATE: {pstate_range['max_pstate']}")
                print()
            except AmdSmiException as e:
                print(f"Failed to get XGMI PState range for CPU {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_rail_isofreq_policy#

Description: Set the CPU Rail Isofrequency Policy. This function configures the frequency policy for CPU power rails.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query
value (int): Input policy value indicating the isofrequency setting:
- 0: Independent control enabled (each rail has an independent frequency limit)
- 1: Independent control disabled (all cores on both rails or each rail - have the same frequency limit)

Output: None

Exceptions that can be thrown by amdsmi_set_cpu_rail_isofreq_policy function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
‘AMDSMI_STATUS_NO_PERM’ - Permission Denied

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                value = 1
                amdsmi_set_cpu_rail_isofreq_policy(processor, value)
                print(f"CPU: {i}")
                print(f"    RAILISOFREQ_POLICY:")
                print(f"        RESPONSE: Set, VALUE: {value}, successful")
                print()
            except AmdSmiException as e:
                print(f"Failed to set cpurailiso frequency policy for cpu {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_rail_isofreq_policy#

Description: Get the CPU Rail Isofrequency Policy. This function retrieves the current frequency policy configuration for CPU power rails.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query

Output: Integer representing the CPU rail isofrequency policy: - 0: Independent control enabled (each rail has an independent frequency limit) - 1: Independent control disabled (all cores on both rails or each rail - have the same frequency limit)

Exceptions that can be thrown by amdsmi_get_cpu_rail_isofreq_policy function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                cpurailisofreq_policy = amdsmi_get_cpu_rail_isofreq_policy(processor)
                print(f"CPU: {i}")
                print(f"    RAILISOFREQ_POLICY:")
                print(f"        VALUE: {cpurailisofreq_policy}")
                print()
            except AmdSmiException as e:
                print(f"Failed to get cpurailiso frequency policy for cpu {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_dfc_ctrl#

Description: Set the DFCState enabling control. DFCState is a low power state used for I/O Die (IOD).

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query
value (int): DFCState control value:
- 0: Disable DFCState control
- 1: Enable DFCState control

Output: None

Exceptions that can be thrown by amdsmi_set_cpu_dfc_ctrl function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
‘AMDSMI_STATUS_NO_PERM’ - Permission Denied

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                value = 1
                amdsmi_set_cpu_dfc_ctrl(processor, value)
                print(f"CPU: {i}")
                print(f"    DFCSTATE_CTRL:")
                print(f"        RESPONSE: Set, VALUE: {value}, successful")
                print()
            except AmdSmiException as e:
                print(f"Failed to set dfcstate control status for cpu {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_dfc_ctrl#

Description: Get the current DFCState enabling control status. DFCState is a low power state used for I/O Die (IOD).

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query

Output: Integer representing the DFCState control status: - 0: DFCState control is disabled - 1: DFCState control is enabled

Exceptions that can be thrown by amdsmi_get_cpu_dfc_ctrl function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                dfcstatectrl_status = amdsmi_get_cpu_dfc_ctrl(processor)

                print(f"CPU: {i}")
                print(f"    DFCSTATE_CTRL:")
                print(f"        VALUE: {dfcstatectrl_status}")
                print()
            except AmdSmiException as e:
                print(f"Failed to get dfcstate control status for cpu {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_pc6_enable#

Description: Set the PC6 (Package C6) enable state. PC6 is a low power state used for package-level power management.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query
value (int): PC6 enable state value:
- 0: Disable PC6 state
- 1: Enable PC6 state

Output: None

Exceptions that can be thrown by amdsmi_set_cpu_pc6_enable function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
‘AMDSMI_STATUS_NO_PERM’ - Permission Denied

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                value = 1
                amdsmi_set_cpu_pc6_enable(processor, value)
                print(f"CPU: {i}")
                print(f"    PC6_ENABLE:")
                print(f"        RESPONSE: Set, VALUE: {value}, successful")
                print()
            except AmdSmiException as e:
                print(f"Failed to set PC6 enable status for cpu {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_pc6_enable#

Description: Get the current PC6 (Package C6) enable state. PC6 is a low power state used for package-level power management.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query

Output: Integer representing the PC6 enable state: - 0: PC6 state is disabled - 1: PC6 state is enabled

Exceptions that can be thrown by amdsmi_get_cpu_pc6_enable function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                pc6_enable_status = amdsmi_get_cpu_pc6_enable(processor)

                print(f"CPU: {i}")
                print(f"    PC6_ENABLE:")
                print(f"        VALUE: {pc6_enable_status}")
                print()
            except AmdSmiException as e:
                print(f"Failed to get PC6 enable status for cpu {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_cc6_enable#

Description: Set the CC6 (Core C6) enable state. CC6 is a low power state used for CPU core-level power management.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query
value (int): CC6 enable state value:
- 0: Disable CC6 state
- 1: Enable CC6 state

Output: None

Exceptions that can be thrown by amdsmi_set_cpu_cc6_enable function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
‘AMDSMI_STATUS_NO_PERM’ - Permission Denied

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                value = 1
                amdsmi_set_cpu_cc6_enable(processor, value)
                print(f"CPU: {i}")
                print(f"    CC6_ENABLE:")
                print(f"        RESPONSE: Set, VALUE: {value}, successful")
                print()
            except AmdSmiException as e:
                print(f"Failed to set CC6 enable status for cpu {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_cc6_enable#

Description: Get the current CC6 (Core C6) enable state. CC6 is a low power state used for CPU core-level power management.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query

Output: Integer representing the CC6 enable state: - 0: CC6 state is disabled - 1: CC6 state is enabled

Exceptions that can be thrown by amdsmi_get_cpu_cc6_enable function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                cc6_enable_status = amdsmi_get_cpu_cc6_enable(processor)
                print(f"CPU: {i}")
                print(f"    CC6_ENABLE:")
                print(f"        VALUE: {cc6_enable_status}")
                print()
            except AmdSmiException as e:
                print(f"Failed to get CC6 enable status for cpu {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_dimm_sb_reg#

Description: Read data from DIMM sideband register using JEDEC Sideband Bus protocol. This API executes a four-byte read transaction at a specified register offset in a designated device on the target DIMM.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query
dimm_addr (int): DIMM address identifier
lid (int): Local Identifier (LID) for the device on DIMM:
- 0x2: TS0 (Thermal Sensor 0)
- 0x6: TS1 (Thermal Sensor 1)
- 0xA: SPD Hub
reg_offset (int): Register offset within the specified register space (hexadecimal)
reg_space (int): Register space selector:
- 0: Volatile register space
- 1: Non-volatile memory (NVM) register space

Output: Integer representing the 4-byte data read from the register

Exceptions that can be thrown by amdsmi_get_cpu_dimm_sb_reg function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                # Read from DIMM sideband register (SPD Hub, volatile space)
                dimm_addr = 0x87  # Example DIMM address
                lid = 0xA         # SPD Hub
                reg_offset = 0x00 # Register offset
                reg_space = 1     # Volatile register space
                data = amdsmi_get_cpu_dimm_sb_reg(processor, dimm_addr, lid, reg_offset, reg_space)
                print(f"CPU: {i}")
                print(f"    DIMM_SB_REG:")
                print(f"        DIMMADDRESS: 0x{dimm_addr:X}")
                print(f"        LID: 0x{lid:X}")
                print(f"        OFFSET: 0x{reg_offset:X}")
                print(f"        REGSPACE: 0x{reg_space:X}")
                print(f"        DATA: 0x{data:X}")
                print()
            except AmdSmiException as e:
                print(f"Failed to read DIMM sideband register for cpu {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_dimm_sb_reg#

Description: Write data to DIMM sideband register using JEDEC Sideband Bus protocol. This API executes a four-byte write transaction at a specified register offset in a designated device on the target DIMM.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query
dimm_addr (int): DIMM address identifier
lid (int): Local Identifier (LID) for the device on DIMM:
- 0x2: TS0 (Thermal Sensor 0)
- 0x6: TS1 (Thermal Sensor 1)
- 0xA: SPD Hub
reg_offset (int): Register offset within the specified register space (hexadecimal)
reg_space (int): Register space selector:
- 0: Volatile register space
- 1: Non-volatile memory (NVM) register space
write_data (int): 4-byte data value to write to the target register (hexadecimal)

Output: True on successful write operation

Exceptions that can be thrown by amdsmi_set_cpu_dimm_sb_reg function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
‘AMDSMI_STATUS_NO_PERM’ - Permission Denied

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                # Write to DIMM sideband register (SPD Hub, volatile space)
                dimm_addr = 0x87  # Example DIMM address
                lid = 0xA         # SPD Hub
                reg_offset = 0x00 # Register offset
                reg_space = 1     # Volatile register space
                date = 0x12345678
                amdsmi_set_cpu_dimm_sb_reg(processor, dimm_addr, lid, reg_offset, reg_space, data)
                print(f"CPU: {i}")
                print(f"    DIMM_SB_REG:")
                print(f"        RESPONSE: Set, VALUE: 0x{data:X}, successful")
                print()
            except AmdSmiException as e:
                print(f"Failed to write DIMM sideband register for cpu {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_core_ccd_power#

Description: Get the power consumption of a specific CCD (Core Complex Die) within a CPU socket. This function reads the average power consumed by the specified CCD.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query
core0 (int): Core 0 CCD power to query

Output: Integer representing the CCD power consumption in watts (W)

Exceptions that can be thrown by amdsmi_get_cpu_core_ccd_power function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    core_handles = amdsmi_get_cpucore_handles()
    if len(core_handles) == 0:
        print("No CPU cores on machine")
    else:
        core0 = core_handles[0]   # <-- pick core 0 explicitly
        power = amdsmi_get_cpu_core_ccd_power(core0)
        print("CPU: 0")
        print("    CCD_POWER:")
        print(f"        VALUE: {power:.3f} Watts")
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_tdelta#

Description: Read the TDELTA value for a CPU socket.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query

Output: Integer representing the TDELTA value

Exceptions that can be thrown by amdsmi_get_cpu_tdelta function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                # Read TDELTA value
                tdelta_value = amdsmi_get_cpu_tdelta(processor)
                print(f"CPU: {i}")
                print(f"    TDELTA:")
                print(f"        VALUE: {tdelta_value}")
                print()
            except AmdSmiException as e:
                print(f"Failed to read TDELTA for CPU {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_svi3_vr_controller_temp#

Description: Get the SVI3 VR temperature for a specific rail and index within a CPU socket. This function retrieves the SVI3 VR temperature for the CPU.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query
rail_selection (int): SVI3 Rail selection type:
- 0: HottestRail - Get temperature from the hottest rail
- 1: IndividualRail - Get temperature from a specific rail (requires rail_index)
rail_index (int, optional): Rail index (0-7) - Required only when rail_selection=1. Defaults to 0.

Output: Dictionary containing the SVI3 VR controller temperature information:

rail_selection (int): SVI3 rail selection used
rail_index (int): SVI3 rail index used
temperature (float): Temperature value in degrees Celsius

Exceptions that can be thrown by amdsmi_get_cpu_svi3_vr_controller_temp function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                # Get SVI3 VR controller temperature with hardcoded values
                rail_selection = 1  # Use rail selection 1
                rail_index = 1      # Use rail index 1
                vr_temp_info = amdsmi_get_cpu_svi3_vr_controller_temp(processor, rail_selection, rail_index)
                print(f"CPU: {i}")
                print(f"    SVI3_VR_CONTROLLER_TEMP:")
                print(f"        RAIL_SELECTION: {vr_temp_info['rail_selection']}")
                print(f"        RAIL_INDEX: {vr_temp_info['rail_index']}")
                print(f"        TEMPERATURE: {vr_temp_info['temperature']:.1f} 'C")
                print()
            except AmdSmiException as e:
                print(f"Failed to get SVI3 VR controller temperature for CPU {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_enabled_commands#

Description: Get the enabled HSMP commands bitmasks for a specific CPU socket. This function retrieves both read and write HSMP enabled commands.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query

Output: Dictionary containing the following keys:

ReadEnabledCommandsBitMask0 (int): Bitmask of enabled read commands (bits 0-31)
ReadEnabledCommandsBitMask1 (int): Bitmask of enabled read commands (bits 32-63)
ReadEnabledCommandsBitMask2 (int): Bitmask of enabled read commands (bits 64-95)
WriteEnabledCommandsBitMask0 (int): Bitmask of enabled write commands (bits 0-31)
WriteEnabledCommandsBitMask1 (int): Bitmask of enabled write commands (bits 32-63)
WriteEnabledCommandsBitMask2 (int): Bitmask of enabled write commands (bits 64-95)

Exceptions that can be thrown by amdsmi_get_cpu_enabled_commands function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                # Get enabled commands bitmasks
                enabled_cmds = amdsmi_get_cpu_enabled_commands(processor)
                print(f"CPU: {i}")
                print(f"    ENABLED_COMMANDS:")
                print(f"        READ_ENABLED_COMMANDS_BITMASK0: 0x{enabled_cmds['ReadEnabledCommandsBitMask0']:08X}")
                print(f"        READ_ENABLED_COMMANDS_BITMASK1: 0x{enabled_cmds['ReadEnabledCommandsBitMask1']:08X}")
                print(f"        READ_ENABLED_COMMANDS_BITMASK2: 0x{enabled_cmds['ReadEnabledCommandsBitMask2']:08X}")
                print(f"        WRITE_ENABLED_COMMANDS_BITMASK0: 0x{enabled_cmds['WriteEnabledCommandsBitMask0']:08X}")
                print(f"        WRITE_ENABLED_COMMANDS_BITMASK1: 0x{enabled_cmds['WriteEnabledCommandsBitMask1']:08X}")
                print(f"        WRITE_ENABLED_COMMANDS_BITMASK2: 0x{enabled_cmds['WriteEnabledCommandsBitMask2']:08X}")
                print()
            except AmdSmiException as e:
                print(f"Failed to get enabled commands for CPU {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_core_floor_freq_limit#

Description: Get the floor limit frequency for CPU cores.

Input parameters:

core0 (int): Core 0 index to query

Output: Integer representing the core floor limit frequency in MHz for core 0

Exceptions that can be thrown by amdsmi_get_cpu_core_floor_freq_limit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    core_handles = amdsmi_get_cpucore_handles()
    if len(core_handles) == 0:
        print("No CPU Cores on machine")
    else:
        core0 = core_handles[0]   # <-- pick core 0 explicitly
        # Get core floor limit for core 0
        floor_limit = amdsmi_get_cpu_core_floor_freq_limit(core0)
        print(f"CORE: 0")
        print(f"    FLOOR_LIMIT:")
        print(f"        VALUE: {floor_limit} MHz")
        print()
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_core_eff_floor_freq_limit#

Description: Get the effective floor limit frequency for CPU core.

Input parameters:

core0 (amdsmi_processor_handle): CPU core handle to query

Output: Integer representing the effective core floor limit frequency in MHz for core 0

Exceptions that can be thrown by amdsmi_get_cpu_core_eff_floor_freq_limit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    core_handles = amdsmi_get_cpucore_handles()
    if len(core_handles) == 0:
        print("No CPU cores on machine")
    else:
        core0 = core_handles[0]   # <-- pick core 0 explicitly
        # Get core effective floor limit for core 0
        eff_floor_limit = amdsmi_get_cpu_core_eff_floor_freq_limit(core0)
        print(f"CORE: 0")
        print(f"    EFF_FLOOR_LIMIT:")
        print(f"        VALUE: {eff_floor_limit} MHz")
        print()
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_floor_freq_limit#

Description: Get the floor limit frequency for a CPU socket.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query

Output: Integer representing the socket floor limit frequency in MHz

Exceptions that can be thrown by amdsmi_get_cpu_floor_freq_limit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            floor_limit = amdsmi_get_cpu_floor_freq_limit(processor)
            print(f"CPU: {i}")
            print(f"    FLOOR_LIMIT:")
            print(f"        VALUE: {floor_limit} MHz")
            print()
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_eff_floor_freq_limit#

Description: Get the effective floor limit frequency for a CPU socket.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query

Output: Integer representing the effective socket floor limit frequency in MHz

Exceptions that can be thrown by amdsmi_get_cpu_eff_floor_freq_limit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            eff_floor_limit = amdsmi_get_cpu_eff_floor_freq_limit(processor)
            print(f"CPU: {i}")
            print(f"    EFF_FLOOR_LIMIT:")
            print(f"        VALUE: {eff_floor_limit} MHz")
            print()
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_freq_range#

Description: Get the CPU socket frequency range. Returns the minimum and maximum frequency limits for CPU socket 0.

Input parameters: None

Output: Dictionary containing frequency range values:

fmax (int): Maximum frequency in MHz
fmin (int): Minimum frequency in MHz

Exceptions that can be thrown by amdsmi_get_cpu_freq_range function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    freq_range = amdsmi_get_cpu_freq_range()
    print(f"CPU Frequency Range:")
    print(f"    FMAX: {freq_range['fmax']} MHz")
    print(f"    FMIN: {freq_range['fmin']} MHz")
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_core_floor_freq_limit#

Description: Set the floor limit frequency for a specific CPU core.

Input parameters:

core0 (int): Core index to configure
floor_limit (int): Floor limit frequency value in MHz

Exceptions that can be thrown by amdsmi_set_cpu_core_floor_freq_limit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
‘AMDSMI_STATUS_NO_PERM’ - Permission Denied

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    core_handles = amdsmi_get_cpucore_handles()
    if len(core_handles) == 0:
        print("No CPU cores on machine")
    else:
        core0 = core_handles[0]   # <-- pick core 0 explicitly
        floor_limit_value = 1200  # Set floor limit to 1200 MHz
        amdsmi_set_cpu_core_floor_freq_limit(core0, floor_limit_value)
        print(f"CORE: 0")
        print(f"    FLOOR_LIMIT:")
        print(f"        RESPONSE: Set, VALUE: {floor_limit_value} MHz, successful")
        print()
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_floor_freq_limit#

Description: Set the CPU floor limit frequency for a CPU socket.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to configure
floor_limit_value (int): Floor limit frequency value in MHz

Output: None

Exceptions that can be thrown by amdsmi_set_cpu_floor_freq_limit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
‘AMDSMI_STATUS_NO_PERM’ - Permission Denied

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                # Set CPU floor limit from 600 MHz to  4000 MHz
                floor_limit_value = 1200
                amdsmi_set_cpu_floor_freq_limit(processor, floor_limit_value)
                print(f"CPU: {i}")
                print(f"    FLOOR_LIMIT:")
                print(f"        RESPONSE: Set, VALUE: {floor_limit_value} MHz, successful")
                print()
            except AmdSmiException as e:
                print(f"Failed to set CPU floor limit for CPU {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_msr_floor_freq_limit#

Description: Set the CPU MSR floor limit frequency for a CPU socket.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to configure
floor_limit (int): MSR floor limit frequency value in MHz

Output: None

Exceptions that can be thrown by amdsmi_set_cpu_msr_floor_freq_limit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
‘AMDSMI_STATUS_NO_PERM’ - Permission Denied

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                # Set CPU MSR floor limit to 1200 MHz
                msr_floor_limit_value = 1200
                amdsmi_set_cpu_msr_floor_freq_limit(processor, msr_floor_limit_value)
                print(f"CPU: {i}")
                print(f"    MSR_FLOOR_LIMIT:")
                print(f"        RESPONSE: Set, VALUE: {msr_floor_limit_value} MHz, successful")
                print()
            except AmdSmiException as e:
                print(f"Failed to set CPU MSR floor limit for CPU {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_core_msr_floor_freq_limit#

Description: Set the CPU core MSR floor limit frequency for a specific CPU core.

Input parameters:

core0 (int): Core 0 index to configure
msr_floor_limit_value (int): MSR floor limit frequency value in MHz

Output: None

Exceptions that can be thrown by amdsmi_set_cpu_core_msr_floor_freq_limit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call
‘AMDSMI_STATUS_NO_PERM’ - Permission Denied

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    core_handles = amdsmi_get_cpucore_handles()
    if len(core_handles) == 0:
        print("No CPU cores on machine")
    else:
        core0 = core_handles[0]   # <-- pick core 0 explicitly
        # Set MSR floor limit for core 0 only
        msr_floor_limit_value = 1200  # Set MSR floor limit to 1200 MHz
        amdsmi_set_cpu_core_msr_floor_freq_limit(core0, msr_floor_limit_value)
        print(f"CORE: 0")
        print(f"    MSR_FLOOR_LIMIT:")
        print(f"        RESPONSE: Set, VALUE: {msr_floor_limit_value} MHz, successful")
        print()
except AmdSmiException as e:
    print(e)

amdsmi_set_cpu_sdps_limit#

Description: Set the SDPS limit for a CPU socket. This function sets the socket SDPS power limit for the CPU socket.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to configure
sdps_limit (int): SDPS limit value in Watts

Output: None

Exceptions that can be thrown by amdsmi_set_cpu_sdps_limit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                # Set CPU socket SDPS limit to 1000 mWatts
                sdps_limit_value_mW = 1000
                sdps_limit_watts = float(sdps_limit_value_mW) / 1000
                amdsmi_set_cpu_sdps_limit(processor, sdps_limit_value_mW)
                print(f"CPU: {i}")
                print(f"    SDPS_LIMIT:")
                print(f"        RESPONSE: Set, VALUE: {sdps_limit_watts} Watts, successful")
                print()
            except AmdSmiException as e:
                print(f"Failed to set CPU socket SDPS limit for CPU {i}: {e}")
except AmdSmiException as e:
    print(e)

amdsmi_get_cpu_sdps_limit#

Description: Get the SDPS limit for a CPU socket. This function retrieves the current socket SDPS power limit for the CPU socket.

Input parameters:

processor_handle (amdsmi_processor_handle): CPU socket handle to query

Output: Double representing the SDPS limit value in Watts

Exceptions that can be thrown by amdsmi_get_cpu_sdps_limit function:

AmdSmiLibraryException

Possible Library Exceptions#

AMDSMI_STATUS_NOT_SUPPORTED - Feature not supported
AMDSMI_STATUS_NOT_YET_IMPLEMENTED - Feature not yet implemented
AMDSMI_STATUS_NO_HSMP_MSG_SUP - HSMP message/feature not supported
AMDSMI_STATUS_INVAL - Invalid parameters
AMDSMI_STATUS_TIMEOUT - Timeout in API call

Example:

from amdsmi import *
try:
    ret = amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
    processor_handles = amdsmi_get_cpusocket_handles()
    if len(processor_handles) == 0:
        print("No CPUs on machine")
    else:
        for i, processor in enumerate(processor_handles):
            try:
                # Get CPU socket SDPS limit
                sdps_limit = amdsmi_get_cpu_sdps_limit(processor)
                print(f"CPU: {i}")
                print(f"    SDPS_LIMIT:")
                print(f"        VALUE: {sdps_limit}")
                print()
            except AmdSmiException as e:
                print(f"Failed to get CPU socket SDPS limit for CPU {i}: {e}")
except AmdSmiException as e:
    print(e)

AMD SMI Python API reference

Contents

AMD SMI Python API reference#

API#

amdsmi_init#

Possible Library Exceptions#

amdsmi_shut_down#

Possible Library Exceptions#

amdsmi_get_processor_type#

Possible Library Exceptions#

amdsmi_get_processor_handles#

Possible Library Exceptions#

amdsmi_get_socket_handles#

amdsmi_get_socket_info#

Possible Library Exceptions#

amdsmi_get_processor_handle_from_bdf#

Possible Library Exceptions#

amdsmi_get_gpu_device_bdf#

Possible Library Exceptions#

amdsmi_get_gpu_device_uuid#

Possible Library Exceptions#

amdsmi_get_gpu_enumeration_info#

Possible Library Exceptions#

amdsmi_get_gpu_driver_info#

Possible Library Exceptions#

amdsmi_get_gpu_asic_info#

Possible Library Exceptions#

amdsmi_get_gpu_kfd_info#

Possible Library Exceptions#

amdsmi_get_power_cap_info#

Possible Library Exceptions#

amdsmi_get_supported_power_cap#

amdsmi_get_gpu_vram_info#

Possible Library Exceptions#

amdsmi_get_gpu_board_info#

Possible Library Exceptions#

amdsmi_get_gpu_revision#

Possible Library Exceptions#

amdsmi_get_gpu_cache_info#

Possible Library Exceptions#

amdsmi_get_gpu_vbios_info#

Possible Library Exceptions#

amdsmi_get_fw_info#

Possible Library Exceptions#

amdsmi_get_gpu_activity#

Possible Library Exceptions#

amdsmi_get_power_info#

Possible Library Exceptions#

amdsmi_get_gpu_vram_usage#

Possible Library Exceptions#

amdsmi_get_violation_status#

Possible Library Exceptions#

amdsmi_get_clock_info#

Possible Library Exceptions#

amdsmi_get_pcie_info#

Possible Library Exceptions#

amdsmi_get_gpu_bad_page_info#

Possible Library Exceptions#

amdsmi_get_gpu_bad_page_threshold#

Possible Library Exceptions#

amdsmi_get_gpu_memory_reserved_pages#

Possible Library Exceptions#

amdsmi_get_gpu_process_list#

Possible Library Exceptions#

amdsmi_get_gpu_total_ecc_count#

Possible Library Exceptions#

amdsmi_get_gpu_cper_entries#

Possible Library Exceptions#

amdsmi_get_afids_from_cper#

Possible Library Exceptions#

amdsmi_get_gpu_ras_feature_info#

Possible Library Exceptions#

amdsmi_get_gpu_ras_block_features_enabled#

Possible Library Exceptions#

AmdSmiEventReader class#

Constructor#

read#

stop#

amdsmi_set_gpu_pci_bandwidth#

Possible Library Exceptions#