pinokiod 7.3.5 → 7.3.6

package/kernel/resource_usage/index.js

@@ -55,8 +55,7 @@ class ResourceUsageService {
     })
     this.gpuSampler = new GpuSampler({
       kernel: this.kernel,
-      ttlMs: 10000,
-      timeoutMs: 2500
+      ttlMs: 5000
     })
     this.cpuAverages = new Map()
     this.workspaceCache = new Map()
@@ -76,6 +75,12 @@ class ResourceUsageService {
     return preferences
   }
 
+  stop() {
+    if (this.gpuSampler && typeof this.gpuSampler.stop === "function") {
+      this.gpuSampler.stop()
+    }
+  }
+
   getShellRootGroups() {
     if (!this.kernel || !this.kernel.shell || typeof this.kernel.path !== "function") {
       return new Map()
@@ -243,8 +248,8 @@ class ResourceUsageService {
       ? await this.macFootprintSampler.getFootprintByPid(this.selectFootprintPids(allPids))
       : null
 
-    const gpuSnapshot = preferences.show_vram && allPids.size > 0
-      ? await this.gpuSampler.getSnapshot()
+    const gpuSnapshot = preferences.show_vram && this.platform !== "darwin" && allPids.size > 0
+      ? await this.gpuSampler.getSnapshot(allPids)
       : null
 
     const nextCache = new Map()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "7.3.5",
+  "version": "7.3.6",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -56,6 +56,7 @@
     "key-store": "^1.2.0",
     "kill-sync": "^1.0.3",
     "kleur": "^4.1.5",
+    "koffi": "^3.0.2",
     "lodash": "^4.17.21",
     "marked": "^5.0.1",
     "mime-types": "^2.1.35",

package/server/index.js

@@ -396,6 +396,9 @@ class Server {
     }
   }
   stop() {
+    if (this.resourceUsage && typeof this.resourceUsage.stop === 'function') {
+      this.resourceUsage.stop()
+    }
     this.server.close()
   }
   killProcessTree(pid, label) {

package/server/views/install.ejs

@@ -19,10 +19,11 @@ document.documentElement.dataset.installSpinnerVariant = "grid-shift"
 <style>
 body {
   --install-status-bg: var(--pinokio-chrome-accent-bg-light);
+  --install-spinner-fg: rgba(0,0,0,0.8);
   --install-status-fg: var(--pinokio-chrome-accent-fg-light);
   --install-status-fg-soft: rgba(225, 178, 97, 0.34);
   --install-status-border: rgba(15, 23, 42, 0.12);
-  --install-status-detail: rgba(235, 222, 197, 0.82);
+  --install-status-detail: rgba(0, 0, 0, 0.6);
   height: 100%;
   overflow: hidden;
   /*
@@ -33,6 +34,7 @@ body {
 }
 body.dark {
   --install-status-bg: var(--pinokio-chrome-accent-bg-dark);
+  --install-spinner-fg: white;
   --install-status-fg: var(--pinokio-chrome-accent-fg-dark);
   --install-status-fg-soft: rgba(194, 178, 138, 0.28);
   --install-status-border: rgba(255, 255, 255, 0.08);
@@ -114,9 +116,6 @@ body.dark {
   width: 100%;
   margin: 0;
   overflow: hidden;
-  border-top: 1px solid var(--install-status-border);
-  background: var(--install-status-bg);
-  color: var(--install-status-fg);
 }
 #status-screen code {
   font-family: "RobotoMono", monospace;
@@ -132,7 +131,6 @@ body.dark {
   flex: 1;
 }
 .install-status-title {
-  color: var(--install-status-fg);
   font-size: 15px;
   line-height: 1.2;
   font-weight: 700;
@@ -189,13 +187,12 @@ body.dark {
   border-radius: 2px;
 }
 .install-status-grid-anchor {
-  background: var(--install-status-fg);
   opacity: 0.16;
 }
 .install-status-grid-tile,
 .install-status-grid-chaser,
 .install-status-grid-pixel {
-  background: var(--install-status-fg);
+  background: var(--install-spinner-fg);
 }
 .install-status-grid-pixel {
   width: 4px;

package/test/resource-usage-gpu.test.js

@@ -1,10 +1,17 @@
 const assert = require("node:assert/strict")
+const fs = require("node:fs")
+const os = require("node:os")
+const path = require("node:path")
 const test = require("node:test")
 
 const {
   GpuSampler,
-  parseNvidiaCsv,
-  parseWindowsGpuProcessMemoryCsv
+  NvmlGpuMemoryClient,
+  collectLinuxDrmFdinfoProcesses,
+  decodeWindowsMultiSz,
+  extractPidFromWindowsGpuInstance,
+  isDedicatedDrmMemoryRegion,
+  parseLinuxDrmFdinfo
 } = require("../kernel/resource_usage/gpu")
 
 const MIB = 1024 * 1024
@@ -16,111 +23,331 @@ function gpuProcess(pid, bytes) {
   }
 }
 
-test("parseNvidiaCsv treats nounits memory as MiB and sums duplicate PIDs", () => {
-  const processes = parseNvidiaCsv([
-    "1234, 256",
-    "1234, 128",
-    "5678, N/A"
+test("extractPidFromWindowsGpuInstance handles full PDH counter paths", () => {
+  assert.equal(extractPidFromWindowsGpuInstance("app_pid_3456_phys_0"), 3456)
+  assert.equal(extractPidFromWindowsGpuInstance("\\\\HOST\\GPU Process Memory(pid_1234_luid_0x00000000_phys_0)\\Dedicated Usage"), 1234)
+  assert.equal(extractPidFromWindowsGpuInstance("\\\\HOST\\GPU Process Memory(_total)\\Dedicated Usage"), null)
+})
+
+test("decodeWindowsMultiSz decodes double-null UTF-16 string lists", () => {
+  const text = "one\u0000two\u0000\u0000"
+  const buffer = Buffer.from(text, "utf16le")
+
+  assert.deepEqual(decodeWindowsMultiSz(buffer, text.length), ["one", "two"])
+})
+
+test("parseLinuxDrmFdinfo counts dedicated DRM memory regions only", () => {
+  const amdgpu = parseLinuxDrmFdinfo([
+    "drm-driver:\tamdgpu",
+    "drm-pdev:\t0000:03:00.0",
+    "drm-client-id:\t17",
+    "drm-memory-vram:\t4 MiB",
+    "drm-memory-gtt:\t128 MiB"
   ].join("\n"))
 
-  assert.equal(processes.get(1234).usedGpuMemoryBytes, 384 * MIB)
-  assert.equal(processes.has(5678), false)
+  const intel = parseLinuxDrmFdinfo([
+    "drm-driver:\ti915",
+    "drm-pdev:\t0000:00:02.0",
+    "drm-client-id:\t9",
+    "drm-resident-local0:\t8 MiB",
+    "drm-resident-system:\t64 MiB"
+  ].join("\n"))
+
+  assert.equal(amdgpu.dedicatedBytes, 4 * MIB)
+  assert.equal(intel.dedicatedBytes, 8 * MIB)
+  assert.equal(isDedicatedDrmMemoryRegion("vram"), true)
+  assert.equal(isDedicatedDrmMemoryRegion("local0"), true)
+  assert.equal(isDedicatedDrmMemoryRegion("gtt"), false)
+  assert.equal(isDedicatedDrmMemoryRegion("system"), false)
 })
 
-test("parseWindowsGpuProcessMemoryCsv extracts dedicated GPU bytes from process counter instances", () => {
-  const processes = parseWindowsGpuProcessMemoryCsv([
-    "\"(PDH-CSV 4.0)\",\"\\\\HOST\\GPU Process Memory(pid_1234_luid_0x00000000_0x00011111_phys_0)\\Dedicated Usage\",\"\\\\HOST\\GPU Process Memory(pid_1234_luid_0x00000000_0x00011111_phys_1)\\Dedicated Usage\",\"\\\\HOST\\GPU Process Memory(_total)\\Dedicated Usage\"",
-    "\"06/18/2026 12:00:00.000\",\"268435456.000000\",\"134217728.000000\",\"1047527424.000000\"",
-    "The command completed successfully."
-  ].join("\r\n"))
+test("collectLinuxDrmFdinfoProcesses deduplicates DRM client fds", async () => {
+  const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), "pinokio-drm-fdinfo-"))
+  try {
+    await fs.promises.mkdir(path.join(root, "1234", "fdinfo"), { recursive: true })
+    await fs.promises.mkdir(path.join(root, "5678", "fdinfo"), { recursive: true })
+    await fs.promises.writeFile(path.join(root, "1234", "fdinfo", "3"), [
+      "drm-driver:\tamdgpu",
+      "drm-pdev:\t0000:03:00.0",
+      "drm-client-id:\t17",
+      "drm-resident-vram:\t12 MiB"
+    ].join("\n"))
+    await fs.promises.writeFile(path.join(root, "1234", "fdinfo", "4"), [
+      "drm-driver:\tamdgpu",
+      "drm-pdev:\t0000:03:00.0",
+      "drm-client-id:\t17",
+      "drm-resident-vram:\t11 MiB"
+    ].join("\n"))
+    await fs.promises.writeFile(path.join(root, "1234", "fdinfo", "5"), [
+      "drm-driver:\tamdgpu",
+      "drm-pdev:\t0000:03:00.0",
+      "drm-client-id:\t18",
+      "drm-resident-vram:\t5 MiB"
+    ].join("\n"))
+    await fs.promises.writeFile(path.join(root, "5678", "fdinfo", "9"), [
+      "drm-driver:\tamdgpu",
+      "drm-pdev:\t0000:03:00.0",
+      "drm-client-id:\t22",
+      "drm-resident-gtt:\t64 MiB"
+    ].join("\n"))
 
-  assert.equal(processes.get(1234).usedGpuMemoryBytes, 384 * MIB)
-  assert.equal(processes.has(999), false)
+    const processes = await collectLinuxDrmFdinfoProcesses([1234, 5678], { procRoot: root })
+
+    assert.equal(processes.get(1234).usedGpuMemoryBytes, 17 * MIB)
+    assert.equal(processes.has(5678), false)
+  } finally {
+    await fs.promises.rm(root, { recursive: true, force: true })
+  }
 })
 
-test("GpuSampler uses Windows GPU counters before nvidia-smi on Windows", async () => {
-  const sampler = new GpuSampler({ platform: "win32" })
-  let nvidiaCalls = 0
-  sampler.collectWindowsGpuProcessMemory = async () => {
-    return {
-      provider: "windows-gpu-process-memory",
-      processes: new Map([
+test("GpuSampler uses Windows PDH only on Windows", async () => {
+  const sampler = new GpuSampler({
+    platform: "win32",
+    windowsPdhClient: {
+      collect: () => new Map([
         [1234, gpuProcess(1234, 500 * MIB)]
-      ]),
-      error: null
+      ])
     }
+  })
+
+  const snapshot = await sampler.collect(new Set([1234]))
+
+  assert.equal(snapshot.available, true)
+  assert.deepEqual(snapshot.providers, ["windows-pdh"])
+  assert.equal(snapshot.processes.get(1234).usedGpuMemoryBytes, 500 * MIB)
+})
+
+test("GpuSampler reports Windows VRAM unavailable when PDH fails", async () => {
+  const originalWarn = console.warn
+  console.warn = () => {}
+
+  try {
+    const sampler = new GpuSampler({
+      platform: "win32",
+      windowsPdhClient: {
+        collect: () => {
+          throw new Error("pdh unavailable")
+        }
+      }
+    })
+
+    const snapshot = await sampler.collect(new Set([1234]))
+
+    assert.equal(snapshot.available, false)
+    assert.deepEqual(snapshot.providers, ["windows-pdh"])
+    assert.equal(snapshot.processes.size, 0)
+    assert.equal(snapshot.errors[0].provider, "windows-pdh")
+  } finally {
+    console.warn = originalWarn
   }
-  sampler.collectNvidia = async () => {
-    nvidiaCalls += 1
-    return {
-      provider: "nvidia-smi",
-      processes: new Map([
-        [1234, gpuProcess(1234, 500 * MIB)]
-      ]),
-      error: null
-    }
+})
+
+test("GpuSampler logs provider failures once per backoff window", async () => {
+  const originalWarn = console.warn
+  const warnings = []
+  console.warn = (...args) => {
+    warnings.push(args)
   }
-  sampler.collectAmd = async () => null
 
-  const snapshot = await sampler.collect()
+  try {
+    const sampler = new GpuSampler({
+      platform: "win32",
+      windowsPdhClient: {
+        collect: () => {
+          const error = new Error("pdh unavailable")
+          error.code = "PDH_TEST"
+          throw error
+        }
+      }
+    })
 
-  assert.equal(nvidiaCalls, 0)
-  assert.deepEqual(snapshot.providers, ["windows-gpu-process-memory"])
-  assert.equal(snapshot.processes.get(1234).usedGpuMemoryBytes, 500 * MIB)
+    await sampler.collect(new Set([1234]))
+    await sampler.collect(new Set([1234]))
+
+    assert.equal(warnings.length, 1)
+    assert.equal(warnings[0][0], "[resource-usage:gpu] provider failed")
+    assert.deepEqual(warnings[0][1], {
+      provider: "windows-pdh",
+      platform: "win32",
+      pid_count: 1,
+      error: "pdh unavailable",
+      code: "PDH_TEST"
+    })
+  } finally {
+    console.warn = originalWarn
+  }
 })
 
-test("GpuSampler does not query nvidia-smi on Windows when OS counters fail", async () => {
-  const sampler = new GpuSampler({ platform: "win32" })
-  let nvidiaCalls = 0
-  sampler.collectWindowsGpuProcessMemory = async () => ({
-    provider: "windows-gpu-process-memory",
-    processes: new Map(),
-    error: "counter unavailable"
+test("GpuSampler uses Linux DRM fdinfo before native library providers", async () => {
+  const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), "pinokio-drm-sampler-"))
+  try {
+    await fs.promises.mkdir(path.join(root, "1234", "fdinfo"), { recursive: true })
+    await fs.promises.writeFile(path.join(root, "1234", "fdinfo", "3"), [
+      "drm-driver:\ti915",
+      "drm-pdev:\t0000:00:02.0",
+      "drm-client-id:\t4",
+      "drm-resident-local0:\t32 MiB"
+    ].join("\n"))
+
+    const sampler = new GpuSampler({ platform: "linux", procRoot: root })
+    let nvmlCalls = 0
+    let amdCalls = 0
+    let rocmCalls = 0
+    sampler.collectNvml = async () => {
+      nvmlCalls += 1
+      return null
+    }
+    sampler.collectAmdSmi = async () => {
+      amdCalls += 1
+      return null
+    }
+    sampler.collectRocmSmi = async () => {
+      rocmCalls += 1
+      return null
+    }
+
+    const snapshot = await sampler.collect(new Set([1234]))
+
+    assert.equal(nvmlCalls, 0)
+    assert.equal(amdCalls, 0)
+    assert.equal(rocmCalls, 0)
+    assert.deepEqual(snapshot.providers, ["linux-drm-fdinfo"])
+    assert.equal(snapshot.available, true)
+    assert.equal(snapshot.processes.get(1234).usedGpuMemoryBytes, 32 * MIB)
+  } finally {
+    await fs.promises.rm(root, { recursive: true, force: true })
+  }
+})
+
+test("GpuSampler uses NVML when fdinfo does not cover target PID", async () => {
+  const sampler = new GpuSampler({
+    platform: "linux",
+    nvmlClient: {
+      collect: () => new Map([
+        [1234, gpuProcess(1234, 700 * MIB)]
+      ])
+    }
   })
-  sampler.collectNvidia = async () => {
-    nvidiaCalls += 1
-    return {
-      provider: "nvidia-smi",
-      processes: new Map([
-        [1234, gpuProcess(1234, 300 * MIB)]
-      ]),
-      error: null
+  sampler.collectLinuxDrmFdinfo = async () => null
+  let amdCalls = 0
+  sampler.collectAmdSmi = async () => {
+    amdCalls += 1
+    return null
+  }
+
+  const snapshot = await sampler.collect(new Set([1234]))
+
+  assert.equal(amdCalls, 0)
+  assert.deepEqual(snapshot.providers, ["linux-nvml"])
+  assert.equal(snapshot.processes.get(1234).usedGpuMemoryBytes, 700 * MIB)
+})
+
+test("NvmlGpuMemoryClient sums the same PID across devices", () => {
+  const client = new NvmlGpuMemoryClient({ koffi: { sizeof: () => 1 } })
+  const compute = { name: "compute" }
+  const graphics = { name: "graphics" }
+  client.init = () => {}
+  client.getDeviceHandles = () => ["gpu0", "gpu1"]
+  client.functions = { compute, graphics, mps: null }
+  client.collectProcessList = (device, entry) => {
+    const samples = {
+      "gpu0:compute": [{ pid: 1234, usedGpuMemory: 300 * MIB }],
+      "gpu0:graphics": [{ pid: 1234, usedGpuMemory: 250 * MIB }],
+      "gpu1:compute": [{ pid: 1234, usedGpuMemory: 400 * MIB }],
+      "gpu1:graphics": [{ pid: 1234, usedGpuMemory: 100 * MIB }]
     }
+    return samples[`${device}:${entry && entry.name}`] || []
   }
-  sampler.collectAmd = async () => null
 
-  const snapshot = await sampler.collect()
+  const processes = client.collect([1234])
 
-  assert.equal(nvidiaCalls, 0)
-  assert.equal(snapshot.available, false)
-  assert.deepEqual(snapshot.providers, ["windows-gpu-process-memory"])
-  assert.equal(snapshot.processes.has(1234), false)
+  assert.equal(processes.get(1234).usedGpuMemoryBytes, 700 * MIB)
+})
+
+
+test("GpuSampler uses AMD SMI after fdinfo and NVML miss", async () => {
+  const sampler = new GpuSampler({
+    platform: "linux",
+    amdSmiClient: {
+      collect: () => new Map([
+        [2222, gpuProcess(2222, 300 * MIB)]
+      ])
+    }
+  })
+  sampler.collectLinuxDrmFdinfo = async () => null
+  sampler.collectNvml = async () => null
+  let rocmCalls = 0
+  sampler.collectRocmSmi = async () => {
+    rocmCalls += 1
+    return null
+  }
+
+  const snapshot = await sampler.collect(new Set([2222]))
+
+  assert.equal(rocmCalls, 0)
+  assert.deepEqual(snapshot.providers, ["linux-amdsmi"])
+  assert.equal(snapshot.processes.get(2222).usedGpuMemoryBytes, 300 * MIB)
+})
+
+test("GpuSampler uses ROCm SMI after AMD SMI misses", async () => {
+  const sampler = new GpuSampler({
+    platform: "linux",
+    rocmSmiClient: {
+      collect: () => new Map([
+        [3333, gpuProcess(3333, 200 * MIB)]
+      ])
+    }
+  })
+  sampler.collectLinuxDrmFdinfo = async () => null
+  sampler.collectNvml = async () => null
+  sampler.collectAmdSmi = async () => null
+
+  const snapshot = await sampler.collect(new Set([3333]))
+
+  assert.deepEqual(snapshot.providers, ["linux-rocm-smi"])
+  assert.equal(snapshot.processes.get(3333).usedGpuMemoryBytes, 200 * MIB)
 })
 
 test("GpuSampler merges overlapping provider samples by PID without double-counting", async () => {
   const sampler = new GpuSampler({ platform: "linux" })
-  sampler.collectNvidia = async () => ({
-    provider: "nvidia-smi",
+  sampler.collectLinuxDrmFdinfo = async () => ({
+    provider: "linux-drm-fdinfo",
     processes: new Map([
-      [1234, gpuProcess(1234, 300 * MIB)],
-      [3333, gpuProcess(3333, 200 * MIB)]
+      [1234, gpuProcess(1234, 300 * MIB)]
     ]),
     error: null
   })
-  sampler.collectAmd = async () => ({
-    provider: "amd-smi",
+  sampler.collectNvml = async () => ({
+    provider: "linux-nvml",
     processes: new Map([
       [1234, gpuProcess(1234, 500 * MIB)],
-      [2222, gpuProcess(2222, 100 * MIB)]
+      [3333, gpuProcess(3333, 200 * MIB)]
     ]),
     error: null
   })
+  sampler.collectAmdSmi = async () => null
+  sampler.collectRocmSmi = async () => null
 
   const snapshot = await sampler.collect()
 
   assert.equal(snapshot.available, true)
-  assert.deepEqual(snapshot.providers, ["nvidia-smi", "amd-smi"])
+  assert.deepEqual(snapshot.providers, ["linux-drm-fdinfo", "linux-nvml"])
   assert.equal(snapshot.processes.get(1234).usedGpuMemoryBytes, 500 * MIB)
-  assert.equal(snapshot.processes.get(2222).usedGpuMemoryBytes, 100 * MIB)
   assert.equal(snapshot.processes.get(3333).usedGpuMemoryBytes, 200 * MIB)
 })
+
+test("GpuSampler does not collect VRAM providers on macOS", async () => {
+  const sampler = new GpuSampler({ platform: "darwin" })
+  sampler.collectNvml = async () => {
+    throw new Error("NVML should not be queried on macOS")
+  }
+  sampler.collectAmdSmi = async () => {
+    throw new Error("AMD SMI should not be queried on macOS")
+  }
+
+  const snapshot = await sampler.collect()
+
+  assert.equal(snapshot.available, false)
+  assert.deepEqual(snapshot.providers, [])
+  assert.equal(snapshot.processes.size, 0)
+})