node-gpuinfo 1.0.0

package/src/macos/intel_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 intel_macos_get_gpu_count(int32_t* count) {
+    if (!count) return GPU_ERROR_INVALID_PARAM;
+    
+    int intel_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);
+            
+            // Intel vendor ID is 0x8086
+            if (vendor == 0x8086) {
+                intel_count++;
+            }
+        }
+        
+        IOObjectRelease(service);
+    }
+    
+    IOObjectRelease(iterator);
+    *count = intel_count;
+    return GPU_SUCCESS;
+}
+
+gpu_error_t intel_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 == 0x8086) {  // Intel
+                if (current_index == index) {
+                    found = 1;
+                    
+                    memset(info, 0, sizeof(gpu_info_t));
+                    info->index = index;
+                    info->vendor = GPU_VENDOR_INTEL;
+                    
+                    // 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), "Intel 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), "INTEL-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;
+}

package/src/macos/nvidia_mac.c

@@ -0,0 +1,21 @@
+#include "../gpu_info.h"
+#include <stdio.h>
+#include <string.h>
+
+// macOS NVIDIA support is extremely limited
+// Apple dropped NVIDIA support after macOS High Sierra (10.13)
+
+gpu_error_t nvidia_macos_get_gpu_count(int32_t* count) {
+    if (!count) return GPU_ERROR_INVALID_PARAM;
+    
+    // NVIDIA GPUs are not supported on modern macOS
+    *count = 0;
+    return GPU_SUCCESS;
+}
+
+gpu_error_t nvidia_macos_get_gpu_info(int32_t index, gpu_info_t* info) {
+    if (!info) return GPU_ERROR_INVALID_PARAM;
+    
+    // NVIDIA GPUs are not supported on modern macOS
+    return GPU_ERROR_NOT_SUPPORTED;
+}

package/src/vendor/amd.c

@@ -0,0 +1,37 @@
+#include "../gpu_info.h"
+
+// Forward declarations for platform-specific implementations
+#ifdef _WIN32
+gpu_error_t amd_windows_get_gpu_count(int32_t* count);
+gpu_error_t amd_windows_get_gpu_info(int32_t index, gpu_info_t* info);
+#elif defined(__APPLE__)
+gpu_error_t amd_macos_get_gpu_count(int32_t* count);
+gpu_error_t amd_macos_get_gpu_info(int32_t index, gpu_info_t* info);
+#else
+gpu_error_t amd_linux_get_gpu_count(int32_t* count);
+gpu_error_t amd_linux_get_gpu_info(int32_t index, gpu_info_t* info);
+#endif
+
+gpu_error_t amd_get_gpu_count(int32_t* count) {
+    if (!count) return GPU_ERROR_INVALID_PARAM;
+    
+#ifdef _WIN32
+    return amd_windows_get_gpu_count(count);
+#elif defined(__APPLE__)
+    return amd_macos_get_gpu_count(count);
+#else
+    return amd_linux_get_gpu_count(count);
+#endif
+}
+
+gpu_error_t amd_get_gpu_info(int32_t index, gpu_info_t* info) {
+    if (!info) return GPU_ERROR_INVALID_PARAM;
+    
+#ifdef _WIN32
+    return amd_windows_get_gpu_info(index, info);
+#elif defined(__APPLE__)
+    return amd_macos_get_gpu_info(index, info);
+#else
+    return amd_linux_get_gpu_info(index, info);
+#endif
+}

package/src/vendor/intel.c

@@ -0,0 +1,37 @@
+#include "../gpu_info.h"
+
+// Forward declarations for platform-specific implementations
+#ifdef _WIN32
+gpu_error_t intel_windows_get_gpu_count(int32_t* count);
+gpu_error_t intel_windows_get_gpu_info(int32_t index, gpu_info_t* info);
+#elif defined(__APPLE__)
+gpu_error_t intel_macos_get_gpu_count(int32_t* count);
+gpu_error_t intel_macos_get_gpu_info(int32_t index, gpu_info_t* info);
+#else
+gpu_error_t intel_linux_get_gpu_count(int32_t* count);
+gpu_error_t intel_linux_get_gpu_info(int32_t index, gpu_info_t* info);
+#endif
+
+gpu_error_t intel_get_gpu_count(int32_t* count) {
+    if (!count) return GPU_ERROR_INVALID_PARAM;
+    
+#ifdef _WIN32
+    return intel_windows_get_gpu_count(count);
+#elif defined(__APPLE__)
+    return intel_macos_get_gpu_count(count);
+#else
+    return intel_linux_get_gpu_count(count);
+#endif
+}
+
+gpu_error_t intel_get_gpu_info(int32_t index, gpu_info_t* info) {
+    if (!info) return GPU_ERROR_INVALID_PARAM;
+    
+#ifdef _WIN32
+    return intel_windows_get_gpu_info(index, info);
+#elif defined(__APPLE__)
+    return intel_macos_get_gpu_info(index, info);
+#else
+    return intel_linux_get_gpu_info(index, info);
+#endif
+}

package/src/vendor/nvidia.c

@@ -0,0 +1,37 @@
+#include "../gpu_info.h"
+
+// Forward declarations for platform-specific implementations
+#ifdef _WIN32
+gpu_error_t nvidia_windows_get_gpu_count(int32_t* count);
+gpu_error_t nvidia_windows_get_gpu_info(int32_t index, gpu_info_t* info);
+#elif defined(__APPLE__)
+gpu_error_t nvidia_macos_get_gpu_count(int32_t* count);
+gpu_error_t nvidia_macos_get_gpu_info(int32_t index, gpu_info_t* info);
+#else
+gpu_error_t nvidia_linux_get_gpu_count(int32_t* count);
+gpu_error_t nvidia_linux_get_gpu_info(int32_t index, gpu_info_t* info);
+#endif
+
+gpu_error_t nvidia_get_gpu_count(int32_t* count) {
+    if (!count) return GPU_ERROR_INVALID_PARAM;
+    
+#ifdef _WIN32
+    return nvidia_windows_get_gpu_count(count);
+#elif defined(__APPLE__)
+    return nvidia_macos_get_gpu_count(count);
+#else
+    return nvidia_linux_get_gpu_count(count);
+#endif
+}
+
+gpu_error_t nvidia_get_gpu_info(int32_t index, gpu_info_t* info) {
+    if (!info) return GPU_ERROR_INVALID_PARAM;
+    
+#ifdef _WIN32
+    return nvidia_windows_get_gpu_info(index, info);
+#elif defined(__APPLE__)
+    return nvidia_macos_get_gpu_info(index, info);
+#else
+    return nvidia_linux_get_gpu_info(index, info);
+#endif
+}