@fraczak/k 7.0.2 → 7.1.0

package/scripts/perf-int.mjs

@@ -58,23 +58,27 @@ function printHelp() {
 
 Big Integer Arithmetic Performance Benchmark Harness.
 Benchmarks plus, minus, times, and squaring scale on arithmetics.k
-across Native JS, kVM interpreter, LLVM, and Wasm backends.
+across Native JS, kVM interpreter, LLVM, Wasm, and PKIR backends.
 
 Options:
   --wasm-in-process
       Run WebAssembly in-process instead of persistent subprocess runner.
   --squaring-llvm-only
       Run squaring benchmark on LLVM only.
+  --pkir-only
+      Run only PKIR backend.
   -h, --help
       Show this help message and exit.
 
 Environment Variables:
   BACKENDS
-      Target backend to run: 'llvm' or 'wasm'.
+      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).
+  PKIR_ONLY
+      Run only PKIR backend ('1' to enable).
   BACKENDS_ONLY
       Skip JS and kVM interpreter baselines ('1' to enable).
   SQUARING_LLVM_ONLY
@@ -116,12 +120,57 @@ 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" || process.argv.includes("--llvm-only");
-const wasmOnly = process.env.WASM_ONLY === "1" || backendsEnv === "wasm" || process.argv.includes("--wasm-only");
-const runLLVM = !wasmOnly;
-const runWasm = !llvmOnly;
-const runBaselines = !process.env.BACKENDS_ONLY && (process.env.LLVM_ONLY !== "1") && (process.env.WASM_ONLY !== "1");
-const squaringLlvmOnly = llvmOnly || process.env.SQUARING_LLVM_ONLY === "1" || process.argv.includes("--squaring-llvm-only");
+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")
+  || process.argv.includes("--llvm-only")
+);
+const wasmOnly = !pkirOnly && !llvmPkirOnly && !llvmOnly && (
+  process.env.WASM_ONLY === "1"
+  || (backendsList && backendsList.length === 1 &&
+      backendsList[0] === "wasm")
+  || process.argv.includes("--wasm-only")
+);
+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;
+const squaringLlvmOnly = llvmOnly || llvmPkirOnly
+  || process.env.SQUARING_LLVM_ONLY === "1"
+  || process.argv.includes("--squaring-llvm-only");
+
+function llvmLaneNameStr() {
+  return llvmLaneName();
+}
+function llvmPkirLaneNameStr() {
+  return llvmLaneName().replace("LLVM", "LLVM-PKIR");
+}
 
 const ops = ["plus", "minus", "times"];
 const benchNames = Object.fromEntries(ops.map(op => [op, `bench_${op}`]));
@@ -149,6 +198,9 @@ function wasmLaneName() {
   const mode = wasmPipe ? "persistent" : "in-process";
   return `WebAssembly (${mode})`;
 }
+function pkirLaneName() {
+  return "PKIR (Wasm persistent)";
+}
 
 console.log("==> Initializing state and loading @fraczak/k/Examples/arithmetics.k");
 const state = createState();
@@ -212,13 +264,37 @@ if (runLLVM) {
       relHash: relation.relHash,
       inputPattern: tc.inputPattern,
       cacheDir,
-      sourceLabel: `@fraczak/k/Examples/arithmetics.k#${relation.relationName}`
+      sourceLabel:
+        `@fraczak/k/Examples/arithmetics.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/arithmetics.k#${relation.relationName}`,
+      usePKIR: true
+    });
+  }
+  codes.load(state.codes);
+  printCompileFailures(
+    testSuite.map(tc => ({ ...tc, llvm: tc.llvmPKIR }))
+  );
+}
+
 // Setup Wasm
 let wasmExports = null;
 const wasmExes = new Map();
@@ -272,6 +348,35 @@ if (runWasm) {
   }
 }
 
