pinokiod 8.0.45 → 8.0.47

package/kernel/sysinfo.js

@@ -3,6 +3,7 @@ const fs = require('fs')
 const path = require('path')
 const nvidia = require("./gpu/nvidia")
 const amd = require("./gpu/amd")
+const amd_pci = require("./gpu/amd_pci")
 class Sysinfo {
   async init(kernel) {
     this.kernel = kernel
@@ -139,7 +140,11 @@ class Sysinfo {
     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()))
+      let target = await amd.resolve_gpu_target(
+        detected.gpu_model,
+        detected.cpu_brand || (() => this.cpu_brand())
+      )
+      return target || await amd_pci.resolve_gpu_target(detected.primaryController)
     } else {
       return null
     }

package/kernel/vault/constants.js

@@ -1,9 +1,16 @@
+const CANDIDATE_SIZE_BASE = process.platform === "win32" ? 1024 : 1000
+const CANDIDATE_SIZE_OPTIONS = [10, 50, 100, 500]
+  .map((value) => value * CANDIDATE_SIZE_BASE ** 2)
+  .concat(CANDIDATE_SIZE_BASE ** 3)
+
 module.exports = {
-  SIZE_THRESHOLD: 100 * 1024 * 1024,
+  SIZE_THRESHOLD: CANDIDATE_SIZE_OPTIONS[2],
+  CANDIDATE_SIZE_OPTIONS,
   TMP_SUFFIX: ".pinokio-dedup-tmp",
   SHA256_RE: /^[0-9a-f]{64}$/,
   ENTRY_BATCH_SIZE: 256,
   DIR_CONCURRENCY: 8,
   STAT_CONCURRENCY: 32,
-  HASH_QUEUE_LIMIT: 256
+  HASH_QUEUE_LIMIT: 256,
+  HASH_INACTIVITY_MS: 120 * 1000
 }

package/kernel/vault/hash_worker.js

@@ -6,20 +6,32 @@ const fs = require('fs')
 // events. This changes only the read granularity; every byte still feeds the
 // same sha256 digest, one file at a time.
 const HASH_READ_SIZE = 1024 * 1024
+const HASH_PROGRESS_INTERVAL_MS = 1000
 
 parentPort.on('message', ({ id, filePath }) => {
   const hash = crypto.createHash('sha256')
   let size = 0
+  let lastProgressAt = 0
+  let complete = false
   const flags = fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0)
   const stream = fs.createReadStream(filePath, { flags, highWaterMark: HASH_READ_SIZE })
   stream.on('data', (chunk) => {
     size += chunk.length
     hash.update(chunk)
+    const now = Date.now()
+    if (now - lastProgressAt >= HASH_PROGRESS_INTERVAL_MS) {
+      lastProgressAt = now
+      parentPort.postMessage({ id, bytes_read: size })
+    }
   })
   stream.on('error', (error) => {
-    parentPort.postMessage({ id, error: error.message })
+    if (complete) return
+    complete = true
+    parentPort.postMessage({ id, error: error.message, code: error.code })
   })
   stream.on('end', () => {
+    if (complete) return
+    complete = true
     parentPort.postMessage({ id, hash: hash.digest('hex'), size })
   })
 })

package/kernel/vault/index.js

@@ -6,7 +6,10 @@ const Registry = require('./registry')
 const Sweeper = require('./sweeper')
 const { walkBatches, statMany } = require('./walker')
 const { fileSnapshot, sameSnapshot, sameContentState } = require('./snapshot')
-const { SIZE_THRESHOLD, TMP_SUFFIX, SHA256_RE, DIR_CONCURRENCY, STAT_CONCURRENCY } = require('./constants')
+const {
+  SIZE_THRESHOLD, CANDIDATE_SIZE_OPTIONS, TMP_SUFFIX, SHA256_RE,
+  DIR_CONCURRENCY, STAT_CONCURRENCY, HASH_INACTIVITY_MS
+} = require('./constants')
 
 // Shared model store engine (spec/requirements/shared-model-store.md).
 // Store + registry + volume probe + hashing + adopt/convert/verify, plus the
