tessl/go-amdsmi

AMD System Management Interface (AMD SMI) Go library for unified GPU and CPU management and monitoring

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

Device Information and Properties

Name: tessl/go-amdsmi
Author: tessl

Hardware identification, driver versions, firmware information, and device capabilities. Essential for device discovery, compatibility checking, and system inventory.

Capabilities

Device Identification

Get basic device identification information including name, vendor, and model.

amdsmi_status_t amdsmi_get_gpu_device_name(amdsmi_processor_handle processor_handle,
                                          char* name,
                                          size_t len);

Usage Example:

char device_name[AMDSMI_MAX_STRING_LENGTH];
amdsmi_status_t status = amdsmi_get_gpu_device_name(gpu_handle, 
                                                   device_name, 
                                                   sizeof(device_name));

if (status == AMDSMI_STATUS_SUCCESS) {
    printf("GPU Device: %s\n", device_name);
}

Device UUID

Get unique device identifier for tracking specific GPU instances.

amdsmi_status_t amdsmi_get_gpu_device_uuid(amdsmi_processor_handle processor_handle,
                                          unsigned int* uuid_length,
                                          char* uuid);

Usage Example:

char uuid[AMDSMI_GPU_UUID_SIZE];
unsigned int uuid_len = sizeof(uuid);
amdsmi_status_t status = amdsmi_get_gpu_device_uuid(gpu_handle, &uuid_len, uuid);

if (status == AMDSMI_STATUS_SUCCESS) {
    printf("GPU UUID: %s\n", uuid);
}

Device PCI Information

Get PCI bus information for device location and topology understanding.

amdsmi_status_t amdsmi_get_gpu_device_bdf(amdsmi_processor_handle processor_handle,
                                         amdsmi_bdf_t* bdf);

PCI BDF Structure:

typedef struct {
    uint32_t domain_number;      // PCI domain
    uint8_t bus_number;          // PCI bus number
    uint8_t device_number;       // PCI device number
    uint8_t function_number;     // PCI function number
} amdsmi_bdf_t;

Usage Example:

amdsmi_bdf_t bdf;
amdsmi_status_t status = amdsmi_get_gpu_device_bdf(gpu_handle, &bdf);

if (status == AMDSMI_STATUS_SUCCESS) {
    printf("PCI Location: %04X:%02X:%02X.%X\n", 
           bdf.domain_number, bdf.bus_number, 
           bdf.device_number, bdf.function_number);
}

Driver Information

Get detailed driver version and compatibility information.

amdsmi_status_t amdsmi_get_gpu_driver_info(amdsmi_processor_handle processor_handle,
                                          amdsmi_driver_info_t* info);

Driver Information Structure:

typedef struct {
    char driver_version[AMDSMI_MAX_DRIVER_VERSION_LENGTH];  // Driver version string
    char driver_date[AMDSMI_MAX_DATE_LENGTH];               // Driver build date
    char driver_name[AMDSMI_MAX_STRING_LENGTH];             // Driver name
} amdsmi_driver_info_t;

Usage Example:

amdsmi_driver_info_t driver_info;
amdsmi_status_t status = amdsmi_get_gpu_driver_info(gpu_handle, &driver_info);

if (status == AMDSMI_STATUS_SUCCESS) {
    printf("Driver Information:\n");
    printf("  Name: %s\n", driver_info.driver_name);
    printf("  Version: %s\n", driver_info.driver_version);
    printf("  Date: %s\n", driver_info.driver_date);
}

VBIOS Information

Get video BIOS version and part number information.

amdsmi_status_t amdsmi_get_gpu_vbios_info(amdsmi_processor_handle processor_handle,
                                         amdsmi_vbios_info_t* info);

VBIOS Information Structure:

typedef struct {
    char vbios_version[AMDSMI_MAX_STRING_LENGTH];    // VBIOS version string
    char vbios_date[AMDSMI_MAX_DATE_LENGTH];         // VBIOS build date
    char vbios_part_number[AMDSMI_MAX_STRING_LENGTH]; // VBIOS part number
} amdsmi_vbios_info_t;