+// Setup PKIR (persistent runner)
+const pkirExes = new Map();
+if (runPKIR) {
+  console.log("==> Compiling PKIR executables (persistent runner)...");
+  for (const op of ops) {
+    const relation = relations[op];
+    try {
+      const wasmPath = path.join(cacheDir, `perf_int_pkir_${op}.wasm`);
+      const exePath = path.join(cacheDir, `perf_int_pkir_${op}.exe`);
+      const wasmBuf = await compileWasmArtifactFromObject(relation.object, {
+        entry: "__main__",
+        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 });
+      pkirExes.set(op, { status: "ok", exePath, wasmPath });
+    } catch (error) {
+      pkirExes.set(op, {
+        status: "failed",
+        error: error.stack || error.message || String(error)
+      });
+    }
+  }
+  for (const tc of testSuite) {
+    tc.pkir = pkirExes.get(tc.op);
+  }
+}
+
 function createWasmRunner(testSuite) {
   const wasmCases = testSuite.filter(tc => tc.wasm?.status === "ok");
   const servers = new Map();
@@ -300,6 +405,34 @@ function createWasmRunner(testSuite) {
   };
 }
 
+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;
+  }
+
+  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() {
   const lanes = [];
   if (runBaselines) {
@@ -307,8 +440,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 (runPKIR) lanes.push(pkirLaneName());
 
   console.log("==> Benchmark description");
   console.log("    source: @fraczak/k/Examples/arithmetics.k");
@@ -320,11 +455,18 @@ 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 (runPKIR) {
+    console.log(`    pkir warmup iterations: ${wasmWarmupIterations}`);
+  }
   console.log(`    iterations: ${iterations}`);
   console.log(`    benchmark lanes: ${lanes.join("; ")}`);
   console.log("    conformance: all outputs are compared to native expected values");
@@ -359,6 +501,22 @@ 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);
+    }
+    llvmPkirResult = await llvmPkirRunner.run(iterations);
+  } finally {
+    llvmPkirRunner.close();
+  }
+}
+
 // 3. Wasm lane
 let wasmResult = null;
 if (runWasm) {
@@ -403,6 +561,25 @@ if (runWasm) {
   }
 }
 
+// 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 (wasmWarmupIterations > 0) {
+        console.log(`==> Warming PKIR (${wasmWarmupIterations} iterations)...`);
+        await pkirRunner.run(wasmWarmupIterations);
+      }
+      console.log(`==> Running PKIR (${iterations} iterations)...`);
+      pkirResult = await pkirRunner.run(iterations);
+    } finally {
+      pkirRunner.close();
+    }
+  }
+}
+
 console.log("\n=================== INTEGER BENCHMARK RESULTS ===================");
 console.log(`Operation calls per iteration: ${testSuite.length}`);
 console.log(`Total requested operation calls: ${iterations * testSuite.length}`);
@@ -414,11 +591,19 @@ 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 (runPKIR) {
+  console.log(`${laneIndex++}. ${pkirLaneName().padEnd(29)} ${formatTiming(pkirResult)}`);
+}
 console.log("=================================================================\n");
 
 // Conformance Validation
