pinokiod 7.3.4 → 7.3.5

package/kernel/resource_usage/gpu.js

@@ -7,6 +7,7 @@ const { execFileText, normalizePid } = require("./process_tree")
 
 const DEFAULT_GPU_TTL_MS = 10000
 const DEFAULT_GPU_TIMEOUT_MS = 2500
+const DEFAULT_WINDOWS_GPU_COUNTER_TTL_MS = 30000
 const MIB = 1024 * 1024
 
 function unique(values) {
@@ -98,6 +99,19 @@ function addGpuProcess(processes, pid, bytes) {
   processes.set(normalizedPid, current)
 }
 
+function mergeGpuProcess(processes, pid, bytes) {
+  const normalizedPid = normalizePid(pid)
+  if (!normalizedPid || !Number.isFinite(bytes) || bytes < 0) {
+    return
+  }
+  const current = processes.get(normalizedPid) || {
+    pid: normalizedPid,
+    usedGpuMemoryBytes: 0
+  }
+  current.usedGpuMemoryBytes = Math.max(current.usedGpuMemoryBytes || 0, bytes)
+  processes.set(normalizedPid, current)
+}
+
 function parseNvidiaCsv(stdout) {
   const processes = new Map()
   for (const line of String(stdout || "").split(/\r?\n/)) {
@@ -111,6 +125,55 @@ function parseNvidiaCsv(stdout) {
   return processes
 }
 
+function parseCsvLine(line) {
+  const values = []
+  let current = ""
+  let inQuotes = false
+  const text = String(line || "")
+  for (let i = 0; i < text.length; i += 1) {
+    const char = text[i]
+    if (char === "\"") {
+      if (inQuotes && text[i + 1] === "\"") {
+        current += "\""
+        i += 1
+      } else {
+        inQuotes = !inQuotes
+      }
+    } else if (char === "," && !inQuotes) {
+      values.push(current)
+      current = ""
+    } else {
+      current += char
+    }
+  }
+  values.push(current)
+  return values
+}
+
+function parseWindowsGpuProcessMemoryCsv(stdout) {
+  const rows = []
+  for (const line of String(stdout || "").split(/\r?\n/)) {
+    const trimmed = line.trim()
+    if (!trimmed || !trimmed.startsWith("\"")) continue
+    const row = parseCsvLine(trimmed)
+    if (row.length > 1) rows.push(row)
+  }
+  if (rows.length < 2) {
+    return new Map()
+  }
+  const headers = rows[0]
+  const values = rows[rows.length - 1]
+  const processes = new Map()
+  for (let i = 1; i < headers.length && i < values.length; i += 1) {
+    const instanceName = String(headers[i] || "")
+    const match = /pid[_\s-]*(\d+)/i.exec(instanceName)
+    const pid = normalizePid(match && match[1])
+    const bytes = parseMemoryToBytes(values[i])
+    addGpuProcess(processes, pid, bytes)
+  }
+  return processes
+}
+
 function findObjectValue(object, predicate) {
   if (!object || typeof object !== "object" || Array.isArray(object)) {
     return null
@@ -160,26 +223,29 @@ function parseAmdJson(stdout) {
 class GpuSampler {
   constructor(options = {}) {
     this.kernel = options.kernel || null
+    this.platform = options.platform || (this.kernel && this.kernel.platform) || os.platform()
     this.ttlMs = options.ttlMs || DEFAULT_GPU_TTL_MS
     this.timeoutMs = options.timeoutMs || DEFAULT_GPU_TIMEOUT_MS
+    this.windowsCounterTtlMs = options.windowsCounterTtlMs || DEFAULT_WINDOWS_GPU_COUNTER_TTL_MS
     this.current = null
     this.inFlight = null
+    this.windowsCounterCurrent = null
+    this.windowsCounterInFlight = null
     this.providerBackoff = new Map()
   }
 
   nvidiaCandidates() {
-    const platform = os.platform()
     const candidates = [
       process.env.NVIDIA_SMI,
       "nvidia-smi",
       ...getPinokioCondaCandidates(this.kernel, ["nvidia-smi"])
     ]
-    if (platform === "win32") {
+    if (this.platform === "win32") {
       candidates.push(
         "C:\\Program Files\\NVIDIA Corporation\\NVSMI\\nvidia-smi.exe",
         "C:\\Windows\\System32\\nvidia-smi.exe"
       )
-    } else if (platform === "linux") {
+    } else if (this.platform === "linux") {
       candidates.push(
         "/usr/bin/nvidia-smi",
         "/usr/local/bin/nvidia-smi",
@@ -190,13 +256,22 @@ class GpuSampler {
     return executableCandidates(candidates)
   }
 
+  windowsGpuCounterCandidates() {
+    return executableCandidates([
+      process.env.TYPEPERF,
+      "typeperf",
+      "C:\\Windows\\System32\\typeperf.exe",
+      "C:\\Windows\\Sysnative\\typeperf.exe"
+    ])
+  }
+
   amdCandidates() {
     const candidates = [
       process.env.AMD_SMI,
       "amd-smi",
       ...getPinokioCondaCandidates(this.kernel, ["amd-smi"])
     ]
-    if (os.platform() === "linux") {
+    if (this.platform === "linux") {
       candidates.push("/opt/rocm/bin/amd-smi", "/usr/bin/amd-smi", "/usr/local/bin/amd-smi")
     }
     return executableCandidates(candidates)
@@ -211,6 +286,63 @@ class GpuSampler {
     this.providerBackoff.set(provider, Date.now() + ms)
   }
 
+  async collectWindowsGpuProcessMemoryOnce() {
+    if (this.platform !== "win32" || this.isBackedOff("windows-gpu-process-memory")) {
+      return null
+    }
+    let lastError = null
+    for (const command of this.windowsGpuCounterCandidates()) {
+      try {
+        const { stdout } = await execFileText(command, [
+          "\\GPU Process Memory(*)\\Dedicated Usage",
+          "-sc",
+          "1"
+        ], { timeoutMs: Math.max(this.timeoutMs, 3000) })
+        return {
+          provider: "windows-gpu-process-memory",
+          processes: parseWindowsGpuProcessMemoryCsv(stdout),
+          error: null,
+          collectedAt: Date.now()
+        }
+      } catch (error) {
+        lastError = error
+        if (error && error.code === "ENOENT") {
+          continue
+        }
+        break
+      }
+    }
+    this.backoff("windows-gpu-process-memory", 60000)
+    return {
+      provider: "windows-gpu-process-memory",
+      processes: new Map(),
+      error: lastError && lastError.message ? lastError.message : "Windows GPU process memory counters unavailable",
+      collectedAt: Date.now()
+    }
+  }
+
+  async collectWindowsGpuProcessMemory() {
+    if (this.platform !== "win32" || this.isBackedOff("windows-gpu-process-memory")) {
+      return null
+    }
+    const now = Date.now()
+    if (this.windowsCounterCurrent && now - this.windowsCounterCurrent.collectedAt < this.windowsCounterTtlMs) {
+      return this.windowsCounterCurrent
+    }
+    if (this.windowsCounterInFlight) {
+      return this.windowsCounterInFlight
+    }
+    this.windowsCounterInFlight = this.collectWindowsGpuProcessMemoryOnce().then((result) => {
+      if (result && !result.error) {
+        this.windowsCounterCurrent = result
+      }
+      return result
+    }).finally(() => {
+      this.windowsCounterInFlight = null
+    })
+    return this.windowsCounterInFlight
+  }
+
   async collectNvidia() {
     if (this.isBackedOff("nvidia")) {
       return null
@@ -245,7 +377,7 @@ class GpuSampler {
   }
 
   async collectAmd() {
-    if (os.platform() !== "linux" || this.isBackedOff("amd")) {
+    if (this.platform !== "linux" || this.isBackedOff("amd")) {
       return null
     }
     let lastError = null
@@ -275,8 +407,15 @@ class GpuSampler {
 
   async collect() {
     const results = []
-    const nvidia = await this.collectNvidia()
-    if (nvidia) results.push(nvidia)
+
+    if (this.platform === "win32") {
+      const windowsGpuProcessMemory = await this.collectWindowsGpuProcessMemory()
+      if (windowsGpuProcessMemory) results.push(windowsGpuProcessMemory)
+    } else {
+      const nvidia = await this.collectNvidia()
+      if (nvidia) results.push(nvidia)
+    }
+
     const amd = await this.collectAmd()
     if (amd) results.push(amd)
 
@@ -288,7 +427,7 @@ class GpuSampler {
       if (result.provider) providers.push(result.provider)
       if (result.error) errors.push({ provider: result.provider, error: result.error })
       for (const entry of result.processes.values()) {
-        addGpuProcess(processes, entry.pid, entry.usedGpuMemoryBytes)
+        mergeGpuProcess(processes, entry.pid, entry.usedGpuMemoryBytes)
       }
     }
     return {
@@ -344,6 +483,8 @@ function sumGpuMemory(snapshot, pids) {
 
 module.exports = {
   GpuSampler,
+  parseNvidiaCsv,
   parseMemoryToBytes,
+  parseWindowsGpuProcessMemoryCsv,
   sumGpuMemory
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "7.3.4",
+  "version": "7.3.5",
   "description": "",
   "main": "index.js",
   "scripts": {

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

@@ -0,0 +1,126 @@
+const assert = require("node:assert/strict")
+const test = require("node:test")
+
+const {
+  GpuSampler,
+  parseNvidiaCsv,
+  parseWindowsGpuProcessMemoryCsv
+} = require("../kernel/resource_usage/gpu")
+
+const MIB = 1024 * 1024
+
+function gpuProcess(pid, bytes) {
+  return {
+    pid,
+    usedGpuMemoryBytes: bytes
+  }
+}
+
+test("parseNvidiaCsv treats nounits memory as MiB and sums duplicate PIDs", () => {
+  const processes = parseNvidiaCsv([
+    "1234, 256",
+    "1234, 128",
+    "5678, N/A"
+  ].join("\n"))
+
+  assert.equal(processes.get(1234).usedGpuMemoryBytes, 384 * MIB)
+  assert.equal(processes.has(5678), 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"))
+
+  assert.equal(processes.get(1234).usedGpuMemoryBytes, 384 * MIB)
+  assert.equal(processes.has(999), false)
+})
+
+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([
+        [1234, gpuProcess(1234, 500 * MIB)]
+      ]),
+      error: null
+    }
+  }
+  sampler.collectNvidia = async () => {
+    nvidiaCalls += 1
+    return {
+      provider: "nvidia-smi",
+      processes: new Map([
+        [1234, gpuProcess(1234, 500 * MIB)]
+      ]),
+      error: null
+    }
+  }
+  sampler.collectAmd = async () => null
+
+  const snapshot = await sampler.collect()
+
+  assert.equal(nvidiaCalls, 0)
+  assert.deepEqual(snapshot.providers, ["windows-gpu-process-memory"])
+  assert.equal(snapshot.processes.get(1234).usedGpuMemoryBytes, 500 * MIB)
+})
+
+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"
+  })
+  sampler.collectNvidia = async () => {
+    nvidiaCalls += 1
+    return {
+      provider: "nvidia-smi",
+      processes: new Map([
+        [1234, gpuProcess(1234, 300 * MIB)]
+      ]),
+      error: null
+    }
+  }
+  sampler.collectAmd = async () => null
+
+  const snapshot = await sampler.collect()
+
+  assert.equal(nvidiaCalls, 0)
+  assert.equal(snapshot.available, false)
+  assert.deepEqual(snapshot.providers, ["windows-gpu-process-memory"])
+  assert.equal(snapshot.processes.has(1234), false)
+})
+
+test("GpuSampler merges overlapping provider samples by PID without double-counting", async () => {
+  const sampler = new GpuSampler({ platform: "linux" })
+  sampler.collectNvidia = async () => ({
+    provider: "nvidia-smi",
+    processes: new Map([
+      [1234, gpuProcess(1234, 300 * MIB)],
+      [3333, gpuProcess(3333, 200 * MIB)]
+    ]),
+    error: null
+  })
+  sampler.collectAmd = async () => ({
+    provider: "amd-smi",
+    processes: new Map([
+      [1234, gpuProcess(1234, 500 * MIB)],
+      [2222, gpuProcess(2222, 100 * MIB)]
+    ]),
+    error: null
+  })
+
+  const snapshot = await sampler.collect()
+
+  assert.equal(snapshot.available, true)
+  assert.deepEqual(snapshot.providers, ["nvidia-smi", "amd-smi"])
+  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)
+})