Firmware Information

Get firmware versions for various GPU components.

amdsmi_status_t amdsmi_get_fw_info(amdsmi_processor_handle processor_handle,
                                  amdsmi_fw_block_t fw_block,
                                  amdsmi_fw_info_t* fw_info);

Firmware Blocks:

typedef enum {
    AMDSMI_FW_ID_ASD,           // ASD firmware
    AMDSMI_FW_ID_CE,            // CE firmware
    AMDSMI_FW_ID_DMCU,          // DMCU firmware
    AMDSMI_FW_ID_MC,            // Memory Controller firmware
    AMDSMI_FW_ID_ME,            // ME firmware
    AMDSMI_FW_ID_MEC,           // MEC firmware
    AMDSMI_FW_ID_MEC2,          // MEC2 firmware
    AMDSMI_FW_ID_PFP,           // PFP firmware
    AMDSMI_FW_ID_RLC,           // RLC firmware
    AMDSMI_FW_ID_RLC_SRLC,      // RLC SRLC firmware
    AMDSMI_FW_ID_RLC_SRLG,      // RLC SRLG firmware
    AMDSMI_FW_ID_RLC_SRLS,      // RLC SRLS firmware
    AMDSMI_FW_ID_SDMA,          // SDMA firmware
    AMDSMI_FW_ID_SDMA2,         // SDMA2 firmware
    AMDSMI_FW_ID_SMC,           // SMC firmware
    AMDSMI_FW_ID_SOS,           // SOS firmware
    AMDSMI_FW_ID_TA_RAS,        // TA RAS firmware
    AMDSMI_FW_ID_TA_XGMI,       // TA XGMI firmware
    AMDSMI_FW_ID_UVD,           // UVD firmware
    AMDSMI_FW_ID_VCE,           // VCE firmware
    AMDSMI_FW_ID_VCN            // VCN firmware
} amdsmi_fw_block_t;

Firmware Information Structure:

typedef struct {
    uint64_t fw_version;        // Firmware version
    uint64_t fw_date;           // Firmware date
    char fw_name[AMDSMI_MAX_STRING_LENGTH]; // Firmware name
} amdsmi_fw_info_t;

Usage Example:

// Get SMC firmware information
amdsmi_fw_info_t fw_info;
amdsmi_status_t status = amdsmi_get_fw_info(gpu_handle, AMDSMI_FW_ID_SMC, &fw_info);

if (status == AMDSMI_STATUS_SUCCESS) {
    printf("SMC Firmware:\n");
    printf("  Name: %s\n", fw_info.fw_name);
    printf("  Version: 0x%lX\n", fw_info.fw_version);
}

Device Brand and Series

Get marketing name and brand information for the device.

amdsmi_status_t amdsmi_get_gpu_device_brand(amdsmi_processor_handle processor_handle,
                                           char* brand,
                                           uint32_t len);

amdsmi_status_t amdsmi_get_gpu_asic_info(amdsmi_processor_handle processor_handle,
                                        amdsmi_asic_info_t* info);

ASIC Information Structure:

typedef struct {
    char market_name[AMDSMI_MAX_STRING_LENGTH];      // Marketing name
    char vendor_name[AMDSMI_MAX_STRING_LENGTH];      // Vendor name
    char subvendor_name[AMDSMI_MAX_STRING_LENGTH];   // Subvendor name
    uint64_t device_id;                              // Device ID
    uint64_t rev_id;                                 // Revision ID
    uint64_t vendor_id;                              // Vendor ID
    uint64_t subvendor_id;                           // Subvendor ID
    uint64_t subsys_id;                              // Subsystem ID
} amdsmi_asic_info_t;

Device Board Information

Get board-level information including part numbers and manufacturing details.

amdsmi_status_t amdsmi_get_gpu_board_info(amdsmi_processor_handle processor_handle,
                                         amdsmi_board_info_t* info);

Board Information Structure:

typedef struct {
    char model_number[AMDSMI_MAX_STRING_LENGTH];     // Board model number
    char product_serial[AMDSMI_MAX_STRING_LENGTH];   // Product serial number
    char fru_id[AMDSMI_MAX_STRING_LENGTH];           // FRU ID
    char product_name[AMDSMI_MAX_STRING_LENGTH];     // Product name
    char manufacturer_name[AMDSMI_MAX_STRING_LENGTH]; // Manufacturer name
} amdsmi_board_info_t;

Language Interface Examples

Python

import amdsmi

gpu_handles = amdsmi.amdsmi_get_processor_handles(amdsmi.AmdSmiProcessorType.AMD_GPU)
if gpu_handles:
    gpu_handle = gpu_handles[0]
    
    # Get device name
    device_name = amdsmi.amdsmi_get_gpu_device_name(gpu_handle)
    print(f"Device: {device_name}")
    
    # Get device UUID
    uuid = amdsmi.amdsmi_get_gpu_device_uuid(gpu_handle)
    print(f"UUID: {uuid}")
    
    # Get PCI information
    bdf = amdsmi.amdsmi_get_gpu_device_bdf(gpu_handle)
    print(f"PCI: {bdf['domain_number']:04X}:{bdf['bus_number']:02X}:{bdf['device_number']:02X}.{bdf['function_number']:X}")
    
    # Get driver information
    driver_info = amdsmi.amdsmi_get_gpu_driver_info(gpu_handle)
    print(f"Driver: {driver_info['driver_name']} v{driver_info['driver_version']}")
    
    # Get VBIOS information
    vbios_info = amdsmi.amdsmi_get_gpu_vbios_info(gpu_handle)
    print(f"VBIOS: {vbios_info['vbios_version']}")
    
    # Get ASIC information
    asic_info = amdsmi.amdsmi_get_gpu_asic_info(gpu_handle)
    print(f"Market Name: {asic_info['market_name']}")
    print(f"Vendor: {asic_info['vendor_name']}")

Go

import "github.com/ROCm/amdsmi"

// Get device information for each GPU
for i := 0; i < int(goamdsmi.GO_gpu_num_monitor_devices()); i++ {
    // Get device name
    deviceName := goamdsmi.GO_gpu_dev_name_get(i)
    fmt.Printf("GPU %d: %s\n", i, C.GoString(deviceName))
    
    // Get device UUID
    uuid := goamdsmi.GO_gpu_dev_uuid_get(i)
    fmt.Printf("UUID: %s\n", C.GoString(uuid))
    
    // Get PCI ID
    pciId := goamdsmi.GO_gpu_dev_pci_id_get(i)
    fmt.Printf("PCI ID: 0x%X\n", pciId)
    
    // Get vendor information
    vendor := goamdsmi.GO_gpu_dev_vendor_name_get(i)
    fmt.Printf("Vendor: %s\n", C.GoString(vendor))
}

Rust

use amdsmi::{get_gpu_device_name, get_gpu_device_uuid, get_gpu_device_bdf};
use amdsmi::{get_gpu_driver_info, get_gpu_asic_info};

// Get comprehensive device information
let device_name = get_gpu_device_name(gpu_handle)?;
println!("Device: {}", device_name);

let uuid = get_gpu_device_uuid(gpu_handle)?;
println!("UUID: {}", uuid);

let bdf = get_gpu_device_bdf(gpu_handle)?;
println!("PCI: {:04X}:{:02X}:{:02X}.{:X}", 
         bdf.domain_number, bdf.bus_number, 
         bdf.device_number, bdf.function_number);

let driver_info = get_gpu_driver_info(gpu_handle)?;
println!("Driver: {} v{}", driver_info.driver_name, driver_info.driver_version);

let asic_info = get_gpu_asic_info(gpu_handle)?;
println!("Market Name: {}", asic_info.market_name);

Device Information Best Practices

Unique Identification: Use UUID for persistent device tracking across reboots
Compatibility Checks: Verify driver versions for feature availability
Inventory Management: Collect comprehensive device information for system inventory
Support Information: Include firmware versions when reporting issues
PCI Topology: Use BDF information for understanding multi-GPU configurations