node-gpuinfo 1.0.0

package/src/linux/amd_linux.c

@@ -0,0 +1,269 @@
+#include "../gpu_info.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dirent.h>
+#include <unistd.h>
+
+static int is_amd_device(const char* card_path) {
+    char vendor_path[512];
+    snprintf(vendor_path, sizeof(vendor_path), "%s/device/vendor", card_path);
+    
+    FILE* f = fopen(vendor_path, "r");
+    if (!f) return 0;
+    
+    unsigned int vendor;
+    int result = fscanf(f, "%x", &vendor);
+    fclose(f);
+    
+    // AMD vendor ID is 0x1002
+    return (result == 1 && vendor == 0x1002);
+}
+
+gpu_error_t amd_linux_get_gpu_count(int32_t* count) {
+    if (!count) return GPU_ERROR_INVALID_PARAM;
+    
+    DIR* dir;
+    struct dirent* entry;
+    int amd_count = 0;
+    
+    dir = opendir("/sys/class/drm");
+    if (!dir) {
+        *count = 0;
+        return GPU_ERROR_API_FAILED;
+    }
+    
+    while ((entry = readdir(dir)) != NULL) {
+        // Look for card* directories
+        if (strncmp(entry->d_name, "card", 4) == 0 && 
+            strlen(entry->d_name) == 5 && 
+            entry->d_name[4] >= '0' && entry->d_name[4] <= '9') {
+            
+            char card_path[512];
+            snprintf(card_path, sizeof(card_path), "/sys/class/drm/%s", entry->d_name);
+            
+            if (is_amd_device(card_path)) {
+                amd_count++;
+            }
+        }
+    }
+    
+    closedir(dir);
+    *count = amd_count;
+    return GPU_SUCCESS;
+}
+
+static int read_sysfs_string(const char* path, char* buffer, size_t size) {
+    FILE* f = fopen(path, "r");
+    if (!f) return 0;
+    
+    if (fgets(buffer, size, f)) {
+        // Remove trailing newline
+        size_t len = strlen(buffer);
+        if (len > 0 && buffer[len-1] == '\n') {
+            buffer[len-1] = '\0';
+        }
+        fclose(f);
+        return 1;
+    }
+    
+    fclose(f);
+    return 0;
+}
+
+static long read_sysfs_long(const char* path) {
+    FILE* f = fopen(path, "r");
+    if (!f) return -1;
+    
+    long value;
+    int result = fscanf(f, "%ld", &value);
+    fclose(f);
+    
+    return (result == 1) ? value : -1;
+}
+
+gpu_error_t amd_linux_get_gpu_info(int32_t index, gpu_info_t* info) {
+    if (!info) return GPU_ERROR_INVALID_PARAM;
+    
+    // Find the correct card device
+    DIR* dir = opendir("/sys/class/drm");
+    if (!dir) return GPU_ERROR_API_FAILED;
+    
+    struct dirent* entry;
+    int current_index = 0;
+    char card_path[512] = {0};
+    int found = 0;
+    
+    while ((entry = readdir(dir)) != NULL) {
+        if (strncmp(entry->d_name, "card", 4) == 0 && 
+            strlen(entry->d_name) == 5 && 
+            entry->d_name[4] >= '0' && entry->d_name[4] <= '9') {
+            
+            char temp_path[512];
+            snprintf(temp_path, sizeof(temp_path), "/sys/class/drm/%s", entry->d_name);
+            
+            if (is_amd_device(temp_path)) {
+                if (current_index == index) {
+                    strncpy(card_path, temp_path, sizeof(card_path) - 1);
+                    found = 1;
+                    break;
+                }
+                current_index++;
+            }
+        }
+    }
+    
+    closedir(dir);
+    
+    if (!found) return GPU_ERROR_INVALID_PARAM;
+    
+    // Initialize structure
+    memset(info, 0, sizeof(gpu_info_t));
+    info->index = index;
+    info->vendor = GPU_VENDOR_AMD;
+    
+    // Read GPU name from device
+    char name_path[512];
+    snprintf(name_path, sizeof(name_path), "%s/device/product_name", card_path);
+    if (!read_sysfs_string(name_path, info->name, sizeof(info->name))) {
+        // Fallback: try model or just use generic name
+        snprintf(name_path, sizeof(name_path), "%s/device/model", card_path);
+        if (!read_sysfs_string(name_path, info->name, sizeof(info->name))) {
+            snprintf(info->name, sizeof(info->name), "AMD GPU %d", index);
+        }
+    }
+    
+    // Read device ID for UUID
+    char device_path[512];
+    snprintf(device_path, sizeof(device_path), "%s/device/device", card_path);
+    unsigned int device_id = 0;
+    FILE* f = fopen(device_path, "r");
+    if (f) {
+        fscanf(f, "%x", &device_id);
+        fclose(f);
+    }
+    snprintf(info->uuid, sizeof(info->uuid), "AMD-Linux-0x%04X-%d", device_id, index);
+    
+    // Read PCI bus ID
+    char pci_path[512];
+    snprintf(pci_path, sizeof(pci_path), "%s/device/uevent", card_path);
+    f = fopen(pci_path, "r");
+    if (f) {
+        char line[256];
+        while (fgets(line, sizeof(line), f)) {
+            if (strncmp(line, "PCI_SLOT_NAME=", 14) == 0) {
+                strncpy(info->pci_bus_id, line + 14, sizeof(info->pci_bus_id) - 1);
+                // Remove newline
+                size_t len = strlen(info->pci_bus_id);
+                if (len > 0 && info->pci_bus_id[len-1] == '\n') {
+                    info->pci_bus_id[len-1] = '\0';
+                }
+                break;
+            }
+        }
+        fclose(f);
+    }
+    if (info->pci_bus_id[0] == '\0') {
+        snprintf(info->pci_bus_id, sizeof(info->pci_bus_id), "PCI:%d", index);
+    }
+    
+    // Read memory information (in bytes, convert to MB)
+    char mem_path[512];
+    snprintf(mem_path, sizeof(mem_path), "%s/device/mem_info_vram_total", card_path);
+    long mem_total = read_sysfs_long(mem_path);
+    if (mem_total > 0) {
+        info->memory_total = (int32_t)(mem_total / (1024 * 1024));
+    }
+    
+    snprintf(mem_path, sizeof(mem_path), "%s/device/mem_info_vram_used", card_path);
+    long mem_used = read_sysfs_long(mem_path);
+    if (mem_used > 0) {
+        info->memory_used = (int32_t)(mem_used / (1024 * 1024));
+        if (info->memory_total > 0) {
+            info->memory_free = info->memory_total - info->memory_used;
+            info->memory_utilization = (float)info->memory_used / info->memory_total * 100.0f;
+        }
+    }
+    
+    // Read GPU utilization
+    char util_path[512];
+    snprintf(util_path, sizeof(util_path), "%s/device/gpu_busy_percent", card_path);
+    long gpu_util = read_sysfs_long(util_path);
+    if (gpu_util >= 0) {
+        info->gpu_utilization = (float)gpu_util;
+    }
+    
+    // Read temperature (in millidegrees, convert to Celsius)
+    char temp_path[512];
+    snprintf(temp_path, sizeof(temp_path), "%s/device/hwmon/hwmon*/temp1_input", card_path);
+    // Note: This glob pattern won't work directly, we'd need to enumerate hwmon directories
+    // For now, try hwmon0 and hwmon1
+    for (int hwmon = 0; hwmon < 4; hwmon++) {
+        snprintf(temp_path, sizeof(temp_path), "%s/device/hwmon/hwmon%d/temp1_input", card_path, hwmon);
+        long temp = read_sysfs_long(temp_path);
+        if (temp > 0) {
+            info->temperature = temp / 1000.0f;
+            break;
+        }
+    }
+    
+    // Read power usage (in microwatts, convert to watts)
+    char power_path[512];
+    for (int hwmon = 0; hwmon < 4; hwmon++) {
+        snprintf(power_path, sizeof(power_path), "%s/device/hwmon/hwmon%d/power1_average", card_path, hwmon);
+        long power = read_sysfs_long(power_path);
+        if (power > 0) {
+            info->power_usage = power / 1000000.0f;
+            break;
+        }
+    }
+    
+    // Read clock speeds (in Hz, convert to MHz)
+    char clock_path[512];
+    snprintf(clock_path, sizeof(clock_path), "%s/device/pp_dpm_sclk", card_path);
+    f = fopen(clock_path, "r");
+    if (f) {
+        char line[256];
+        // Find the line with asterisk (current clock)
+        while (fgets(line, sizeof(line), f)) {
+            if (strchr(line, '*')) {
+                unsigned int clock_mhz;
+                if (sscanf(line, "%*d: %uMhz", &clock_mhz) == 1) {
+                    info->core_clock = clock_mhz;
+                    break;
+                }
+            }
+        }
+        fclose(f);
+    }
+    
+    snprintf(clock_path, sizeof(clock_path), "%s/device/pp_dpm_mclk", card_path);
+    f = fopen(clock_path, "r");
+    if (f) {
+        char line[256];
+        while (fgets(line, sizeof(line), f)) {
+            if (strchr(line, '*')) {
+                unsigned int clock_mhz;
+                if (sscanf(line, "%*d: %uMhz", &clock_mhz) == 1) {
+                    info->memory_clock = clock_mhz;
+                    break;
+                }
+            }
+        }
+        fclose(f);
+    }
+    
+    // Read fan speed (percentage)
+    char fan_path[512];
+    for (int hwmon = 0; hwmon < 4; hwmon++) {
+        snprintf(fan_path, sizeof(fan_path), "%s/device/hwmon/hwmon%d/pwm1", card_path, hwmon);
+        long fan_pwm = read_sysfs_long(fan_path);
+        if (fan_pwm >= 0) {
+            // PWM is typically 0-255
+            info->fan_speed = (fan_pwm / 255.0f) * 100.0f;
+            break;
+        }
+    }
+    
+    return GPU_SUCCESS;
+}

