llm-checker 3.2.8 → 3.3.0

package/src/hardware/backends/cuda-detector.js

@@ -4,12 +4,15 @@
  * Supports multi-GPU setups and detailed CUDA information
  */
 
+const fs = require('fs');
+const os = require('os');
 const { execSync, exec } = require('child_process');
 
 class CUDADetector {
     constructor() {
         this.cache = null;
         this.isAvailable = null;
+        this.detectionMode = null;
     }
 
     /**
@@ -20,18 +23,134 @@ class CUDADetector {
             return this.isAvailable;
         }
 
+        if (this.hasNvidiaSMI()) {
+            this.isAvailable = true;
+            this.detectionMode = 'nvidia-smi';
+            return this.isAvailable;
+        }
+
+        if (this.isJetsonPlatform() && this.hasJetsonCudaSupport()) {
+            this.isAvailable = true;
+            this.detectionMode = 'jetson';
+            return this.isAvailable;
+        }
+
+        this.isAvailable = false;
+        this.detectionMode = null;
+
+        return this.isAvailable;
+    }
+
+    hasNvidiaSMI() {
         try {
             execSync('nvidia-smi --version', {
                 encoding: 'utf8',
                 timeout: 5000,
                 stdio: ['pipe', 'pipe', 'pipe']
             });
-            this.isAvailable = true;
+            return true;
         } catch (e) {
-            this.isAvailable = false;
+            return false;
         }
+    }
 
-        return this.isAvailable;
+    readFileIfExists(path) {
+        try {
+            if (!fs.existsSync(path)) return null;
+            return fs.readFileSync(path, 'utf8').replace(/\0/g, '').trim();
+        } catch (e) {
+            return null;
+        }
+    }
+
+    isJetsonPlatform() {
+        if (process.platform !== 'linux') return false;
+
+        // Strong L4T marker present on Jetson devices
+        if (this.readFileIfExists('/etc/nv_tegra_release')) {
+            return true;
+        }
+
+        const modelPaths = [
+            '/proc/device-tree/model',
+            '/sys/firmware/devicetree/base/model',
+            '/proc/device-tree/compatible',
+            '/sys/firmware/devicetree/base/compatible'
+        ];
+
+        const jetsonMarkers = [
+            'jetson',
+            'tegra',
+            'orin',
+            'xavier',
+            'p3701',
+            'p3767',
+            'p2888',
+            'p3668',
+            'p3448'
+        ];
+
+        for (const modelPath of modelPaths) {
+            const model = this.readFileIfExists(modelPath);
+            if (!model) continue;
+
+            const modelLower = model.toLowerCase();
+            if (jetsonMarkers.some((marker) => modelLower.includes(marker))) {
+                return true;
+            }
+        }
+
+        // Jetson kernels often include tegra in release string
+        const kernelRelease = (os.release() || '').toLowerCase();
+        if (kernelRelease.includes('tegra')) {
+            return true;
+        }
+
+        // Last-resort utility-based detection for minimal installs
+        if (process.arch === 'arm64' && (
+            fs.existsSync('/usr/bin/tegrastats') ||
+            fs.existsSync('/usr/sbin/nvpmodel')
+        )) {
+            return true;
+        }
+
+        const cpuInfo = this.readFileIfExists('/proc/cpuinfo');
+        if (cpuInfo) {
+            const cpuLower = cpuInfo.toLowerCase();
+            if (cpuLower.includes('nvidia') && cpuLower.includes('tegra')) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    hasJetsonCudaSupport() {
+        const runtimeHints = [
+            '/usr/local/cuda',
+            '/usr/bin/tegrastats',
+            '/usr/sbin/nvpmodel',
+            '/usr/lib/aarch64-linux-gnu/tegra',
+            '/etc/nv_tegra_release',
+            '/dev/nvhost-gpu',
+            '/dev/nvmap',
+            '/proc/driver/nvidia/version'
+        ];
+
+        if (runtimeHints.some((hintPath) => fs.existsSync(hintPath))) {
+            return true;
+        }
+
+        try {
+            execSync('nvcc --version', {
+                encoding: 'utf8',
+                timeout: 5000,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            return true;
+        } catch (e) {
+            return false;
+        }
     }
 
     /**
@@ -47,7 +166,14 @@ class CUDADetector {
         }
 
         try {
-            const info = this.getGPUInfo();
+            const info = this.detectionMode === 'jetson'
+                ? this.getJetsonGPUInfo()
+                : this.getGPUInfo();
+
+            if (!info || !Array.isArray(info.gpus) || info.gpus.length === 0) {
+                return null;
+            }
+
             this.cache = info;
             return info;
         } catch (error) {
@@ -192,6 +318,201 @@ class CUDADetector {
         return result;
     }
 
+    getJetsonGPUInfo() {
+        const modelRaw = this.readJetsonModel();
+        const model = this.normalizeJetsonModel(modelRaw);
+        const cudaVersion = this.detectJetsonCudaVersion();
+        const driverVersion = this.detectJetsonDriverVersion();
+        const totalSystemGB = Math.max(1, Math.round(os.totalmem() / (1024 ** 3)));
+        const sharedGpuMemoryGB = Math.max(1, Math.round(totalSystemGB * 0.85));
+        const capabilities = this.getJetsonCapabilities(modelRaw || model);
+        const speedCoefficient = this.getJetsonSpeedCoefficient(modelRaw || model);
+
+        return {
+            gpus: [
+                {
+                    index: 0,
+                    name: model,
+                    uuid: null,
+                    memory: {
+                        total: sharedGpuMemoryGB,
+                        free: Math.max(0, sharedGpuMemoryGB - 1),
+                        used: Math.min(1, sharedGpuMemoryGB)
+                    },
+                    computeMode: 'Default',
+                    pcie: {
+                        generation: 0,
+                        width: 0
+                    },
+                    power: {
+                        draw: 0,
+                        limit: 0
+                    },
+                    temperature: 0,
+                    utilization: {
+                        gpu: 0,
+                        memory: 0
+                    },
+                    clocks: {
+                        current: 0,
+                        max: 0
+                    },
+                    capabilities,
+                    speedCoefficient
+                }
+            ],
+            driver: driverVersion,
+            cuda: cudaVersion,
+            totalVRAM: sharedGpuMemoryGB,
+            backend: 'cuda',
+            isMultiGPU: false,
+            speedCoefficient
+        };
+    }
+
+    readJetsonModel() {
+        const sources = [
+            '/proc/device-tree/model',
+            '/sys/firmware/devicetree/base/model'
+        ];
+
+        for (const source of sources) {
+            const model = this.readFileIfExists(source);
+            if (model) return model;
+        }
+
+        return null;
+    }
+
+    normalizeJetsonModel(model) {
+        const modelLower = (model || '').toLowerCase();
+
+        if (modelLower.includes('agx orin')) return 'NVIDIA Jetson AGX Orin';
+        if (modelLower.includes('orin nx')) return 'NVIDIA Jetson Orin NX';
+        if (modelLower.includes('orin nano')) return 'NVIDIA Jetson Orin Nano';
+        if (modelLower.includes('orin')) return 'NVIDIA Jetson Orin';
+        if (modelLower.includes('xavier nx')) return 'NVIDIA Jetson Xavier NX';
+        if (modelLower.includes('agx xavier')) return 'NVIDIA Jetson AGX Xavier';
+        if (modelLower.includes('xavier')) return 'NVIDIA Jetson Xavier';
+        if (modelLower.includes('jetson nano')) return 'NVIDIA Jetson Nano';
+        if (modelLower.includes('tx2')) return 'NVIDIA Jetson TX2';
+
+        return 'NVIDIA Jetson (CUDA)';
+    }
+
+    detectJetsonCudaVersion() {
+        const versionTxt = this.readFileIfExists('/usr/local/cuda/version.txt');
+        if (versionTxt) {
+            const match = versionTxt.match(/CUDA Version\s+([\d.]+)/i);
+            if (match) return match[1];
+        }
+
+        try {
+            const nvccVersion = execSync('nvcc --version', {
+                encoding: 'utf8',
+                timeout: 5000,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            const match = nvccVersion.match(/release\s+([\d.]+)/i);
+            if (match) return match[1];
+        } catch (e) {
+            // Ignore missing nvcc
+        }
+
+        return null;
+    }
+
+    detectJetsonDriverVersion() {
+        const versionInfo = this.readFileIfExists('/proc/driver/nvidia/version');
+        if (!versionInfo) return null;
+
+        const match = versionInfo.match(/Kernel Module\s+([0-9.]+)/i);
+        return match ? match[1] : null;
+    }
+
+    getJetsonCapabilities(model) {
+        const modelLower = (model || '').toLowerCase();
+
+        if (modelLower.includes('orin')) {
+            return {
+                tensorCores: true,
+                fp16: true,
+                bf16: true,
+                int8: true,
+                fp8: false,
+                nvlink: false,
+                computeCapability: '8.7',
+                architecture: 'Ampere'
+            };
+        }
+
+        if (modelLower.includes('xavier')) {
+            return {
+                tensorCores: true,
+                fp16: true,
+                bf16: false,
+                int8: true,
+                fp8: false,
+                nvlink: false,
+                computeCapability: '7.2',
+                architecture: 'Volta'
+            };
+        }
+
+        if (modelLower.includes('tx2')) {
+            return {
+                tensorCores: false,
+                fp16: true,
+                bf16: false,
+                int8: true,
+                fp8: false,
+                nvlink: false,
+                computeCapability: '6.2',
+                architecture: 'Pascal'
+            };
+        }
+
+        if (modelLower.includes('nano')) {
+            return {
+                tensorCores: false,
+                fp16: true,
+                bf16: false,
+                int8: true,
+                fp8: false,
+                nvlink: false,
+                computeCapability: '5.3',
+                architecture: 'Maxwell'
+            };
+        }
+
+        return {
+            tensorCores: false,
+            fp16: true,
+            bf16: false,
+            int8: true,
+            fp8: false,
+            nvlink: false,
+            computeCapability: '6.2',
+            architecture: 'Jetson'
+        };
+    }
+
+    getJetsonSpeedCoefficient(model) {
+        const modelLower = (model || '').toLowerCase();
+
+        if (modelLower.includes('agx orin')) return 95;
+        if (modelLower.includes('orin nx')) return 75;
+        if (modelLower.includes('orin nano')) return 65;
+        if (modelLower.includes('orin')) return 70;
+        if (modelLower.includes('agx xavier')) return 55;
+        if (modelLower.includes('xavier nx')) return 45;
+        if (modelLower.includes('xavier')) return 50;
+        if (modelLower.includes('tx2')) return 30;
+        if (modelLower.includes('nano')) return 24;
+
+        return 35;
+    }
+
     /**
      * Get GPU capabilities based on model name
      */
@@ -283,6 +604,24 @@ class CUDADetector {
             capabilities.architecture = 'Volta';
             capabilities.nvlink = true;
         }
+        // Jetson Orin (Ampere)
+        else if (nameLower.includes('jetson') && nameLower.includes('orin')) {
+            capabilities.tensorCores = true;
+            capabilities.bf16 = true;
+            capabilities.computeCapability = '8.7';
+            capabilities.architecture = 'Ampere';
+        }
+        // Jetson Xavier (Volta)
+        else if (nameLower.includes('jetson') && nameLower.includes('xavier')) {
+            capabilities.tensorCores = true;
+            capabilities.computeCapability = '7.2';
+            capabilities.architecture = 'Volta';
+        }
+        // Jetson Nano / TX2
+        else if (nameLower.includes('jetson') && (nameLower.includes('nano') || nameLower.includes('tx2'))) {
+            capabilities.computeCapability = nameLower.includes('tx2') ? '6.2' : '5.3';
+            capabilities.architecture = nameLower.includes('tx2') ? 'Pascal' : 'Maxwell';
+        }
 
         return capabilities;
     }
@@ -339,7 +678,18 @@ class CUDADetector {
             'a40': 180,
             't4': 70,
             'v100': 120,
-            'p100': 45
+            'p100': 45,
+
+            // Jetson family
+            'jetson agx orin': 95,
+            'jetson orin nx': 75,
+            'jetson orin nano': 65,
+            'jetson orin': 70,
+            'jetson agx xavier': 55,
+            'jetson xavier nx': 45,
+            'jetson xavier': 50,
+            'jetson tx2': 30,
+            'jetson nano': 24
         };
 
         for (const [model, speed] of Object.entries(speedMap)) {