@@ -81,6 +84,7 @@ class Vault {
     this.workerSeq = 0
     this.workerIdleTimer = null
     this.workerIdleMs = 750
+    this.hashInactivityMs = HASH_INACTIVITY_MS
     this.statConcurrency = STAT_CONCURRENCY
     this.dirConcurrency = DIR_CONCURRENCY
     this.sizeThreshold = SIZE_THRESHOLD
@@ -167,9 +171,10 @@ class Vault {
       if (this.fileActionProgress === progress) this.fileActionProgress = null
     }
   }
-  startScan(scopeId = null) {
+  startScan(scopeId = null, sizeThreshold = this.sizeThreshold) {
     if (!this.enabled || !this.sweeper) return { started: false, disabled: true }
     if (this.scanPromise) return { started: false, already_running: true }
+    this.sizeThreshold = sizeThreshold
     this.scanError = null
     this.scanScopeId = scopeId
     this.scanPromise = this.runExclusive(() => this.sweeper.scan(scopeId))
@@ -200,11 +205,19 @@ class Vault {
           }
         }
       }
-      case "scan":
+      case "scan": {
         if (payload.scope_id && !this.scanSource(payload.scope_id)) {
           return { error: "That scan location is no longer available." }
         }
-        return this.startScan(payload.scope_id || null)
+        let sizeThreshold = this.sizeThreshold
+        if (payload.candidate_size != null) {
+          if (!CANDIDATE_SIZE_OPTIONS.includes(payload.candidate_size)) {
+            return { error: "Choose a valid minimum file size." }
+          }
+          sizeThreshold = payload.candidate_size
+        }
+        return this.startScan(payload.scope_id || null, sizeThreshold)
+      }
       case "deduplicate":
         if (typeof payload.path === "string" && payload.path) {
           return this.runMutation(() => this.runFileAction({
@@ -675,7 +688,21 @@ class Vault {
     this.volumeModes.set(dev, mode)
     return mode
   }
-  async hashFile(filePath) {
+  failHashWorker(worker, error, terminate = false) {
+    if (this.worker === worker) {
+      if (this.workerIdleTimer) clearTimeout(this.workerIdleTimer)
+      this.workerIdleTimer = null
+      this.worker = null
+    }
+    for (const [id, job] of [...this.workerJobs]) {
+      if (job.worker !== worker) continue
+      clearTimeout(job.inactivityTimer)
+      this.workerJobs.delete(id)
+      job.reject(error)
+    }
+    if (terminate) worker.terminate().catch(() => {})
+  }
+  async hashFile(filePath, options = {}) {
     if (this.workerIdleTimer) {
       clearTimeout(this.workerIdleTimer)
       this.workerIdleTimer = null
@@ -684,12 +711,24 @@ class Vault {
       const worker = new Worker(path.resolve(__dirname, "hash_worker.js"))
       this.worker = worker
       worker.unref()
-      worker.on("message", ({ id, hash, size, error }) => {
+      worker.on("message", ({ id, hash, size, bytes_read: bytesRead, error, code }) => {
         const job = this.workerJobs.get(id)
-        if (!job) return
+        if (!job || job.worker !== worker) return
+        if (Number.isFinite(bytesRead)) {
+          job.resetInactivity()
+          job.reportProgress(bytesRead)
+          return
+        }
+        clearTimeout(job.inactivityTimer)
         this.workerJobs.delete(id)
-        if (error) job.reject(new Error(error))
-        else job.resolve({ hash, size })
+        if (error) {
+          const failure = new Error(error)
+          if (code) failure.code = code
+          job.reject(failure)
+        } else {
+          job.reportProgress(size)
+          job.resolve({ hash, size })
+        }
         // Keep the worker warm across the scan queue. Starting one worker per
         // file costs ~30ms and adds up quickly on a first scan.
         if (this.workerJobs.size === 0 && this.worker === worker) {
@@ -705,27 +744,46 @@ class Vault {
       })
       worker.on("error", (error) => {
         if (this.worker !== worker) return
-        if (this.workerIdleTimer) clearTimeout(this.workerIdleTimer)
-        this.workerIdleTimer = null
-        for (const job of this.workerJobs.values()) job.reject(error)
-        this.workerJobs.clear()
-        this.worker = null
+        this.failHashWorker(worker, error)
       })
       worker.on("exit", (code) => {
         if (this.worker !== worker) return
-        if (this.workerIdleTimer) clearTimeout(this.workerIdleTimer)
-        this.workerIdleTimer = null
-        for (const job of this.workerJobs.values()) {
-          job.reject(new Error(`hash worker exited with code ${code}`))
-        }
-        this.workerJobs.clear()
-        this.worker = null
+        this.failHashWorker(worker, new Error(`hash worker exited with code ${code}`))
       })
     }
+    const worker = this.worker
     const id = ++this.workerSeq
     return new Promise((resolve, reject) => {
-      this.workerJobs.set(id, { resolve, reject })
-      this.worker.postMessage({ id, filePath })
+      const onProgress = typeof options.onProgress === "function" ? options.onProgress : null
+      const job = {
+        worker,
+        resolve,
+        reject,
+        reportProgress: (bytes) => {
+          if (!onProgress) return
+          // Progress is observational and must never fail a content hash.
+          try { onProgress(bytes) } catch (_) {}
+        },
+        inactivityTimer: null,
+        resetInactivity: null
+      }
+      job.resetInactivity = () => {
+        clearTimeout(job.inactivityTimer)
+        const inactivityMs = Math.max(1, Number(this.hashInactivityMs) || HASH_INACTIVITY_MS)
+        job.inactivityTimer = setTimeout(() => {
+          const failure = new Error(`Timed out while reading ${path.basename(filePath)}`)
+          failure.code = "ETIMEDOUT"
+          this.failHashWorker(worker, failure, true)
+        }, inactivityMs)
+        if (job.inactivityTimer.unref) job.inactivityTimer.unref()
+      }
+      this.workerJobs.set(id, job)
+      job.resetInactivity()
+      try {
+        worker.postMessage({ id, filePath })
+      } catch (error) {
+        this.failHashWorker(worker, error, true)
+      }
     })
   }
   async refreshLinkSnapshots(hash, dev, ino) {
@@ -1798,6 +1856,8 @@ class Vault {
       : sweeper.state
     return Object.assign({}, state, {
       current_file: sweeper.currentHash ? path.basename(sweeper.currentHash.path) : null,
+      current_file_bytes: sweeper.currentHash ? sweeper.currentHash.bytes : null,
+      current_file_size: sweeper.currentHash ? sweeper.currentHash.size : null,
       pending,
       error: this.scanError
     })

package/kernel/vault/sweeper.js

@@ -54,12 +54,11 @@ class Sweeper {
   idleState() {
     return {
       active: false, phase: "idle", dirs: 0, files: 0, bytes_total: 0,
-      counted_dirs: 0, counted_files: 0, total_files: null, count_estimate_files: null,
+      counted_dirs: 0, counted_files: 0, total_files: null,
       home_bytes_total: 0, source_bytes: {}, source_files: {}, source_hash_failures: {}, scope_id: null,
       candidates: 0, hashed: 0, hash_total: 0, hash_bytes: 0, queued: 0,
       inode_reuses: 0, unstable_hashes: 0, hash_failures: 0,
       inaccessible: 0, inaccessible_paths: [],
-      estimated_count_weight: 0.4, estimated_walk_weight: 0.5,
       started: null, duration_ms: null,
       count_duration_ms: null, walk_duration_ms: null, hash_wait_duration_ms: null,
       hash_duration_ms: 0
@@ -84,24 +83,6 @@ class Sweeper {
       if (!scopeId) this.vault.reconcileConfiguredSources()
       const scanRoots = this.vault.scanRoots(scopeId)
       if (!scanRoots.length) throw new Error("That scan location is no longer available.")
-      const previous = this.vault.registry.scanFor(scopeId)
-      if (previous) {
-        if (Number.isFinite(previous.files) && previous.files > 0) {
-          this.state.count_estimate_files = previous.files
-        }
-        const duration = Math.max(0, Number(previous.duration_ms) || 0)
-        const walkDuration = Math.max(0, Number(previous.walk_duration_ms) || 0)
-        const waitDuration = Math.max(0, Number(previous.hash_wait_duration_ms) || 0)
-        const countDuration = Number.isFinite(previous.count_duration_ms)
-          ? Math.max(0, previous.count_duration_ms)
-          : Math.max(0, duration - walkDuration - waitDuration)
-        const finishDuration = Math.max(1, duration - countDuration - walkDuration)
-        const measuredDuration = countDuration + walkDuration + finishDuration
-        if (measuredDuration > 1) {
-          this.state.estimated_count_weight = countDuration / measuredDuration
-          this.state.estimated_walk_weight = walkDuration / measuredDuration
-        }
-      }
       const countStarted = Date.now()
       for (const source of scanRoots) await this.countFiles(source.root)
       this.state.count_duration_ms = Date.now() - countStarted
@@ -411,9 +392,20 @@ class Sweeper {
   async _hashJob(job) {
     const primary = job.names[0]
     const started = Date.now()
-    this.currentHash = { path: primary.filePath }
+    const currentHash = {
+      path: primary.filePath,
+      size: Math.max(0, Number(primary.expected.size) || 0),
+      bytes: 0
+    }
+    this.currentHash = currentHash
     try {
-      const { hash, size } = await this.vault.hashFile(primary.filePath)
+      const { hash, size } = await this.vault.hashFile(primary.filePath, {
+        onProgress: (bytes) => {
+          if (this.currentHash === currentHash) {
+            currentHash.bytes = Math.min(currentHash.size, Math.max(0, Number(bytes) || 0))
+          }
+        }
+      })
       this.state.hashed += 1
       this.state.hash_bytes += size || 0
       const primaryStat = await fs.promises.lstat(primary.filePath)
@@ -460,7 +452,7 @@ class Sweeper {
       if (job.inodeKey && this.hashJobsByIno.get(job.inodeKey) === job) {
         this.hashJobsByIno.delete(job.inodeKey)
       }
-      this.currentHash = null
+      if (this.currentHash === currentHash) this.currentHash = null
       this.state.queued = Math.max(0, this.state.queued - 1)
       if (this.state.queued < this.hashQueueLimit) {
         for (const resolve of this.hashCapacityWaiters.splice(0)) resolve()

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "pinokiod",
-  "version": "8.0.45",
+  "version": "8.0.47",
   "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",
+    "check:amd-gfx-targets": "node script/update-amd-gfx-targets.js --check",
     "start": "node script/index"
   },
   "author": "",

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

@@ -1,11 +1,65 @@
+const crypto = require('node:crypto')
 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 AMD_VENDOR_ID = '1002'
+
+// Update these revisions deliberately during release maintenance. Runtime GPU
+// detection never fetches upstream data.
+const ROCM_REVISION = '14f8138863403a26e0caef6671cfab9b09aa636e'
+const MESA_REVISION = '3e2d8517b897026377267c09975db83525d2fc95'
+const LLVM_REVISION = '2f3f97fb72606f51ece7d64d6a7a73c9eaad8978'
+const LINUX_REVISION = '7d0a66e4bb9081d75c82ec4957c50034cb0ea449'
+const LIBDRM_REVISION = 'f198c21dfcb89127083413dd4779a13b3f9a6507'
+
+const SOURCES = {
+  rocm_specs: {
+    repository: 'https://github.com/ROCm/ROCm',
+    revision: ROCM_REVISION,
+    path: 'docs/reference/gpu-arch-specs.rst',
+    url: `https://raw.githubusercontent.com/ROCm/ROCm/${ROCM_REVISION}/docs/reference/gpu-arch-specs.rst`
+  },
+  mesa_pci_ids: {
+    repository: 'https://gitlab.freedesktop.org/mesa/mesa',
+    revision: MESA_REVISION,
+    path: 'include/pci_ids/radeonsi_pci_ids.h',
+    url: `https://gitlab.freedesktop.org/mesa/mesa/-/raw/${MESA_REVISION}/include/pci_ids/radeonsi_pci_ids.h`
+  },
+  mesa_families: {
+    repository: 'https://gitlab.freedesktop.org/mesa/mesa',
+    revision: MESA_REVISION,
+    path: 'src/amd/common/amd_family.c',
+    url: `https://gitlab.freedesktop.org/mesa/mesa/-/raw/${MESA_REVISION}/src/amd/common/amd_family.c`
+  },
+  mesa_family_names: {
+    repository: 'https://gitlab.freedesktop.org/mesa/mesa',
+    revision: MESA_REVISION,
+    path: 'src/amd/common/amd_family.h',
+    url: `https://gitlab.freedesktop.org/mesa/mesa/-/raw/${MESA_REVISION}/src/amd/common/amd_family.h`
+  },
+  llvm_processors: {
+    repository: 'https://github.com/llvm/llvm-project',
+    revision: LLVM_REVISION,
+    path: 'llvm/lib/Target/AMDGPU/GCNProcessors.td',
+    url: `https://raw.githubusercontent.com/llvm/llvm-project/${LLVM_REVISION}/llvm/lib/Target/AMDGPU/GCNProcessors.td`
+  },
+  linux_pci_ids: {
+    repository: 'https://github.com/torvalds/linux',
+    revision: LINUX_REVISION,
+    path: 'drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c',
+    url: `https://raw.githubusercontent.com/torvalds/linux/${LINUX_REVISION}/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c`
+  },
+  libdrm_names: {
+    repository: 'https://gitlab.freedesktop.org/mesa/libdrm',
+    revision: LIBDRM_REVISION,
+    path: 'data/amdgpu.ids',
+    url: `https://gitlab.freedesktop.org/mesa/libdrm/-/raw/${LIBDRM_REVISION}/data/amdgpu.ids`
+  }
+}
 
 const repoRoot = path.resolve(__dirname, '..')
 
@@ -33,6 +87,10 @@ function fetchText(url) {
   })
 }
 
+function sha256(value) {
+  return crypto.createHash('sha256').update(value).digest('hex')
+}
+
 function canonicalKey(value) {
   let key = normalize_model(value)
   let previous
@@ -95,25 +153,243 @@ function parseGpuSpecs(rst) {
   return entries
 }
 
+function parseLlvmProcessorTargets(tablegen) {
+  const processors = {}
+  const processorPattern = /def\s*:\s*ProcessorModel<"([^"]+)"([\s\S]*?)>;/g
+  let processorMatch
+  while ((processorMatch = processorPattern.exec(tablegen))) {
+    const name = processorMatch[1].toLowerCase()
+    const version = processorMatch[2].match(
+      /FeatureISAVersion([0-9]+)_([0-9a-f]+)_([0-9a-f]+)\.Features/i
+    )
+    if (!version) continue
+    const target = /^gfx[0-9a-f]+$/.test(name)
+      ? name
+      : `gfx${version[1]}${version[2]}${version[3]}`.toLowerCase()
+    processors[name] = target
+  }
+  return processors
+}
+
+function parseMesaFamilyTargets(source, processorTargets) {
+  const start = source.indexOf('const char *ac_get_llvm_processor_name')
+  const end = source.indexOf('const char *ac_get_ip_type_string', start)
+  if (start < 0 || end < 0) {
+    throw new Error('Mesa ac_get_llvm_processor_name function was not found')
+  }
+
+  const body = source.slice(start, end)
+  const familyTargets = {}
+  const returnPattern = /((?:\s*case\s+CHIP_[A-Z0-9_]+:\s*)+)\s*return\s+"([^"]+)";/g
+  let returnMatch
+  while ((returnMatch = returnPattern.exec(body))) {
+    const processor = returnMatch[2].toLowerCase()
+    const target = /^gfx[0-9a-f]+$/.test(processor)
+      ? processor
+      : processorTargets[processor]
+    if (!target || !/^gfx[0-9a-f]+$/.test(target)) continue
+
+    const familyPattern = /case\s+CHIP_([A-Z0-9_]+):/g
+    let familyMatch
+    while ((familyMatch = familyPattern.exec(returnMatch[1]))) {
+      familyTargets[familyMatch[1]] = target
+    }
+  }
+  return familyTargets
+}
+
+function parseMesaFamilyAliases(source) {
+  const aliases = {}
+  const aliasPattern = /CHIP_([A-Z0-9_]+),[^\n]*formerly\s+"([^"]+)"/gi
+  let aliasMatch
+  while ((aliasMatch = aliasPattern.exec(source))) {
+    const current = aliasMatch[1].toUpperCase()
+    const former = aliasMatch[2].toUpperCase().replace(/[^A-Z0-9]+/g, '_')
+    aliases[former] = current
+  }
+  return aliases
+}
+
+function addPciEntry(entries, device, family, target) {
+  if (!target) return
+  const key = `${AMD_VENDOR_ID}:${device.toLowerCase()}`
+  const previous = entries[key]
+  if (previous && previous.target !== target) {
+    throw new Error(
+      `Conflicting targets for ${key}: ${previous.target} (${previous.family}) and ${target} (${family})`
+    )
+  }
+  entries[key] = { target, family }
+}
+
+function parseMesaPciTargets(source, familyTargets, entries = {}) {
+  const pciPattern = /CHIPSET\(0x([0-9a-f]{4}),\s*([A-Z0-9_]+)\)/gi
+  let pciMatch
+  while ((pciMatch = pciPattern.exec(source))) {
+    const device = pciMatch[1].toLowerCase()
+    const family = pciMatch[2].toUpperCase()
+    addPciEntry(entries, device, family, familyTargets[family])
+  }
+  return entries
+}
+
+function parseLinuxPciTargets(source, familyTargets, familyAliases, entries = {}) {
+  const pciPattern = /\{\s*0x1002,\s*0x([0-9a-f]{4}),[^\n]*\bCHIP_([A-Z0-9_]+)/gi
+  let pciMatch
+  while ((pciMatch = pciPattern.exec(source))) {
+    const device = pciMatch[1].toLowerCase()
+    const sourceFamily = pciMatch[2].toUpperCase()
+    const family = familyAliases[sourceFamily] || sourceFamily
+    addPciEntry(entries, device, family, familyTargets[family])
+  }
+  return entries
+}
+
+function parseLibdrmRevisionTargets(source, modelTargets, pciTargets) {
+  const entries = {}
+  const rowPattern = /^([0-9a-f]{4}),\s*([0-9a-f]{2}),\s*(.+?)\s*$/gim
+  let rowMatch
+  while ((rowMatch = rowPattern.exec(source))) {
+    const device = rowMatch[1].toLowerCase()
+    const revision = rowMatch[2].toLowerCase()
+    const model = rowMatch[3].trim()
+    const modelTarget = modelTargets[canonicalKey(model)]
+    const pciTarget = pciTargets[`${AMD_VENDOR_ID}:${device}`]
+    if (pciTarget && modelTarget && pciTarget.target !== modelTarget) {
+      throw new Error(
+        `Conflicting family/model targets for ${device}:${revision} (${model}): ` +
+        `${pciTarget.target} and ${modelTarget}`
+      )
+    }
+    const target = pciTarget ? pciTarget.target : modelTarget
+    if (target) {
+      entries[`${AMD_VENDOR_ID}:${device}:${revision}`] = { target, model }
+    }
+  }
+  return entries
+}
+
+function sourceMetadata(definition, contents) {
+  return {
+    repository: definition.repository,
+    revision: definition.revision,
+    path: definition.path,
+    url: definition.url,
+    sha256: sha256(contents)
+  }
+}
+
+function sortedObject(entries) {
+  return Object.fromEntries(Object.entries(entries).sort(([a], [b]) => a.localeCompare(b)))
+}
+
+function buildOutputs(contents) {
+  const modelTargets = parseGpuSpecs(contents.rocm_specs)
+  const processorTargets = parseLlvmProcessorTargets(contents.llvm_processors)
+  const familyTargets = parseMesaFamilyTargets(contents.mesa_families, processorTargets)
+  const familyAliases = parseMesaFamilyAliases(contents.mesa_family_names)
+  const pciTargets = parseMesaPciTargets(contents.mesa_pci_ids, familyTargets)
+  parseLinuxPciTargets(
+    contents.linux_pci_ids,
+    familyTargets,
+    familyAliases,
+    pciTargets
+  )
+  const revisionTargets = parseLibdrmRevisionTargets(
+    contents.libdrm_names,
+    modelTargets,
+    pciTargets
+  )
+
+  const required = {
+    '1002:731f': 'gfx1010',
+    '1002:7340': 'gfx1012',
+    '1002:73bf': 'gfx1030',
+    '1002:73ff': 'gfx1032'
+  }
+  for (const [key, target] of Object.entries(required)) {
+    if (!pciTargets[key] || pciTargets[key].target !== target) {
+      throw new Error(`Pinned sources did not produce required mapping ${key} -> ${target}`)
+    }
+  }
+
+  return {
+    models: {
+      source: SOURCES.rocm_specs.url,
+      source_revision: SOURCES.rocm_specs.revision,
+      source_sha256: sha256(contents.rocm_specs),
+      generated_by: GENERATOR,
+      entries: sortedObject(modelTargets)
+    },
+    pci: {
+      generated_by: GENERATOR,
+      sources: [
+        sourceMetadata(SOURCES.mesa_pci_ids, contents.mesa_pci_ids),
+        sourceMetadata(SOURCES.mesa_families, contents.mesa_families),
+        sourceMetadata(SOURCES.mesa_family_names, contents.mesa_family_names),
+        sourceMetadata(SOURCES.llvm_processors, contents.llvm_processors),
+        sourceMetadata(SOURCES.linux_pci_ids, contents.linux_pci_ids),
+        sourceMetadata(SOURCES.libdrm_names, contents.libdrm_names)
+      ],
+      revision_entries: sortedObject(revisionTargets),
+      entries: sortedObject(pciTargets)
+    }
+  }
+}
+
 function writeJson(relativePath, data) {
   const file = path.join(repoRoot, relativePath)
   fs.writeFileSync(file, `${JSON.stringify(data, null, 2)}\n`)
 }
 
+function checkJson(relativePath, data) {
+  const file = path.join(repoRoot, relativePath)
+  const expected = `${JSON.stringify(data, null, 2)}\n`
+  if (fs.readFileSync(file, 'utf8') !== expected) {
+    throw new Error(`${relativePath} is stale; run npm run update:amd-gfx-targets`)
+  }
+}
+
 async function main() {
-  const specs = await fetchText(GPU_SPECS_URL)
-  const entries = parseGpuSpecs(specs)
+  const contents = Object.fromEntries(await Promise.all(
+    Object.entries(SOURCES).map(async ([name, source]) => [name, await fetchText(source.url)])
+  ))
+  const outputs = buildOutputs(contents)
+  const files = [
+    ['kernel/gpu/amd_gfx_targets.json', outputs.models],
+    ['kernel/gpu/amd_pci_targets.json', outputs.pci]
+  ]
 
-  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)))
-  })
+  if (process.argv.includes('--check')) {
+    for (const [file, data] of files) checkJson(file, data)
+    console.log('AMD gfx target data is up to date')
+    return
+  }
 
-  console.log(`Wrote ${Object.keys(entries).length} AMD gfx target entries`)
+  for (const [file, data] of files) writeJson(file, data)
+
+  console.log(
+    `Wrote ${Object.keys(outputs.models.entries).length} AMD model targets and ` +
+    `${Object.keys(outputs.pci.entries).length} AMD PCI targets`
+  )
 }
 
-main().catch((error) => {
-  console.error(error)
-  process.exit(1)
-})
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(error)
+    process.exit(1)
+  })
+}
+
+module.exports = {
+  SOURCES,
+  buildOutputs,
+  checkJson,
+  parseGpuSpecs,
+  parseLibdrmRevisionTargets,
+  parseLinuxPciTargets,
+  parseLlvmProcessorTargets,
+  parseMesaFamilyAliases,
+  parseMesaFamilyTargets,
+  parseMesaPciTargets
+}