package/src/linux/intel_linux.c

@@ -0,0 +1,20 @@
+#include "../gpu_info.h"
+#include <stdio.h>
+#include <string.h>
+
+// Intel GPU detection on Linux is not yet implemented
+// Would require i915 sysfs interface or similar
+
+gpu_error_t intel_linux_get_gpu_count(int32_t* count) {
+    if (!count) return GPU_ERROR_INVALID_PARAM;
+    
+    // Not yet implemented
+    *count = 0;
+    return GPU_SUCCESS;
+}
+
+gpu_error_t intel_linux_get_gpu_info(int32_t index, gpu_info_t* info) {
+    if (!info) return GPU_ERROR_INVALID_PARAM;
+    
+    return GPU_ERROR_NOT_SUPPORTED;
+}

package/src/linux/nvidia_linux.c

@@ -0,0 +1,257 @@
+#include "../gpu_info.h"
+#include <dlfcn.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+static void* nvml_library = NULL;
+static int nvml_initialized = 0;
+
+// NVML structures (same as Windows)
+typedef struct {
+    unsigned long long total;
+    unsigned long long free;
+    unsigned long long used;
+} nvmlMemory_t;
+
+typedef struct {
+    unsigned int gpu;
+    unsigned int memory;
+} nvmlUtilization_t;
+
+// PCI info structure (same as Windows)
+typedef struct {
+    char busId[16];  // PCI bus ID in format: "0000:00:00.0"
+    unsigned int domain;
+    unsigned int bus;
+    unsigned int device;
+    unsigned int pciDeviceId;
+    unsigned int pciSubSystemId;
+} nvmlPciInfo_t;
+
+// Function pointers (same as Windows)
+static int (*nvmlInit_v2)(void) = NULL;
+static int (*nvmlShutdown)(void) = NULL;
+static int (*nvmlDeviceGetCount_v2)(unsigned int*) = NULL;
+static int (*nvmlDeviceGetHandleByIndex)(unsigned int, void**) = NULL;
+static int (*nvmlDeviceGetName)(void*, char*, unsigned int) = NULL;
+static int (*nvmlDeviceGetUUID)(void*, char*, unsigned int) = NULL;
+static int (*nvmlDeviceGetMemoryInfo)(void*, nvmlMemory_t*) = NULL;
+static int (*nvmlDeviceGetUtilizationRates)(void*, nvmlUtilization_t*) = NULL;
+static int (*nvmlDeviceGetTemperature)(void*, int, unsigned int*) = NULL;
+static int (*nvmlDeviceGetPowerUsage)(void*, unsigned int*) = NULL;
+static int (*nvmlDeviceGetClockInfo)(void*, int, unsigned int*) = NULL;
+static int (*nvmlDeviceGetFanSpeed)(void*, unsigned int*) = NULL;
+static int (*nvmlDeviceGetPciInfo)(void*, nvmlPciInfo_t*) = NULL;
+
+static gpu_error_t load_nvml_linux(void) {
+    if (nvml_initialized) return GPU_SUCCESS;
+    
+    // Try to load NVML library from common locations
+    nvml_library = dlopen("libnvidia-ml.so", RTLD_LAZY);
+    if (!nvml_library) {
+        nvml_library = dlopen("libnvidia-ml.so.1", RTLD_LAZY);
+    }
+    if (!nvml_library) {
+        return GPU_ERROR_NOT_SUPPORTED;
+    }
+    
+    // Load all NVML functions
+    nvmlInit_v2 = (int(*)(void))dlsym(nvml_library, "nvmlInit_v2");
+    nvmlShutdown = (int(*)(void))dlsym(nvml_library, "nvmlShutdown");
+    nvmlDeviceGetCount_v2 = (int(*)(unsigned int*))dlsym(nvml_library, "nvmlDeviceGetCount_v2");
+    nvmlDeviceGetHandleByIndex = (int(*)(unsigned int, void**))dlsym(nvml_library, "nvmlDeviceGetHandleByIndex");
+    nvmlDeviceGetName = (int(*)(void*, char*, unsigned int))dlsym(nvml_library, "nvmlDeviceGetName");
+    nvmlDeviceGetUUID = (int(*)(void*, char*, unsigned int))dlsym(nvml_library, "nvmlDeviceGetUUID");
+    nvmlDeviceGetMemoryInfo = (int(*)(void*, nvmlMemory_t*))dlsym(nvml_library, "nvmlDeviceGetMemoryInfo");
+    nvmlDeviceGetUtilizationRates = (int(*)(void*, nvmlUtilization_t*))dlsym(nvml_library, "nvmlDeviceGetUtilizationRates");
+    nvmlDeviceGetTemperature = (int(*)(void*, int, unsigned int*))dlsym(nvml_library, "nvmlDeviceGetTemperature");
+    nvmlDeviceGetPowerUsage = (int(*)(void*, unsigned int*))dlsym(nvml_library, "nvmlDeviceGetPowerUsage");
+    nvmlDeviceGetClockInfo = (int(*)(void*, int, unsigned int*))dlsym(nvml_library, "nvmlDeviceGetClockInfo");
+    nvmlDeviceGetFanSpeed = (int(*)(void*, unsigned int*))dlsym(nvml_library, "nvmlDeviceGetFanSpeed");
+    nvmlDeviceGetPciInfo = (int(*)(void*, nvmlPciInfo_t*))dlsym(nvml_library, "nvmlDeviceGetPciInfo");
+    
+    // Check for essential functions
+    if (!nvmlInit_v2 || !nvmlDeviceGetCount_v2 || !nvmlDeviceGetHandleByIndex) {
+        dlclose(nvml_library);
+        nvml_library = NULL;
+        return GPU_ERROR_NOT_SUPPORTED;
+    }
+    
+    if (nvmlInit_v2() != 0) {
+        dlclose(nvml_library);
+        nvml_library = NULL;
+        return GPU_ERROR_NOT_SUPPORTED;
+    }
+    
+    nvml_initialized = 1;
+    return GPU_SUCCESS;
+}
+
+gpu_error_t nvidia_linux_get_gpu_count(int32_t* count) {
+    if (!count) return GPU_ERROR_INVALID_PARAM;
+    
+    gpu_error_t result = load_nvml_linux();
+    if (result != GPU_SUCCESS) {
+        *count = 0;
+        return GPU_SUCCESS;
+    }
+    
+    unsigned int nv_count = 0;
+    if (nvmlDeviceGetCount_v2(&nv_count) != 0) {
+        *count = 0;
+        return GPU_ERROR_API_FAILED;
+    }
+    
+    *count = (int32_t)nv_count;
+    return GPU_SUCCESS;
+}
+
+gpu_error_t nvidia_linux_get_gpu_info(int32_t index, gpu_info_t* info) {
+    if (!info) return GPU_ERROR_INVALID_PARAM;
+    
+    gpu_error_t result = load_nvml_linux();
+    if (result != GPU_SUCCESS) {
+        return result;
+    }
+    
+    void* device;
+    if (nvmlDeviceGetHandleByIndex((unsigned int)index, &device) != 0) {
+        return GPU_ERROR_API_FAILED;
+    }
+    
+    memset(info, 0, sizeof(gpu_info_t));
+    info->index = index;
+    info->vendor = GPU_VENDOR_NVIDIA;
+    
+    // Get GPU name
+    char name[256];
+    if (nvmlDeviceGetName && nvmlDeviceGetName(device, name, sizeof(name)) == 0) {
+        strncpy(info->name, name, sizeof(info->name) - 1);
+    } else {
+        strncpy(info->name, "NVIDIA GPU", sizeof(info->name) - 1);
+    }
+    
+    // Get UUID
+    char uuid[64];
+    if (nvmlDeviceGetUUID && nvmlDeviceGetUUID(device, uuid, sizeof(uuid)) == 0) {
+        strncpy(info->uuid, uuid, sizeof(info->uuid) - 1);
+    } else {
+        snprintf(info->uuid, sizeof(info->uuid), "NVIDIA-%d", index);
+    }
+    
+    // Get PCI bus information
+    if (nvmlDeviceGetPciInfo) {
+        nvmlPciInfo_t pciInfo;
+        if (nvmlDeviceGetPciInfo(device, &pciInfo) == 0) {
+            // Use the actual PCI bus ID from NVML
+            strncpy(info->pci_bus_id, pciInfo.busId, sizeof(info->pci_bus_id) - 1);
+            
+            // Debug output to see all PCI information (optional)
+            /*printf("GPU %d PCI Info:\n", index);
+            printf("  Bus ID: %s\n", pciInfo.busId);
+            printf("  Domain: 0x%04X\n", pciInfo.domain);
+            printf("  Bus: 0x%02X\n", pciInfo.bus);
+            printf("  Device: 0x%02X\n", pciInfo.device);
+            printf("  Device ID: 0x%04X\n", pciInfo.pciDeviceId);
+            printf("  Subsystem ID: 0x%04X\n", pciInfo.pciSubSystemId);*/
+        } else {
+            // Fallback: generate from index
+            snprintf(info->pci_bus_id, sizeof(info->pci_bus_id), "PCI:%d", index);
+        }
+    } else {
+        // Fallback: generate from index
+        snprintf(info->pci_bus_id, sizeof(info->pci_bus_id), "PCI:%d", index);
+    }
+    
+    // Get memory info
+    nvmlMemory_t memory;
+    if (nvmlDeviceGetMemoryInfo && nvmlDeviceGetMemoryInfo(device, &memory) == 0) {
+        info->memory_total = memory.total / (1024 * 1024); // Convert to MB
+        info->memory_used = memory.used / (1024 * 1024);
+        info->memory_free = memory.free / (1024 * 1024);
+        
+        // Calculate memory capacity utilization (for reference)
+        float capacity_utilization = 0.0f;
+        if (memory.total > 0) {
+            capacity_utilization = (float)memory.used / memory.total * 100.0f;
+        }
+        
+        // Debug output (optional)
+        /*printf("GPU %d Memory: %llu/%llu MB (%.1f%% capacity)\n", 
+               index, memory.used / (1024 * 1024), memory.total / (1024 * 1024),
+               capacity_utilization);*/
+    } else {
+        // Fallback values
+        info->memory_total = 8 * 1024;
+        info->memory_used = 0;
+        info->memory_free = 8 * 1024;
+    }
+    
+    // Get utilization rates
+    nvmlUtilization_t utilization;
+    if (nvmlDeviceGetUtilizationRates && nvmlDeviceGetUtilizationRates(device, &utilization) == 0) {
+        info->gpu_utilization = (float)utilization.gpu;
+        info->memory_utilization = (float)utilization.memory; // Memory bandwidth utilization
+        
+        // Debug output (optional)
+        /*printf("GPU %d Utilization: GPU=%u%%, Memory=%u%%\n", 
+               index, utilization.gpu, utilization.memory);*/
+    } else {
+        info->gpu_utilization = 0.0f;
+        info->memory_utilization = 0.0f;
+    }
+    
+    // Get temperature (GPU core)
+    unsigned int temperature;
+    if (nvmlDeviceGetTemperature && nvmlDeviceGetTemperature(device, 0, &temperature) == 0) {
+        info->temperature = (float)temperature;
+    } else {
+        info->temperature = 0.0f;
+    }
+    
+    // Get power usage (in milliwatts)
+    unsigned int power;
+    if (nvmlDeviceGetPowerUsage && nvmlDeviceGetPowerUsage(device, &power) == 0) {
+        info->power_usage = (float)power / 1000.0f; // Convert to watts
+    } else {
+        info->power_usage = 0.0f;
+    }
+    
+    // Get core clock (graphics clock)
+    unsigned int clock;
+    if (nvmlDeviceGetClockInfo && nvmlDeviceGetClockInfo(device, 0, &clock) == 0) {
+        info->core_clock = clock;
+    } else {
+        info->core_clock = 0;
+    }
+    
+    // Get memory clock
+    if (nvmlDeviceGetClockInfo && nvmlDeviceGetClockInfo(device, 1, &clock) == 0) {
+        info->memory_clock = clock;
+    } else {
+        info->memory_clock = 0;
+    }
+    
+    // Get fan speed
+    unsigned int fan_speed;
+    if (nvmlDeviceGetFanSpeed && nvmlDeviceGetFanSpeed(device, &fan_speed) == 0) {
+        info->fan_speed = (float)fan_speed;
+    } else {
+        info->fan_speed = 0.0f;
+    }
+    
+    return GPU_SUCCESS;
+}
+
+// Cleanup function
+void nvidia_linux_cleanup(void) {
+    if (nvml_initialized && nvmlShutdown) {
+        nvmlShutdown();
+    }
+    if (nvml_library) {
+        dlclose(nvml_library);
+        nvml_library = NULL;
+    }
+    nvml_initialized = 0;
+}

