pinokiod 7.5.13 → 7.5.15

package/kernel/gpu/amd.js

@@ -1,4 +1,19 @@
 const { normalize_model } = require("./common")
+const amd_gfx_targets = require("./amd_gfx_targets.json")
+
+const canonical_model_key = (model) => {
+  let key = normalize_model(model)
+  let previous
+  do {
+    previous = key
+    key = key
+      .replace(/^advanced micro devices\s+/, "")
+      .replace(/^amd\s+/, "")
+      .replace(/^instinct\s+/, "")
+      .trim()
+  } while (key !== previous)
+  return key
+}
 
 // Detect uninformative AMD APU names that need CPU-brand fallback matching.
 const is_generic_gpu_model = (model) => {
@@ -15,58 +30,30 @@ const resolve_cpu_brand = async (cpu_brand) => {
   }
 }
 
-// Match AMD GPU model names that Pinokio should route to PyTorch ROCm wheels.
-const matches_rocm_torch_model = (model) => {
-  let normalized = normalize_model(model)
-
-  // AMD PyTorch ROCm install policy. These checks are based on the
-  // hardware families Pinokio should route to ROCm-flavored PyTorch wheels,
-  // not on whether ROCm is already installed on the machine.
-
-  // Radeon RX 7600+:
-  // - RX 7600 / 7600 XT / 7600M / 7600M XT
-  // - RX 7700 / 7800 / 7900 families
-  // - RX 9000 families such as RX 9060 and RX 9070
-  // - Future RX 8xxx/9xxx names are treated as ROCm-intended by policy.
-  let rx = normalized.match(/\brx\s*([7-9]\d{3})(?!\d)/)
-  if (rx && Number(rx[1]) >= 7600) {
-    return true
+const resolve_rocm_gfx_target = (model) => {
+  let key = canonical_model_key(model)
+  if (/^gfx[0-9a-f]+$/i.test(key)) {
+    return key.toLowerCase()
   }
-
-  // Radeon PRO W7700+:
-  // - PRO W7700 / W7800 / W7900
-  // - Future PRO W 8xxx/9xxx names are treated as ROCm-intended by policy.
-  let pro = normalized.match(/\bpro\s*w\s*([7-9]\d{3})(?!\d)/)
-  if (pro && Number(pro[1]) >= 7700) {
-    return true
+  if (amd_gfx_targets.entries[key]) {
+    return amd_gfx_targets.entries[key]
   }
 
-  return (
-    // Radeon PRO V710
-    /\bpro\s*v\s*710\b/.test(normalized) ||
-    // Radeon AI PRO R9600/R9700 variants, including suffixes like R9700S.
-    /\bai\s*pro\s*r\s*9[67]\d{2}[a-z]?\b/.test(normalized) ||
-    // Supported APUs and codenames seen in PyTorch ROCm wheel support.
-    /\b(780m|820m|880m|890m|8050s|8060s|strix|phoenix|fire range)\b/.test(normalized)
-  )
+  return null
 }
 
-// Decide AMD ROCm install intent, using CPU brand only for generic APU GPU names.
-const supports_torch_backend = async (model, cpu_brand) => {
-  if (matches_rocm_torch_model(model)) {
-    return true
+const resolve_gpu_target = async (model, cpu_brand) => {
+  let target = resolve_rocm_gfx_target(model)
+  if (target) {
+    return target
   }
   if (!is_generic_gpu_model(model)) {
-    return false
+    return null
   }
-  // APU-only systems can report the GPU as just "AMD Radeon Graphics".
-  // In that generic case, use the CPU brand as a fallback because it often
-  // includes the Radeon model or codename, such as 8060S or Strix Halo.
-  return matches_rocm_torch_model(await resolve_cpu_brand(cpu_brand))
+  return resolve_rocm_gfx_target(await resolve_cpu_brand(cpu_brand))
 }
 
 module.exports = {
-  is_generic_gpu_model,
-  matches_rocm_torch_model,
-  supports_torch_backend
+  resolve_gpu_target,
+  resolve_rocm_gfx_target
 }

package/kernel/gpu/amd_gfx_targets.json

@@ -0,0 +1,67 @@
+{
+  "source": "https://raw.githubusercontent.com/ROCm/ROCm/develop/docs/reference/gpu-arch-specs.rst",
+  "generated_by": "script/update-amd-gfx-targets.js",
+  "entries": {
+    "mi100": "gfx908",
+    "mi210": "gfx90a",
+    "mi25": "gfx900",
+    "mi250": "gfx90a",
+    "mi250x": "gfx90a",
+    "mi300a": "gfx942",
+    "mi300x": "gfx942",
+    "mi325x": "gfx942",
+    "mi350x": "gfx950",
+    "mi355x": "gfx950",
+    "mi50 16gb": "gfx906",
+    "mi50 32gb": "gfx906",
+    "mi6": "gfx803",
+    "mi60": "gfx906",
+    "mi8": "gfx803",
+    "radeon 780m": "gfx1103",
+    "radeon 8060s": "gfx1151",
+    "radeon 860m": "gfx1152",
+    "radeon 890m": "gfx1150",
+    "radeon ai pro r9600d": "gfx1201",
+    "radeon ai pro r9700": "gfx1201",
+    "radeon pro v620": "gfx1030",
+    "radeon pro v710": "gfx1101",
+    "radeon pro vii": "gfx906",
+    "radeon pro w5500": "gfx1012",
+    "radeon pro w6600": "gfx1032",
+    "radeon pro w6800": "gfx1030",
+    "radeon pro w7700": "gfx1101",
+    "radeon pro w7800": "gfx1100",
+    "radeon pro w7800 48gb": "gfx1100",
+    "radeon pro w7900": "gfx1100",
+    "radeon pro w7900 dual slot": "gfx1100",
+    "radeon rx 6600": "gfx1032",
+    "radeon rx 6600 xt": "gfx1032",
+    "radeon rx 6650 xt": "gfx1032",
+    "radeon rx 6700": "gfx1031",
+    "radeon rx 6700 xt": "gfx1031",
+    "radeon rx 6750 xt": "gfx1031",
+    "radeon rx 6800": "gfx1030",
+    "radeon rx 6800 xt": "gfx1030",
+    "radeon rx 6900 xt": "gfx1030",
+    "radeon rx 6950 xt": "gfx1030",
+    "radeon rx 7600": "gfx1102",
+    "radeon rx 7700": "gfx1101",
+    "radeon rx 7700 xt": "gfx1101",
+    "radeon rx 7800 xt": "gfx1101",
+    "radeon rx 7900 gre": "gfx1100",
+    "radeon rx 7900 xt": "gfx1100",
+    "radeon rx 7900 xtx": "gfx1100",
+    "radeon rx 9060": "gfx1200",
+    "radeon rx 9060 xt": "gfx1200",
+    "radeon rx 9060 xt lp": "gfx1200",
+    "radeon rx 9070": "gfx1201",
+    "radeon rx 9070 gre": "gfx1201",
+    "radeon rx 9070 xt": "gfx1201",
+    "radeon vii": "gfx906",
+    "ryzen 7 7840u": "gfx1103",
+    "ryzen 9 270": "gfx1103",
+    "ryzen ai 9 hx 375": "gfx1150",
+    "ryzen ai max pro 395": "gfx1151",
+    "ryzen al 7 350": "gfx1152"
+  }
+}

package/kernel/gpu/nvidia.js

@@ -1,8 +1,94 @@
-// NVIDIA routes to CUDA PyTorch wheels on supported non-macOS platforms.
-const supports_torch_backend = (controller, platform) => {
-  return !!controller && platform !== "darwin"
+const { execFile } = require("node:child_process")
+
+const NVIDIA_SMI_COMPUTE_CAP_ARGS = [
+  "--query-gpu=pci.bus_id,compute_cap",
+  "--format=csv,noheader,nounits"
+]
+
+let cuda_sm_targets_promise = null
+
+const normalize_pci_bus = (bus) => {
+  let normalized = String(bus || "").trim().toLowerCase()
+  let match = /(?:[0-9a-f]{4,8}:)?([0-9a-f]{2}:[0-9a-f]{2}\.[0-7])$/.exec(normalized)
+  return match ? match[1] : normalized
+}
+
+const compute_cap_to_sm_target = (compute_cap) => {
+  let match = /^(\d+)\.(\d+)$/.exec(String(compute_cap || "").trim())
+  return match ? `sm_${match[1]}${match[2]}` : null
+}
+
+const parse_nvidia_smi_compute_caps = (stdout) => {
+  return String(stdout || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      let parts = line.split(",").map((part) => part.trim())
+      if (parts.length < 2) return null
+      let target = compute_cap_to_sm_target(parts[1])
+      if (!target) return null
+      return {
+        pci_bus: normalize_pci_bus(parts[0]),
+        target
+      }
+    })
+    .filter(Boolean)
+}
+
+const query_cuda_sm_targets = (exec_file = execFile) => {
+  return new Promise((resolve) => {
+    exec_file(
+      "nvidia-smi",
+      NVIDIA_SMI_COMPUTE_CAP_ARGS,
+      { windowsHide: true, timeout: 5000 },
+      (error, stdout) => {
+        if (error) {
+          resolve([])
+        } else {
+          resolve(parse_nvidia_smi_compute_caps(stdout))
+        }
+      }
+    )
+  })
+}
+
+const cached_cuda_sm_targets = () => {
+  if (!cuda_sm_targets_promise) {
+    cuda_sm_targets_promise = query_cuda_sm_targets()
+  }
+  return cuda_sm_targets_promise
+}
+
+const select_cuda_sm_target = (controller, records) => {
+  let targets = Array.isArray(records) ? records : []
+  if (targets.length === 0) {
+    return null
+  }
+
+  let controller_bus = normalize_pci_bus(controller && (controller.pciBus || controller.busAddress))
+  if (controller_bus) {
+    let match = targets.find((record) => record.pci_bus === controller_bus)
+    if (match) {
+      return match.target
+    }
+  }
+
+  return targets.length === 1 ? targets[0].target : null
+}
+
+const resolve_cuda_sm_target = async (controller) => {
+  if (!controller) {
+    return null
+  }
+  let records = await cached_cuda_sm_targets()
+  return select_cuda_sm_target(controller, records)
 }
 
 module.exports = {
-  supports_torch_backend
+  compute_cap_to_sm_target,
+  parse_nvidia_smi_compute_caps,
+  query_cuda_sm_targets,
+  resolve_cuda_sm_target,
+  select_cuda_sm_target
 }

package/kernel/index.js

@@ -92,10 +92,10 @@ class Kernel {
     this.pinokio_configs = {}
     this.shellpath = shellPath.sync()
     this.favicon = new Favicon()
-    this.torch_backend = "cpu"
     this.vram = 0
     this.ram = 0
     this.gpu_driver = null
+    this.gpu_target = null
     this.readyState = new ReadyState(this)
     this.app_ready_status = this.readyState.status
     this.launchRequirements = new LaunchRequirements(this)
@@ -824,6 +824,7 @@ class Kernel {
       procs: this.procs,
       gpu: this.gpu,
       gpus: this.gpus,
+      gpu_target: this.gpu_target,
       ...info
     }
 
@@ -1152,7 +1153,7 @@ class Kernel {
           system,
           platform: this.platform,
           arch: this.arch,
-          torch_backend: this.torch_backend,
+          gpu_target: this.gpu_target,
           vram: this.vram,
           ram: this.ram,
           proxy: (port) => {
@@ -1349,7 +1350,7 @@ class Kernel {
         this.gpu = info.gpu
         this.gpu_model = info.gpu_model
         this.gpu_driver = info.gpu_driver || null
-        this.torch_backend = info.torch_backend || "cpu"
+        this.gpu_target = info.gpu_target || null
         this.gpus = info.gpus
         this.vram = typeof info.vram === "number" ? info.vram : 0
         this.ram = typeof info.ram === "number" ? info.ram : 0

package/kernel/sysinfo.js

@@ -3,8 +3,6 @@ const fs = require('fs')
 const path = require('path')
 const nvidia = require("./gpu/nvidia")
 const amd = require("./gpu/amd")
-const apple = require("./gpu/apple")
-const intel = require("./gpu/intel")
 class Sysinfo {
   async init(kernel) {
     this.kernel = kernel
@@ -74,7 +72,6 @@ class Sysinfo {
     let is_nvidia = controllers.find(x => /nvidia/i.test(x.vendor || ""))
     let is_amd = bestByVram(controllers.filter(x => /(amd|advanced micro devices)/i.test(x.vendor || "")))
     let is_apple = controllers.find(x => /apple/i.test(x.vendor || ""))
-    let is_intel = controllers.find(x => /intel/i.test(x.vendor || ""))
 
     let gpu
     let gpu_model
@@ -108,14 +105,22 @@ class Sysinfo {
     let vramMB = primaryController && primaryController.vram ? primaryController.vram : 0
     let vramGB = vramMB > 0 ? Math.round(vramMB / 1024) : 0
     let gpu_driver = driver(primaryController)
-    let torch_backend = await this.torch_backend({ is_nvidia, is_amd, is_apple, is_intel, gpu_model })
+    let cpu_brand_value
+    let cpu_brand = async () => {
+      if (cpu_brand_value === undefined) {
+        cpu_brand_value = await this.cpu_brand()
+      }
+      return cpu_brand_value
+    }
+    let detected = { is_nvidia, is_amd, gpu_model, primaryController, cpu_brand }
+    let gpu_target = await this.gpu_target(detected)
 
     this.info.graphics = g
     this.info.gpus = gpus
     this.info.gpu = gpu
     this.info.gpu_model = gpu_model
     this.info.gpu_driver = gpu_driver
-    this.info.torch_backend = torch_backend
+    this.info.gpu_target = gpu_target
     this.info.vram = vramGB
   }
   // Read CPU brand only when generic iGPU names need CPU fallback matching.
@@ -130,27 +135,13 @@ class Sysinfo {
     }
     return cpu && cpu.brand
   }
-  // Select the PyTorch backend install target from detected hardware identity.
-  async torch_backend(detected) {
-    // Do not require runtime probes such as rocminfo, hipInfo, ze_info, or
-    // an existing torch install here.
-    if (nvidia.supports_torch_backend(detected.is_nvidia, process.platform)) {
-      return "cuda"
-    } else if (apple.supports_torch_backend(detected.is_apple, process.platform)) {
-      return "mps"
-    } else if (
-      detected.is_amd &&
-      process.platform !== "darwin" &&
-      await amd.supports_torch_backend(detected.gpu_model, () => this.cpu_brand())
-    ) {
-      return "rocm"
-    } else if (
-      detected.is_intel &&
-      await intel.supports_torch_backend(detected.is_intel.model, () => this.cpu_brand())
-    ) {
-      return "xpu"
+  async gpu_target(detected) {
+    if (detected.is_nvidia) {
+      return await nvidia.resolve_cuda_sm_target(detected.primaryController)
+    } else if (detected.is_amd) {
+      return await amd.resolve_gpu_target(detected.gpu_model, detected.cpu_brand || (() => this.cpu_brand()))
     } else {
-      return "cpu"
+      return null
     }
   }
 //  async time() {

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "pinokiod",
-  "version": "7.5.13",
+  "version": "7.5.15",
   "description": "",
   "main": "index.js",
   "scripts": {
     "download_readme": "wget -O kernel/proto/PINOKIO.md https://raw.githubusercontent.com/pinokiocomputer/home/refs/heads/main/docs/README.md",
+    "update:amd-gfx-targets": "node script/update-amd-gfx-targets.js",
     "start": "node script/index"
   },
   "author": "",

package/script/update-amd-gfx-targets.js

@@ -0,0 +1,119 @@
+const fs = require('node:fs')
+const https = require('node:https')
+const path = require('node:path')
+
+const { normalize_model } = require('../kernel/gpu/common')
+
+const GPU_SPECS_URL = 'https://raw.githubusercontent.com/ROCm/ROCm/develop/docs/reference/gpu-arch-specs.rst'
+const GENERATOR = 'script/update-amd-gfx-targets.js'
+
+const repoRoot = path.resolve(__dirname, '..')
+
+function fetchText(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (response) => {
+      if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        const nextUrl = new URL(response.headers.location, url).toString()
+        response.resume()
+        fetchText(nextUrl).then(resolve, reject)
+        return
+      }
+      if (response.statusCode !== 200) {
+        response.resume()
+        reject(new Error(`${url} returned ${response.statusCode}`))
+        return
+      }
+      let body = ''
+      response.setEncoding('utf8')
+      response.on('data', (chunk) => {
+        body += chunk
+      })
+      response.on('end', () => resolve(body))
+    }).on('error', reject)
+  })
+}
+
+function canonicalKey(value) {
+  let key = normalize_model(value)
+  let previous
+  do {
+    previous = key
+    key = key
+      .replace(/^advanced micro devices\s+/, '')
+      .replace(/^amd\s+/, '')
+      .replace(/^instinct\s+/, '')
+      .trim()
+  } while (key !== previous)
+  return key
+}
+
+function addEntry(entries, name, target) {
+  const key = canonicalKey(name)
+  if (key && /^gfx[0-9a-f]+$/i.test(target)) {
+    entries[key] = target.toLowerCase()
+  }
+}
+
+function parseGpuSpecs(rst) {
+  const entries = {}
+  let headers = null
+  let cells = []
+  let inRow = false
+
+  const flushRow = () => {
+    if (!inRow || cells.length === 0) return
+    if (cells.includes('Name') && cells.includes('LLVM target name')) {
+      headers = cells
+    } else if (headers) {
+      const nameIndex = headers.indexOf('Name')
+      const graphicsIndex = headers.indexOf('Graphics model')
+      const targetIndex = headers.indexOf('LLVM target name')
+      const target = cells[targetIndex]
+      if (target) {
+        addEntry(entries, cells[nameIndex], target)
+        if (graphicsIndex >= 0) {
+          addEntry(entries, cells[graphicsIndex], target)
+        }
+      }
+    }
+    cells = []
+  }
+
+  for (const line of rst.split(/\r?\n/)) {
+    if (/^\s*\*\s*$/.test(line)) {
+      flushRow()
+      inRow = true
+      continue
+    }
+    const cell = line.match(/^\s*-\s*(.*)$/)
+    if (inRow && cell) {
+      cells.push(cell[1].trim())
+    }
+  }
+  flushRow()
+
+  return entries
+}
+
+function writeJson(relativePath, data) {
+  const file = path.join(repoRoot, relativePath)
+  fs.writeFileSync(file, `${JSON.stringify(data, null, 2)}\n`)
+}
+
+async function main() {
+  const specs = await fetchText(GPU_SPECS_URL)
+  const entries = parseGpuSpecs(specs)
+
+  writeJson('kernel/gpu/amd_gfx_targets.json', {
+    source: GPU_SPECS_URL,
+    generated_by: GENERATOR,
+    entries: Object.fromEntries(Object.entries(entries).sort(([a], [b]) => a.localeCompare(b)))
+  })
+
+  console.log(`Wrote ${Object.keys(entries).length} AMD gfx target entries`)
+}
+
+main().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/server/lib/app_log_report.js

@@ -358,8 +358,7 @@ class AppLogReportService {
         version: this.readPinokioVersion(),
         node: process.version,
         platform: kernel.platform || process.platform,
-        arch: kernel.arch || process.arch,
-        torch_backend: kernel.torch_backend || info.torch_backend || null
+        arch: kernel.arch || process.arch
       },
       hardware: this.compactObject({
         gpu: kernel.gpu || info.gpu || null,