@@ -446,6 +631,24 @@ 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.deepEqual(toPlainObject(actual), toPlainObject(tc.expected));
+        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.label}):`);
+        console.log(tc.llvmPKIR.error.split("\n").slice(0, 8).join("\n"));
+      }
+    }
+  }
+
   if (runWasm) {
     if (wasmPipe) {
       if (tc.wasm?.status !== "ok") {
@@ -484,6 +687,24 @@ for (const tc of testSuite) {
     }
   }
 
+  if (runPKIR) {
+    if (tc.pkir?.status !== "ok") {
+      tc.pkirConformance = "compile-failed";
+    } else {
+      try {
+        const outputWire = await runExecutable(tc.pkir.exePath, tc.inputWire);
+        const actual = decodeWire(outputWire).value;
+        assert.deepEqual(toPlainObject(actual), toPlainObject(tc.expected));
+        tc.pkirConformance = "ok";
+      } catch (error) {
+        tc.pkirConformance = "failed";
+        tc.pkir.error = error.stack || error.message || String(error);
+        console.log(`PKIR conformance failure for ${tc.op}(${tc.label}):`);
+        console.log(tc.pkir.error.split("\n").slice(0, 8).join("\n"));
+      }
+    }
+  }
+
 }
 
 const validationSummary = [];
@@ -492,14 +713,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 (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 (runPKIR && testSuite.some(tc => tc.pkirConformance !== "ok")) process.exitCode = 1;
 
 // =======================================================================
 // Squaring Scale & Memory Profiling Benchmark
@@ -596,13 +827,31 @@ for (const algo of squaringAlgos) {
       relHash: algo.rel.relHash,
       inputPattern: sInputPattern,
       cacheDir,
-      sourceLabel: algo.sourceLabel
+      sourceLabel: algo.sourceLabel,
+      usePKIR: false
     });
     if (sLlvmCompiled.status === "ok") {
       algo.llvmServer = new PersistentExecutable(sLlvmCompiled.exePath);
     }
   }
 
+  algo.llvmPkirServer = null;
+  if (runLLVMPKIR) {
+    const sLlvmPkirCompiled = tryCompileCase({
+      object: algo.rel.object,
+      relationName: algo.rel.relationName,
+      relHash: algo.rel.relHash,
+      inputPattern: sInputPattern,
+      cacheDir,
+      sourceLabel: algo.sourceLabel,
+      usePKIR: true
+    });
+    if (sLlvmPkirCompiled.status === "ok") {
+      algo.llvmPkirServer =
+        new PersistentExecutable(sLlvmPkirCompiled.exePath);
+    }
+  }
+
   algo.wasmServer = null;
   if (runWasm && !squaringLlvmOnly) {
     try {
@@ -618,6 +867,24 @@ for (const algo of squaringAlgos) {
     }
   }
 
+  algo.pkirServer = null;
+  if (runPKIR && !squaringLlvmOnly) {
+    try {
+      const sPkirPath = path.join(cacheDir, `perf_int_pkir_${algo.id}.wasm`);
+      const sPkirExe = path.join(cacheDir, `perf_int_pkir_${algo.id}.exe`);
+      const wasmBuf = await compileWasmArtifactFromObject(algo.rel.object, {
+        entry: "__main__",
+        usePKIR: true
+      });
+      fs.writeFileSync(sPkirPath, wasmBuf);
+      const runBin = fileURLToPath(import.meta.resolve("../backends/wasm/bin/k-wasm-run.mjs"));
+      fs.writeFileSync(sPkirExe, `#!/bin/sh\nexec node "${runBin}" "${sPkirPath}" "$@"\n`, { mode: 0o755 });
+      algo.pkirServer = new PersistentExecutable(sPkirExe);
+    } catch (e) {
+      console.log(`Failed to build PKIR executable for '${algo.id}':`, e.message);
+    }
+  }
+
   algo.results = {};
 }
 
@@ -628,11 +895,27 @@ if (runBaselines && !squaringLlvmOnly) {
   squaringLanes.push({ id: "kvm", name: "kVM (Env-Free)", type: "kvm", memLabel: "heap" });
 }
 if (runLLVM) {
-  squaringLanes.push({ id: "llvm", name: llvmLaneName(), type: "persistent", memLabel: "peak RSS" });
+  squaringLanes.push({
+    id: "llvm",
+    name: llvmLaneNameStr(),
+    type: "persistent",
+    memLabel: "peak RSS"
+  });
+}
+if (runLLVMPKIR) {
+  squaringLanes.push({
+    id: "llvm-pkir",
+    name: llvmPkirLaneNameStr(),
+    type: "persistent",
+    memLabel: "peak RSS"
+  });
 }
 if (runWasm && !squaringLlvmOnly) {
   squaringLanes.push({ id: "wasm", name: wasmLaneName(), type: "persistent", memLabel: "peak RSS" });
 }