package/src/macos/amd_mac.c

@@ -0,0 +1,131 @@
+#include "../gpu_info.h"
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOKit/IOKitLib.h>
+#include <IOKit/graphics/IOGraphicsLib.h>
+#include <stdio.h>
+#include <string.h>
+
+gpu_error_t amd_macos_get_gpu_count(int32_t* count) {
+    if (!count) return GPU_ERROR_INVALID_PARAM;
+    
+    int amd_count = 0;
+    io_iterator_t iterator;
+    
+    // Get list of all GPUs
+    kern_return_t kr = IOServiceGetMatchingServices(kIOMasterPortDefault,
+                                                     IOServiceMatching("IOPCIDevice"),
+                                                     &iterator);
+    
+    if (kr != KERN_SUCCESS) {
+        *count = 0;
+        return GPU_ERROR_API_FAILED;
+    }
+    
+    io_object_t service;
+    while ((service = IOIteratorNext(iterator))) {
+        // Check if it's a display device
+        CFTypeRef vendorID = IORegistryEntryCreateCFProperty(service, CFSTR("vendor-id"),
+                                                               kCFAllocatorDefault, 0);
+        
+        if (vendorID) {
+            UInt32 vendor = 0;
+            CFDataGetBytes(vendorID, CFRangeMake(0, sizeof(UInt32)), (UInt8*)&vendor);
+            CFRelease(vendorID);
+            
+            // AMD vendor ID is 0x1002
+            if (vendor == 0x1002) {
+                amd_count++;
+            }
+        }
+        
+        IOObjectRelease(service);
+    }
+    
+    IOObjectRelease(iterator);
+    *count = amd_count;
+    return GPU_SUCCESS;
+}
+
+gpu_error_t amd_macos_get_gpu_info(int32_t index, gpu_info_t* info) {
+    if (!info) return GPU_ERROR_INVALID_PARAM;
+    
+    int current_index = 0;
+    io_iterator_t iterator;
+    
+    kern_return_t kr = IOServiceGetMatchingServices(kIOMasterPortDefault,
+                                                     IOServiceMatching("IOPCIDevice"),
+                                                     &iterator);
+    
+    if (kr != KERN_SUCCESS) {
+        return GPU_ERROR_API_FAILED;
+    }
+    
+    io_object_t service;
+    int found = 0;
+    
+    while ((service = IOIteratorNext(iterator))) {
+        CFTypeRef vendorID = IORegistryEntryCreateCFProperty(service, CFSTR("vendor-id"),
+                                                               kCFAllocatorDefault, 0);
+        
+        if (vendorID) {
+            UInt32 vendor = 0;
+            CFDataGetBytes(vendorID, CFRangeMake(0, sizeof(UInt32)), (UInt8*)&vendor);
+            CFRelease(vendorID);
+            
+            if (vendor == 0x1002) {  // AMD
+                if (current_index == index) {
+                    found = 1;
+                    
+                    memset(info, 0, sizeof(gpu_info_t));
+                    info->index = index;
+                    info->vendor = GPU_VENDOR_AMD;
+                    
+                    // Get model name
+                    CFTypeRef model = IORegistryEntryCreateCFProperty(service, CFSTR("model"),
+                                                                        kCFAllocatorDefault, 0);
+                    if (model && CFGetTypeID(model) == CFDataGetTypeID()) {
+                        const char* modelStr = (const char*)CFDataGetBytePtr(model);
+                        snprintf(info->name, sizeof(info->name), "%s", modelStr);
+                        CFRelease(model);
+                    } else {
+                        snprintf(info->name, sizeof(info->name), "AMD GPU %d", index);
+                    }
+                    
+                    // Get device ID for UUID
+                    CFTypeRef deviceID = IORegistryEntryCreateCFProperty(service, CFSTR("device-id"),
+                                                                           kCFAllocatorDefault, 0);
+                    if (deviceID) {
+                        UInt32 devID = 0;
+                        CFDataGetBytes(deviceID, CFRangeMake(0, sizeof(UInt32)), (UInt8*)&devID);
+                        snprintf(info->uuid, sizeof(info->uuid), "AMD-macOS-0x%04X", devID);
+                        CFRelease(deviceID);
+                    }
+                    
+                    snprintf(info->pci_bus_id, sizeof(info->pci_bus_id), "PCI:%d", index);
+                    
+                    // macOS does not provide detailed GPU monitoring APIs
+                    // Metal framework and IOKit have limited metrics access
+                    info->memory_total = 0;
+                    info->memory_used = 0;
+                    info->memory_free = 0;
+                    info->gpu_utilization = 0.0f;
+                    info->memory_utilization = 0.0f;
+                    info->temperature = 0.0f;
+                    info->power_usage = 0.0f;
+                    info->core_clock = 0;
+                    info->memory_clock = 0;
+                    info->fan_speed = 0.0f;
+                    
+                    IOObjectRelease(service);
+                    break;
+                }
+                current_index++;
+            }
+        }
+        
+        IOObjectRelease(service);
+    }
+    
+    IOObjectRelease(iterator);
+    return found ? GPU_SUCCESS : GPU_ERROR_API_FAILED;
+}