@fraczak/k 7.0.1 → 7.1.0

package/scripts/perf-poly.mjs

@@ -24,8 +24,6 @@ import {
   csvEnv,
   formatTiming,
   createLLVMRunner,
-  createARM64Runner,
-  arm64LaneName,
   llvmLaneName,
   makeCacheDir,
   parseNonNegativeIntEnv,
@@ -56,7 +54,6 @@ import {
   writeValueToArena
 } from "../backends/wasm/tests/perf-support.mjs";
 
-import { compileARM64ArtifactFromObject } from "../backends/arm64/src/arm64.mjs";
 import { compileWasmArtifactFromObject } from "../backends/wasm/src/wasm.mjs";
 import { inputPatternForObjectRelation } from "../backends/llvm/src/executable.mjs";
 
@@ -65,7 +62,7 @@ function printHelp() {
 
 Polymorphic List Operations Benchmark Harness.
 Benchmarks reverse, concat, split_by, get_nth, and length on
-Examples/poly.k across Native JS, kVM interpreter, LLVM, Wasm, and ARM64.
+Examples/poly.k across Native JS, kVM interpreter, LLVM, Wasm, and PKIR.
 
 Options:
   --trace
@@ -74,18 +71,20 @@ Options:
       Enable per-function call count profiling.
   --wasm-in-process
       Run WebAssembly in-process instead of persistent subprocess runner.
+  --pkir-only
+      Run only PKIR backend.
   -h, --help
       Show this help message and exit.
 
 Environment Variables:
   BACKENDS
-      Target backend to run: 'llvm', 'wasm', or 'arm64'.
+      Target backend to run: 'llvm', 'wasm', or 'pkir'.
   LLVM_ONLY
       Run only LLVM backend ('1' to enable).
   WASM_ONLY
       Run only WebAssembly backend ('1' to enable).
-  ARM64_ONLY
-      Run only ARM64 backend ('1' to enable).
+  PKIR_ONLY
+      Run only PKIR backend ('1' to enable).
   BACKENDS_ONLY
       Skip JS and kVM interpreter baselines ('1' to enable).
   LIST_LENGTH
@@ -96,14 +95,6 @@ Environment Variables:
       Enable nanosecond execution tracing ('1' to enable).
   PROFILE, K_PROFILE
       Enable per-function call count profiling ('1' to enable).
-  ARM64_WARMUP_ITERATIONS
-      Warmup iterations for ARM64 backend (default: 1).
-  ARM64_OPT
-      ARM64 backend optimization flags (default: -O2).
-  ARM64_SPAWN_PER_CALL
-      Spawn process per ARM64 call instead of persistent ('1' or '0').
-  ARM64_PIPELINE
-      Use persistent pipelined runner for ARM64 ('1' or '0').
   LLVM_WARMUP_ITERATIONS
       Warmup iterations for LLVM backend (default: 1).
   LLVM_SPAWN_PER_CALL
@@ -129,15 +120,52 @@ if (process.argv.includes("-h") || process.argv.includes("--help")) {
 
 // Backend selection
 const backendsEnv = process.env.BACKENDS?.toLowerCase();
-const llvmOnly = process.env.LLVM_ONLY === "1" || backendsEnv === "llvm";
-const wasmOnly = process.env.WASM_ONLY === "1" || backendsEnv === "wasm";
-const arm64Only = process.env.ARM64_ONLY === "1" || backendsEnv === "arm64";
-
-const isArm64Host = process.arch === "arm64" && process.platform === "linux";
-const runARM64 = !wasmOnly && !llvmOnly && (isArm64Host || arm64Only);
-const runLLVM = !wasmOnly && !arm64Only;
-const runWasm = !llvmOnly && !arm64Only;
-const runBaselines = !process.env.BACKENDS_ONLY && (process.env.LLVM_ONLY !== "1") && (process.env.WASM_ONLY !== "1") && (process.env.ARM64_ONLY !== "1");
+const backendsList = backendsEnv
+  ? backendsEnv.split(",").map(s => s.trim())
+  : null;
+const llvmPkirOnly = process.env.LLVM_PKIR_ONLY === "1"
+  || (backendsList && backendsList.length === 1 &&
+      backendsList[0] === "llvm-pkir")
+  || process.argv.includes("--llvm-pkir-only");
+const pkirOnly = !llvmPkirOnly && (
+  process.env.PKIR_ONLY === "1"
+  || (backendsList && backendsList.length === 1 &&
+      backendsList[0] === "pkir")
+  || process.argv.includes("--pkir-only")
+);
+const llvmOnly = !pkirOnly && !llvmPkirOnly && (
+  process.env.LLVM_ONLY === "1"
+  || (backendsList && backendsList.length === 1 &&
+      backendsList[0] === "llvm")
+);
+const wasmOnly = !pkirOnly && !llvmPkirOnly && !llvmOnly && (
+  process.env.WASM_ONLY === "1"
+  || (backendsList && backendsList.length === 1 &&
+      backendsList[0] === "wasm")
+);
+const runLLVM = backendsList
+  ? backendsList.includes("llvm")
+  : !wasmOnly && !pkirOnly && !llvmPkirOnly;
+const runLLVMPKIR = backendsList
+  ? backendsList.includes("llvm-pkir")
+  : !wasmOnly && !pkirOnly && !llvmOnly;
+const runWasm = backendsList
+  ? backendsList.includes("wasm")
+  : !llvmOnly && !pkirOnly && !llvmPkirOnly;
+const runPKIR = backendsList
+  ? backendsList.includes("pkir")
+  : !llvmOnly && !wasmOnly && !llvmPkirOnly;
+const runBaselines = !process.env.BACKENDS_ONLY
+  && (backendsList == null || backendsList.includes("kvm") ||
+      backendsList.includes("js"))
+  && !llvmOnly && !wasmOnly && !pkirOnly && !llvmPkirOnly;
+
+function llvmLaneNameStr() {
+  return llvmLaneName();
+}
+function llvmPkirLaneNameStr() {
+  return llvmLaneName().replace("LLVM", "LLVM-PKIR");
+}
 
 const ops = ["reverse", "concat", "split_by", "get_nth", "length"];
 const benchNames = Object.fromEntries(ops.map(op => [op, `bench_${op}`]));
@@ -146,10 +174,6 @@ const iterations = parsePositiveIntEnv("ITERATIONS", 3);
 const runTrace = process.argv.includes("--trace") || process.env.TRACE === "1" || process.env.K_TRACE === "1";
 const runProfile = runTrace || process.argv.includes("--profile") || process.env.K_PROFILE === "1" || process.env.PROFILE === "1";
 
-// ARM64 options
-const arm64WarmupIterations = parseNonNegativeIntEnv("ARM64_WARMUP_ITERATIONS", 1);
-const arm64OptLevel = process.env.ARM64_OPT || "-O2";
-
 // LLVM options
 const llvmWarmupIterations = parseNonNegativeIntEnv("LLVM_WARMUP_ITERATIONS", 1);
 const cacheDir = makeCacheDir("k-poly-perf-");
@@ -164,6 +188,9 @@ function wasmLaneName() {
   const mode = wasmPipe ? "persistent" : "in-process";
   return `WebAssembly (${mode})`;
 }
+function pkirLaneName() {
+  return "PKIR (Wasm persistent)";
+}
 
 
 console.log("==> Loading @fraczak/k/Examples/arithmetics.k as library");
@@ -193,7 +220,7 @@ function buildExportPreamble(exports, libraries) {
   return lines.join("\n") + "\n";
 }
 
-const neededExports = ["0", "int", "inc", "dec", "nat", "zero_int?"];
+const neededExports = ["0", "int", "inc", "dec", "nat", "zero_int?", "neg?", "GT"];
 const exportPreamble = buildExportPreamble(neededExports, [arithmeticsLib]);
 const polyLib = loadLibrary(compileLibrary(exportPreamble + polySource, {
   source: polyPath,
@@ -219,7 +246,7 @@ for (const op of ops) {
 }
 
 function intValue(text) {
-  return valueForCode(parseIntValue(text), state.typeAliases.int, codes.find);
+  return parseIntValue(text);
 }
 
 function makeList(elements) {
@@ -315,13 +342,37 @@ if (runLLVM) {
       relHash: relation.relHash,
       inputPattern: tc.inputPattern,
       cacheDir,
-      sourceLabel: `@fraczak/k/Examples/poly.k#${relation.relationName}`
+      sourceLabel:
+        `@fraczak/k/Examples/poly.k#${relation.relationName}`,
+      usePKIR: false
     });
   }
   codes.load(state.codes);
   printCompileFailures(testSuite);
 }
 
+// Setup LLVM-PKIR
+if (runLLVMPKIR) {
+  console.log("==> Compiling LLVM-PKIR executables");
+  for (const tc of testSuite) {
+    const relation = relations[tc.op];
+    tc.llvmPKIR = tryCompileCase({
+      object: relation.object,
+      relationName: relation.relationName,
+      relHash: relation.relHash,
+      inputPattern: tc.inputPattern,
+      cacheDir,
+      sourceLabel:
+        `@fraczak/k/Examples/poly.k#${relation.relationName}`,
+      usePKIR: true
+    });
+  }
+  codes.load(state.codes);
+  printCompileFailures(
+    testSuite.map(tc => ({ ...tc, llvm: tc.llvmPKIR }))
+  );
+}
+
 // Setup Wasm
 let wasmExports = null;
 let wasmProfileFunctions = [];
@@ -364,6 +415,34 @@ if (runWasm) {
   }
 }
 
+// Setup PKIR (persistent runner)
+const pkirExes = new Map();
+if (runPKIR) {
+  console.log("==> Compiling PKIR executables (persistent runner)...");
+  for (const tc of testSuite) {
+    const relation = relations[tc.op];
+    try {
+      const wasmPath = path.join(cacheDir, `perf_poly_pkir_${tc.op}.wasm`);
+      const exePath = path.join(cacheDir, `perf_poly_pkir_${tc.op}.exe`);
+      const wasmBuf = await compileWasmArtifactFromObject(relation.object, {
+        entry: relation.relHash,
+        usePKIR: true
+      });
+      fs.writeFileSync(wasmPath, wasmBuf);
+      const runBin = fileURLToPath(import.meta.resolve("../backends/wasm/bin/k-wasm-run.mjs"));
+      fs.writeFileSync(exePath, `#!/bin/sh\nexec node "${runBin}" "${wasmPath}" "$@"\n`, { mode: 0o755 });
+      tc.pkir = { status: "ok", exePath, wasmPath };
+      pkirExes.set(tc.op, tc.pkir);
+    } catch (error) {
+      tc.pkir = {
+        status: "failed",
+        error: error.stack || error.message || String(error)
+      };
+      pkirExes.set(tc.op, tc.pkir);
+    }
+  }
+}
+
 function createWasmRunner(testSuite) {
   const wasmCases = testSuite.filter(tc => tc.wasm?.status === "ok");
   const servers = new Map();
@@ -392,39 +471,32 @@ function createWasmRunner(testSuite) {
   };
 }
 
-// Setup ARM64
-const arm64Exes = new Map();
-if (runARM64) {
-  console.log(`==> Compiling Linux ARM64 executables (${arm64OptLevel})...`);
-  for (const tc of testSuite) {
-    const relation = relations[tc.op];
-    try {
-      const exePath = path.join(cacheDir, `perf_poly_arm64_${tc.op}`);
-      compileARM64ArtifactFromObject(relation.object, {
-        entry: relation.relationName,
-        inputPattern: tc.inputPattern,
-        outputPattern: tc.outputPattern,
-        outputPath: exePath,
-        optLevel: arm64OptLevel,
-        profile: runProfile
-      });
-      tc.arm64 = { status: "ok", exePath };
-      arm64Exes.set(tc.op, tc.arm64);
-    } catch (error) {
-      tc.arm64 = {
-        status: "failed",
-        error: error.stack || error.message || String(error)
-      };
-      arm64Exes.set(tc.op, tc.arm64);
+function createPKIRRunner(testSuite) {
+  const pkirCases = testSuite.filter(tc => tc.pkir?.status === "ok");
+  const servers = new Map();
+  function serverFor(exePath) {
+    let server = servers.get(exePath);
+    if (server == null) {
+      server = new PersistentExecutable(exePath);
+      servers.set(exePath, server);
     }
+    return server;
   }
-  const failedOps = [...arm64Exes.entries()].filter(([_, v]) => v.status !== "ok");
-  if (failedOps.length > 0) {
-    console.log("Linux ARM64 compilation failures:");
-    for (const [op, res] of failedOps) {
-      console.log(`  ${op}: ${res.error.split("\n")[0]}`);
+
+  return {
+    async run(iterations) {
+      if (pkirCases.length === 0) return null;
+      return runTimedIterationsAsync(iterations, async () => {
+        for (const tc of pkirCases) {
+          await serverFor(tc.pkir.exePath).request(tc.inputWire);
+        }
+      });
+    },
+    serverFor,
+    close() {
+      for (const server of servers.values()) server.close();
     }
-  }
+  };
 }
 
 function printBenchmarkDescription() {
@@ -434,9 +506,10 @@ function printBenchmarkDescription() {
     lanes.push("Native JS (Envelope-Free)");
     lanes.push("kVM Interpreter (Env-Free)");
   }
-  if (runLLVM) lanes.push(llvmLaneName());
+  if (runLLVM) lanes.push(llvmLaneNameStr());
+  if (runLLVMPKIR) lanes.push(llvmPkirLaneNameStr());
   if (runWasm) lanes.push(wasmLaneName());
-  if (runARM64) lanes.push(arm64LaneName(arm64OptLevel));
+  if (runPKIR) lanes.push(pkirLaneName());
 
   console.log("==> Benchmark description");
   console.log("    source: @fraczak/k/Examples/poly.k");
@@ -448,16 +521,17 @@ function printBenchmarkDescription() {
     console.log(`    llvm-ready cases: ${testSuite.filter(tc => tc.llvm?.status === "ok").length}`);
     console.log(`    llvm warmup iterations: ${llvmWarmupIterations}`);
   }
+  if (runLLVMPKIR) {
+    console.log(`    llvm-pkir ready cases: ${testSuite.filter(tc => tc.llvmPKIR?.status === "ok").length}`);
+    console.log(`    llvm-pkir warmup iterations: ${llvmWarmupIterations}`);
+  }
   if (runWasm) {
     console.log(`    wasm runner mode: ${wasmPipe ? "persistent pipe" : "in-process"}`);
     console.log(`    wasm warmup iterations: ${wasmWarmupIterations}`);
     if (!wasmPipe) console.log(`    wasm arena reset: ${wasmReset ? "yes" : "no"}`);
   }
-  if (runARM64) {
-    console.log(`    arm64-ready cases: ${testSuite.filter(tc => tc.arm64?.status === "ok").length}`);
-    console.log(`    arm64 warmup iterations: ${arm64WarmupIterations}`);
-    console.log(`    arm64 opt level: ${arm64OptLevel}`);
-    console.log(`    arm64 runner mode: ${process.env.ARM64_SPAWN_PER_CALL === "1" ? "spawn per call" : "persistent"}`);
+  if (runPKIR) {
+    console.log(`    pkir warmup iterations: ${wasmWarmupIterations}`);
   }
   console.log(`    iterations: ${iterations}`);
   console.log(`    benchmark lanes: ${lanes.join("; ")}`);
@@ -494,6 +568,23 @@ if (runLLVM) {
   }
 }
 
+// 2b. LLVM-PKIR lane
+let llvmPkirResult = null;
+if (runLLVMPKIR) {
+  const llvmPkirCases = testSuite.map(tc => ({ ...tc, llvm: tc.llvmPKIR }));
+  const llvmPkirRunner = createLLVMRunner(llvmPkirCases);
+  try {
+    if (llvmWarmupIterations > 0) {
+      console.log(`==> Warming LLVM-PKIR executables (${llvmWarmupIterations} iterations)...`);
+      await llvmPkirRunner.run(llvmWarmupIterations);
+    }
+    console.log(`==> Running LLVM-PKIR (${iterations} iterations)...`);
+    llvmPkirResult = await llvmPkirRunner.run(iterations);
+  } finally {
+    llvmPkirRunner.close();
+  }
+}
+
 // 3. Wasm lane
 let wasmResult = null;
 if (runWasm) {
@@ -539,22 +630,21 @@ if (runWasm) {
   }
 }
 
-// 4. Linux ARM64 lane
-let arm64Result = null;
-if (runARM64) {
-  const arm64Cases = testSuite.filter(tc => tc.arm64?.status === "ok");
-  if (arm64Cases.length === testSuite.length) {
-    const arm64Runner = createARM64Runner(testSuite);
+// 4. PKIR lane
+let pkirResult = null;
+if (runPKIR) {
+  const pkirCases = testSuite.filter(tc => tc.pkir?.status === "ok");
+  if (pkirCases.length === testSuite.length) {
+    const pkirRunner = createPKIRRunner(testSuite);
     try {
-      if (arm64WarmupIterations > 0) {
-        console.log(`==> Warming Linux ARM64 (${arm64WarmupIterations} iterations)...`);
-        await arm64Runner.run(arm64WarmupIterations);
+      if (wasmWarmupIterations > 0) {
+        console.log(`==> Warming PKIR (${wasmWarmupIterations} iterations)...`);
+        await pkirRunner.run(wasmWarmupIterations);
       }
-
-      console.log(`==> Running Linux ARM64 (${iterations} iterations)...`);
-      arm64Result = await arm64Runner.run(iterations);
+      console.log(`==> Running PKIR (${iterations} iterations)...`);
+      pkirResult = await pkirRunner.run(iterations);
     } finally {
-      arm64Runner.close();
+      pkirRunner.close();
     }
   }
 }
@@ -570,14 +660,18 @@ if (runBaselines) {
   console.log(`${laneIndex++}. kVM Interpreter (Env-Free):   ${formatTiming(kvmFreeResult)}`);
 }
 if (runLLVM) {
-  console.log(`${laneIndex++}. ${llvmLaneName().padEnd(29)} ${formatTiming(llvmResult)}`);
+  const name = llvmLaneNameStr().padEnd(29);
+  console.log(`${laneIndex++}. ${name} ${formatTiming(llvmResult)}`);
+}
+if (runLLVMPKIR) {
+  const name = llvmPkirLaneNameStr().padEnd(29);
+  console.log(`${laneIndex++}. ${name} ${formatTiming(llvmPkirResult)}`);
 }
 if (runWasm) {
   console.log(`${laneIndex++}. ${wasmLaneName().padEnd(29)} ${formatTiming(wasmResult)}`);
 }
-if (runARM64) {
-  const timingStr = arm64Result ? formatTiming(arm64Result) : "compile failed";
-  console.log(`${laneIndex++}. ${arm64LaneName(arm64OptLevel).padEnd(29)} ${timingStr}`);
+if (runPKIR) {
+  console.log(`${laneIndex++}. ${pkirLaneName().padEnd(29)} ${formatTiming(pkirResult)}`);
 }
 console.log("=====================================================================\n");
 
@@ -605,6 +699,23 @@ for (const tc of testSuite) {
     }
   }
 
+  if (runLLVMPKIR) {
+    if (tc.llvmPKIR.status !== "ok") {
+      tc.llvmPkirConformance = "compile-failed";
+    } else {
+      try {
+        const outputWire = await runExecutable(tc.llvmPKIR.exePath, tc.inputWire);
+        const actual = decodeWire(outputWire).value;
+        assert.ok(safeDeepEqual(actual, tc.expected), `LLVM-PKIR output mismatch for ${tc.op}`);
+        tc.llvmPkirConformance = "ok";
+      } catch (error) {
+        tc.llvmPkirConformance = "failed";
+        tc.llvmPKIR.error = error.stack || error.message || String(error);
+        console.log(`LLVM-PKIR conformance failure for ${tc.op}:`, tc.llvmPKIR.error.split("\n")[0]);
+      }
+    }
+  }
+
   if (runWasm) {
     if (wasmPipe) {
       if (tc.wasm?.status !== "ok") {
@@ -644,22 +755,23 @@ for (const tc of testSuite) {
     }
   }
 
-  if (runARM64) {
-    if (tc.arm64?.status !== "ok") {
-      tc.arm64Conformance = "compile-failed";
+  if (runPKIR) {
+    if (tc.pkir?.status !== "ok") {
+      tc.pkirConformance = "compile-failed";
     } else {
       try {
-        const outputWire = await runExecutable(tc.arm64.exePath, tc.inputWire);
+        const outputWire = await runExecutable(tc.pkir.exePath, tc.inputWire);
         const actual = decodeWire(outputWire).value;
-        assert.ok(safeDeepEqual(actual, tc.expected), `ARM64 output mismatch for ${tc.op}`);
-        tc.arm64Conformance = "ok";
+        assert.ok(safeDeepEqual(actual, tc.expected), `PKIR output mismatch for ${tc.op}`);
+        tc.pkirConformance = "ok";
       } catch (error) {
-        tc.arm64Conformance = "failed";
-        tc.arm64.error = error.stack || error.message || String(error);
-        console.log(`Linux ARM64 conformance failure for ${tc.op}:`, tc.arm64.error.split("\n")[0]);
+        tc.pkirConformance = "failed";
+        tc.pkir.error = error.stack || error.message || String(error);
+        console.log(`PKIR conformance failure for ${tc.op}:`, tc.pkir.error.split("\n")[0]);
       }
     }
   }
+
 }
 
 const validationSummary = [];
@@ -668,19 +780,24 @@ if (runLLVM) {
   const llvmOk = testSuite.filter(tc => tc.llvmConformance === "ok").length;
   validationSummary.push(`LLVM ${llvmOk}/${testSuite.length}`);
 }
+if (runLLVMPKIR) {
+  const pkirOk = testSuite.filter(tc => tc.llvmPkirConformance === "ok").length;
+  validationSummary.push(`LLVM-PKIR ${pkirOk}/${testSuite.length}`);
+}
 if (runWasm) {
   const wasmOk = testSuite.filter(tc => tc.wasmConformance === "ok").length;
   validationSummary.push(`Wasm ${wasmOk}/${testSuite.length}`);
 }
-if (runARM64) {
-  const arm64Ok = testSuite.filter(tc => tc.arm64Conformance === "ok").length;
-  validationSummary.push(`Linux ARM64 ${arm64Ok}/${testSuite.length}`);
+if (runPKIR) {
+  const pkirOk = testSuite.filter(tc => tc.pkirConformance === "ok").length;
+  validationSummary.push(`PKIR ${pkirOk}/${testSuite.length}`);
 }
 
 console.log(`Conformance validation: ${validationSummary.join(", ")} cases match expected values.`);
 if (runLLVM && shouldStrictFail(testSuite)) process.exitCode = 1;
+if (runLLVMPKIR && shouldStrictFail(testSuite.map(tc => ({ ...tc, llvm: tc.llvmPKIR })))) process.exitCode = 1;
 if (runWasm && testSuite.some(tc => tc.wasmConformance !== "ok")) process.exitCode = 1;
-if (runARM64 && testSuite.some(tc => tc.arm64Conformance !== "ok")) process.exitCode = 1;
+if (runPKIR && testSuite.some(tc => tc.pkirConformance !== "ok")) process.exitCode = 1;
 
 if (runTrace && process.exitCode !== 1) {
   console.log("\n=================== RUNNING MACRO-PHASE TRACING ===================");
@@ -696,6 +813,18 @@ if (runTrace && process.exitCode !== 1) {
     }
   }
 
+  const llvmPkirServers = new Map();
+  if (runLLVMPKIR) {
+    for (const tc of testSuite) {
+      if (tc.llvmPKIR?.status === "ok") {
+        llvmPkirServers.set(
+          tc.op,
+          new PersistentExecutable(tc.llvmPKIR.exePath)
+        );
+      }
+    }
+  }
+
   const wasmServers = new Map();
   if (runWasm && wasmPipe) {
     for (const tc of testSuite) {
@@ -705,11 +834,11 @@ if (runTrace && process.exitCode !== 1) {
     }
   }
 
-  const arm64Servers = new Map();
-  if (runARM64) {
+  const pkirServers = new Map();
+  if (runPKIR) {
     for (const tc of testSuite) {
-      if (tc.arm64?.status === "ok") {
-        arm64Servers.set(tc.op, new PersistentExecutable(tc.arm64.exePath));
+      if (tc.pkir?.status === "ok") {
+        pkirServers.set(tc.op, new PersistentExecutable(tc.pkir.exePath));
       }
     }
   }
@@ -746,43 +875,28 @@ if (runTrace && process.exitCode !== 1) {
     const op = tc.op;
     const opData = { op, label: tc.label };
 
-    // 1. ARM64
-    if (arm64Servers.has(op)) {
-      const server = arm64Servers.get(op);
+    // 2. LLVM
+    if (llvmServers.has(op)) {
+      const server = llvmServers.get(op);
       for (let i = 0; i < 3; i++) await server.requestWithTrace(tc.inputWire);
       const samples = [];
-      let arm64Profile = null;
       for (let i = 0; i < sampleReps; i++) {
         const res = await server.requestWithTrace(tc.inputWire);
-        if (res.trace) {
-          samples.push(res.trace);
-          if (res.trace.profile) arm64Profile = res.trace.profile;
-        }
-      }
-      opData.arm64 = averageTrace(samples);
-      if (arm64Profile) {
-        if (arm64Profile.__main__ !== undefined) {
-          if (arm64Profile[op] !== undefined) {
-            arm64Profile[benchNames[op]] = arm64Profile.__main__;
-          } else {
-            arm64Profile[op] = arm64Profile.__main__;
-          }
-          delete arm64Profile.__main__;
-        }
-        opData.arm64Profile = arm64Profile;
+        if (res.trace) samples.push(res.trace);
       }
+      opData.llvm = averageTrace(samples);
     }
 
-    // 2. LLVM
-    if (llvmServers.has(op)) {
-      const server = llvmServers.get(op);
+    // 2b. LLVM-PKIR
+    if (llvmPkirServers.has(op)) {
+      const server = llvmPkirServers.get(op);
       for (let i = 0; i < 3; i++) await server.requestWithTrace(tc.inputWire);
       const samples = [];
       for (let i = 0; i < sampleReps; i++) {
         const res = await server.requestWithTrace(tc.inputWire);
         if (res.trace) samples.push(res.trace);
       }
-      opData.llvm = averageTrace(samples);
+      opData.llvmPkir = averageTrace(samples);
     }
 
     // 3. Wasm
@@ -845,6 +959,18 @@ if (runTrace && process.exitCode !== 1) {
       }
     }
 
+    // PKIR
+    if (runPKIR && pkirServers.has(op)) {
+      const server = pkirServers.get(op);
+      for (let i = 0; i < 3; i++) await server.requestWithTrace(tc.inputWire);
+      const samples = [];
+      for (let i = 0; i < sampleReps; i++) {
+        const res = await server.requestWithTrace(tc.inputWire);
+        if (res.trace) samples.push(res.trace);
+      }
+      opData.pkir = averageTrace(samples);
+    }
+
     // 4. kVM
     if (runBaselines) {
       const relDef = relations[op].relDef;
@@ -891,8 +1017,9 @@ if (runTrace && process.exitCode !== 1) {
   }
 
   for (const s of llvmServers.values()) s.close();
-  for (const s of arm64Servers.values()) s.close();
+  for (const s of llvmPkirServers.values()) s.close();
   for (const s of wasmServers.values()) s.close();
+  for (const s of pkirServers.values()) s.close();
 
   function formatUs(ns) {
     if (ns == null || ns === 0) return "      -     ";
@@ -911,26 +1038,36 @@ if (runTrace && process.exitCode !== 1) {
     { name: "Total Request Time", key: "totalNs", isTotal: true }
   ];
 
+  const activeTraceLanes = [];
+  if (runLLVM) {
+    activeTraceLanes.push({ id: "llvm", label: "LLVM" });
+  }
+  if (runLLVMPKIR) {
+    activeTraceLanes.push({ id: "llvmPkir", label: "LLVM-PKIR" });
+  }
+  if (runWasm) activeTraceLanes.push({ id: "wasm", label: "WebAssembly" });
+  if (runPKIR) activeTraceLanes.push({ id: "pkir", label: "PKIR (Wasm)" });
+  if (runBaselines) activeTraceLanes.push({ id: "kvm", label: "kVM Interp" });
+
+  const traceHeader = ["Phase                   ", ...activeTraceLanes.map(l => l.label.padEnd(13))].join(" | ");
+  const traceDivider = ["------------------------", ...activeTraceLanes.map(() => "-------------")].join("-+-");
+
   for (const item of phaseResults) {
     console.log(`\n--- Operation: ${item.op} (${item.label}) ---`);
-    console.log("Phase                    | Linux ARM64   | LLVM          | WebAssembly   | kVM Interp");
-    console.log("-------------------------+---------------+---------------+---------------+---------------");
+    console.log(traceHeader);
+    console.log(traceDivider);
     for (const phase of phases) {
       if (phase.isTotal) {
-        console.log("-------------------------+---------------+---------------+---------------+---------------");
+        console.log(traceDivider);
       }
       const pName = phase.name.padEnd(24);
-      const arm64Col = formatUs(item.arm64?.[phase.key]);
-      const llvmCol = formatUs(item.llvm?.[phase.key]);
-      const wasmCol = formatUs(item.wasm?.[phase.key]);
-      const kvmCol = formatUs(item.kvm?.[phase.key]);
-      console.log(`${pName} | ${arm64Col}  | ${llvmCol}  | ${wasmCol}  | ${kvmCol}`);
+      const cols = [pName, ...activeTraceLanes.map(l => formatUs(item[l.id]?.[phase.key]))];
+      console.log(cols.join(" | "));
     }
 
-    const hasProfile = item.arm64Profile || item.wasmProfile || item.kvmProfile;
+    const hasProfile = item.wasmProfile || item.kvmProfile;
     if (hasProfile) {
       const allFuncs = new Set([
-        ...Object.keys(item.arm64Profile || {}),
         ...Object.keys(item.wasmProfile || {}),
         ...Object.keys(item.kvmProfile || {})
       ]);
@@ -945,37 +1082,33 @@ if (runTrace && process.exitCode !== 1) {
       });
 
       console.log(`\n  Function Call Profile: ${item.op}`);
-      console.log("  Function Name            | Linux ARM64 Calls | WebAssembly Calls | kVM Interp Calls");
-      console.log("  -------------------------+-------------------+-------------------+------------------");
-      let arm64Total = 0, wasmTotal = 0, kvmTotal = 0;
+      console.log("  Function Name            | WebAssembly Calls | kVM Interp Calls");
+      console.log("  -------------------------+-------------------+------------------");
+      let wasmTotal = 0, kvmTotal = 0;
       for (const fn of sortedFuncs) {
-        const aCount = item.arm64Profile?.[fn] ?? 0;
         const wCount = item.wasmProfile?.[fn] ?? 0;
         const kCount = item.kvmProfile?.[fn] ?? 0;
-        arm64Total += aCount;
         wasmTotal += wCount;
         kvmTotal += kCount;
         const fnCol = fn.padEnd(24);
-        const aStr = (aCount > 0 ? String(aCount) : "-").padStart(17);
         const wStr = (wCount > 0 ? String(wCount) : "-").padStart(17);
         const kStr = (kCount > 0 ? String(kCount) : "-").padStart(16);
-        console.log(`  ${fnCol} | ${aStr} | ${wStr} | ${kStr}`);
+        console.log(`  ${fnCol} | ${wStr} | ${kStr}`);
       }
-      console.log("  -------------------------+-------------------+-------------------+------------------");
+      console.log("  -------------------------+-------------------+------------------");
       const totCol = "Total Calls".padEnd(24);
-      const aTotStr = String(arm64Total).padStart(17);
       const wTotStr = String(wasmTotal).padStart(17);
       const kTotStr = String(kvmTotal).padStart(16);
-      console.log(`  ${totCol} | ${aTotStr} | ${wTotStr} | ${kTotStr}`);
+      console.log(`  ${totCol} | ${wTotStr} | ${kTotStr}`);
     }
   }
 
   console.log(`\n=== AVERAGE ACROSS ALL ${phaseResults.length} OPERATIONS ===`);
-  console.log("Phase                    | Linux ARM64   | LLVM          | WebAssembly   | kVM Interp");
-  console.log("-------------------------+---------------+---------------+---------------+---------------");
+  console.log(traceHeader);
+  console.log(traceDivider);
   for (const phase of phases) {
     if (phase.isTotal) {
-      console.log("-------------------------+---------------+---------------+---------------+---------------");
+      console.log(traceDivider);
     }
     const pName = phase.name.padEnd(24);
     const avg = (backend) => {
@@ -983,30 +1116,25 @@ if (runTrace && process.exitCode !== 1) {
       if (vals.length === 0) return null;
       return vals.reduce((a, b) => a + b, 0) / vals.length;
     };
-    const arm64Col = formatUs(avg("arm64"));
-    const llvmCol = formatUs(avg("llvm"));
-    const wasmCol = formatUs(avg("wasm"));
-    const kvmCol = formatUs(avg("kvm"));
-    console.log(`${pName} | ${arm64Col}  | ${llvmCol}  | ${wasmCol}  | ${kvmCol}`);
+    const cols = [pName, ...activeTraceLanes.map(l => formatUs(avg(l.id)))];
+    console.log(cols.join(" | "));
   }
 
-  if (phaseResults.some(r => r.arm64Profile || r.wasmProfile || r.kvmProfile)) {
+  if (phaseResults.some(r => r.wasmProfile || r.kvmProfile)) {
     console.log("\n=== FUNCTION CALL COUNT SUMMARY ACROSS ALL OPERATIONS ===");
-    console.log("Operation (Case)         | Linux ARM64 Calls | WebAssembly Calls | kVM Interp Calls");
-    console.log("-------------------------+-------------------+-------------------+------------------");
-    let arm64Grand = 0, wasmGrand = 0, kvmGrand = 0;
+    console.log("Operation (Case)         | WebAssembly Calls | kVM Interp Calls");
+    console.log("-------------------------+-------------------+------------------");
+    let wasmGrand = 0, kvmGrand = 0;
     for (const r of phaseResults) {
-      const aSum = Object.values(r.arm64Profile || {}).reduce((a, b) => a + b, 0);
       const wSum = Object.values(r.wasmProfile || {}).reduce((a, b) => a + b, 0);
       const kSum = Object.values(r.kvmProfile || {}).reduce((a, b) => a + b, 0);
-      arm64Grand += aSum;
       wasmGrand += wSum;
       kvmGrand += kSum;
       const opCol = `${r.op} (${r.label})`.slice(0, 24).padEnd(24);
-      console.log(`${opCol} | ${String(aSum).padStart(17)} | ${String(wSum).padStart(17)} | ${String(kSum).padStart(16)}`);
+      console.log(`${opCol} | ${String(wSum).padStart(17)} | ${String(kSum).padStart(16)}`);
     }
-    console.log("-------------------------+-------------------+-------------------+------------------");
-    console.log(`${"Total Calls".padEnd(24)} | ${String(arm64Grand).padStart(17)} | ${String(wasmGrand).padStart(17)} | ${String(kvmGrand).padStart(16)}`);
+    console.log("-------------------------+-------------------+------------------");
+    console.log(`${"Total Calls".padEnd(24)} | ${String(wasmGrand).padStart(17)} | ${String(kvmGrand).padStart(16)}`);
   }
   console.log("=====================================================================\n");
 }