+if (runPKIR && !squaringLlvmOnly) {
+  squaringLanes.push({ id: "pkir", name: pkirLaneName(), type: "persistent", memLabel: "peak RSS" });
+}
 
 for (const algo of squaringAlgos) {
   for (const lane of squaringLanes) {
@@ -642,10 +925,16 @@ for (const algo of squaringAlgos) {
 const stepMetadata = [];
 
 try {
-  // 1. Persistent child processes (Wasm, LLVM)
+  // 1. Persistent child processes (Wasm, PKIR, LLVM)
   for (const lane of squaringLanes.filter(l => l.type === "persistent")) {
     for (const algo of squaringAlgos) {
-      const server = lane.id === "llvm" ? algo.llvmServer : algo.wasmServer;
+      const server = lane.id === "llvm"
+        ? algo.llvmServer
+        : lane.id === "llvm-pkir"
+          ? algo.llvmPkirServer
+          : lane.id === "pkir"
+            ? algo.pkirServer
+            : algo.wasmServer;
       if (!server) continue;
       console.log(`==> Running ${lane.name} squaring [${algo.name}]...`);
       let curWire = sInitWire;
@@ -746,7 +1035,9 @@ try {
 } finally {
   for (const algo of squaringAlgos) {
     if (algo.wasmServer) algo.wasmServer.close();
+    if (algo.pkirServer) algo.pkirServer.close();
     if (algo.llvmServer) algo.llvmServer.close();
+    if (algo.llvmPkirServer) algo.llvmPkirServer.close();
   }
 }
 
@@ -765,11 +1056,13 @@ for (let step = 1; step <= squaringSteps; step++) {
 const sep130 = "=".repeat(130);
 const line130 = "-".repeat(130);
 
-if (squaringLanes.length === 1 && squaringLanes[0].id === "llvm") {
+if (squaringLanes.length === 1 && (squaringLanes[0].id === "llvm" || squaringLanes[0].id === "llvm-pkir")) {
+  const laneId = squaringLanes[0].id;
+  const laneName = squaringLanes[0].name;
   // LLVM Only side-by-side comparison table
   console.log(`\n${sep130}`);
-  console.log("=================== SQUARING SCALE & ALGORITHM BENCHMARK (LLVM) ===================");
-  console.log(`Algorithms: times vs karatsuba on ${squaringLanes[0].name}`);
+  console.log(`=================== SQUARING SCALE & ALGORITHM BENCHMARK (${laneName}) ===================`);
+  console.log(`Algorithms: times vs karatsuba on ${laneName}`);
   console.log(`Initial: ${squaringInputText} (${countBitsValue(sInitialVal)} bits)`);
   console.log(line130);
 
@@ -780,8 +1073,8 @@ if (squaringLanes.length === 1 && squaringLanes[0].id === "llvm") {
     "Step",
     "Bits",
     "Wire(B)",
-    "LLVM times (peak RSS)",
-    "LLVM karatsuba (peak RSS)",
+    `${laneName} times (peak RSS)`,
+    `${laneName} karatsuba (peak RSS)`,
     "Speedup (T/K)"
   ];
   console.log(hCols.map((h, i) => (i < 3 ? h.padStart(colW[i]) : h.padEnd(colW[i]))).join(" | "));
@@ -789,8 +1082,8 @@ if (squaringLanes.length === 1 && squaringLanes[0].id === "llvm") {
 
   for (let step = 1; step <= squaringSteps; step++) {
     const meta = stepMetadata[step - 1] || { bits: "?", wireLen: "?" };
-    const tRes = tAlgo.results.llvm[step - 1];
-    const kRes = kAlgo.results.llvm[step - 1];
+    const tRes = tAlgo.results[laneId][step - 1];
+    const kRes = kAlgo.results[laneId][step - 1];
 
     const formatCell = (res, w) => {
       if (!res) return "-".padEnd(w);

package/scripts/perf-multiplication.mjs

@@ -7,6 +7,7 @@
  * across available execution backends:
  *   - LLVM (native binary via Clang/LLVM)
  *   - WebAssembly (persistent runner via Wasm)
+ *   - PKIR (persistent runner via Wasm/PKIR)
  *   - kVM Interpreter (envelope-free bytecode engine)
  *   - Native JS (envelope-free convergence engine)
  *
@@ -66,7 +67,7 @@ function printHelp() {
 
 Multiplication Algorithm & Multi-Backend Performance Harness.
 Compares multiplication algorithms ('times' vs 'karatsuba') across
-available execution backends (LLVM, Wasm, kVM, JS).
+available execution backends (LLVM, Wasm, PKIR, kVM, JS).
 
 Options:
   --mode <squaring|sizes>
@@ -75,7 +76,8 @@ Options:
       (default: squaring)
   --backends <csv>
       Comma-separated list of execution backends to test:
-      llvm, wasm, kvm, js. (default: llvm,wasm,kvm,js)
+      llvm, llvm-pkir, wasm, pkir, kvm, js.
+      (default: llvm,llvm-pkir,wasm,pkir,kvm,js)
   --algos <csv>
       Comma-separated list of multiplication algorithms to test:
       times, karatsuba. (default: times,karatsuba)
@@ -114,7 +116,11 @@ if (hasFlag("-h") || hasFlag("--help")) {
 }
 
 const mode = getArg("--mode", "squaring"); // 'squaring' or 'sizes'
-const backendsArg = getArg("--backends", "llvm,wasm,kvm,js");
+const defaultBackends = "llvm,llvm-pkir,wasm,pkir,kvm,js";
+const backendsArg = getArg(
+  "--backends",
+  process.env.BACKENDS || defaultBackends
+);
 const selectedBackends = backendsArg
   .split(",").map(b => b.trim().toLowerCase()).filter(Boolean);
 const algosArg = getArg("--algos", "times,karatsuba");
@@ -239,7 +245,7 @@ const cacheDir = makeCacheDir("k-mult-perf-");
 // 2. Prepare Squaring Relations & Binaries
 // For squaring: relation name `s_${algo} = {()x, ()y} ${algo}; s_${algo}`
 const algoRelations = {};
-const algoServers = { llvm: {}, wasm: {} };
+const algoServers = { llvm: {}, "llvm-pkir": {}, wasm: {}, pkir: {} };
 
 let commonState = null;
 
@@ -285,6 +291,26 @@ for (const algo of selectedAlgos) {
     }
   }
 
+  // LLVM (via PKIR)
+  if (selectedBackends.includes("llvm-pkir")) {
+    const exePath = path.join(cacheDir, `perf_mult_llvm_pkir_${algo}`);
+    try {
+      compileObjectToExecutable(
+        algoRelations[algo].object, exePath, {
+          clangOpt: "-O2",
+          inputPattern: parseIntValue("0").pattern,
+          usePKIR: true
+        }
+      );
+      algoServers["llvm-pkir"][algo] =
+        new PersistentExecutable(exePath);
+    } catch (e) {
+      console.warn(
+        `[WARN] Failed to compile LLVM-PKIR for ${algo}: ${e.message}`
+      );
+    }
+  }
+
   // Wasm
   if (selectedBackends.includes("wasm")) {
     const wasmPath = path.join(cacheDir, `perf_mult_wasm_${algo}.wasm`);
@@ -309,6 +335,31 @@ for (const algo of selectedAlgos) {
       );
     }
   }
+
+  // PKIR
+  if (selectedBackends.includes("pkir")) {
+    const pkirPath = path.join(cacheDir, `perf_mult_pkir_${algo}.wasm`);
+    const exePath = path.join(cacheDir, `perf_mult_pkir_${algo}.exe`);
+    try {
+      const wasmBuf = await compileWasmArtifactFromObject(
+        algoRelations[algo].object, { entry: "__main__", usePKIR: true }
+      );
+      fs.writeFileSync(pkirPath, wasmBuf);
+      const runBin = fileURLToPath(
+        import.meta.resolve("../backends/wasm/bin/k-wasm-run.mjs")
+      );
+      fs.writeFileSync(
+        exePath,
+        `#!/bin/sh\nexec node "${runBin}" "${pkirPath}" "$@"\n`,
+        { mode: 0o755 }
+      );
+      algoServers.pkir[algo] = new PersistentExecutable(exePath);
+    } catch (e) {
+      console.warn(
+        `[WARN] Failed to compile PKIR for ${algo}: ${e.message}`
+      );
+    }
+  }
 }
 
 // 3. Squaring Mode Benchmark
@@ -327,8 +378,8 @@ if (mode === "squaring") {
   const stepBits = [];
 
   try {
-    // A. Run persistent backends (LLVM, Wasm)
-    const activeBackends = ["llvm", "wasm"]
+    // A. Run persistent backends (LLVM, LLVM-PKIR, Wasm, PKIR)
+    const activeBackends = ["llvm", "llvm-pkir", "wasm", "pkir"]
       .filter(b => selectedBackends.includes(b));
     for (const backend of activeBackends) {
       for (const algo of selectedAlgos) {
@@ -541,7 +592,7 @@ if (mode === "squaring") {
 
   } finally {
     // Teardown persistent servers
-    for (const backend of ["llvm", "wasm"]) {
+    for (const backend of ["llvm", "llvm-pkir", "wasm", "pkir"]) {
       for (const algo of selectedAlgos) {
         algoServers[backend]?.[algo]?.child?.kill();
       }