@fraczak/k 7.0.1 → 7.1.0

package/scripts/perf-int.mjs

@@ -23,8 +23,6 @@ import {
   csvEnv,
   formatTiming,
   createLLVMRunner,
-  createARM64Runner,
-  arm64LaneName,
   llvmLaneName,
   makeCacheDir,
   parseNonNegativeIntEnv,
@@ -53,7 +51,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";
 
 function printHelp() {
@@ -61,37 +58,35 @@ function printHelp() {
 
 Big Integer Arithmetic Performance Benchmark Harness.
 Benchmarks plus, minus, times, and squaring scale on arithmetics.k
-across Native JS, kVM interpreter, LLVM, Wasm, and ARM64 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', '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).
+  SQUARING_LLVM_ONLY
+      Run squaring benchmark on LLVM only ('1' to enable).
   INPUTS
       Comma-separated integer strings to benchmark.
   ITERATIONS
       Measured iterations per benchmark (default: 3).
-  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
@@ -125,15 +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";
-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")
+  || 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}`]));
@@ -143,9 +180,6 @@ const inputTexts = csvEnv(
 );
 const iterations = parsePositiveIntEnv("ITERATIONS", 3);
 
-// ARM64 options
-const arm64WarmupIterations = parseNonNegativeIntEnv("ARM64_WARMUP_ITERATIONS", 1);
-const arm64OptLevel = process.env.ARM64_OPT || "-O2";
 if (!process.env.K_ARENA_CAPACITY_MB && !process.env.K_ARENA_MB) {
   process.env.K_ARENA_CAPACITY_MB = "4096";
 }
@@ -164,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();
@@ -175,7 +212,7 @@ for (const op of ops) {
 }
 
 function intValue(text) {
-  return valueForCode(parseIntValue(text), state.typeAliases.int, codes.find);
+  return parseIntValue(text);
 }
 
 console.log("==> Preparing relations");
@@ -227,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();
@@ -287,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();
@@ -315,37 +405,32 @@ function createWasmRunner(testSuite) {
   };
 }
 
-// Setup ARM64
-const arm64Exes = new Map();
-if (runARM64) {
-  console.log(`==> Compiling Linux ARM64 executables (${arm64OptLevel})...`);
-  for (const op of ops) {
-    const relation = relations[op];
-    try {
-      const exePath = path.join(cacheDir, `perf_int_arm64_${op}`);
-      compileARM64ArtifactFromObject(relation.object, {
-        entry: "__main__",
-        outputPath: exePath,
-        optLevel: arm64OptLevel
-      });
-      arm64Exes.set(op, { status: "ok", exePath });
-    } catch (error) {
-      arm64Exes.set(op, {
-        status: "failed",
-        error: error.stack || error.message || String(error)
-      });
+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;
   }
-  for (const tc of testSuite) {
-    tc.arm64 = arm64Exes.get(tc.op);
-  }
-  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() {
@@ -355,9 +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 (runARM64) lanes.push(arm64LaneName(arm64OptLevel));
+  if (runPKIR) lanes.push(pkirLaneName());
 
   console.log("==> Benchmark description");
   console.log("    source: @fraczak/k/Examples/arithmetics.k");
@@ -369,16 +455,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("; ")}`);
@@ -414,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) {
@@ -458,22 +561,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();
     }
   }
 }
@@ -489,14 +591,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");
 
@@ -525,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") {
@@ -563,23 +687,24 @@ 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.deepEqual(toPlainObject(actual), toPlainObject(tc.expected));
-        tc.arm64Conformance = "ok";
+        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.label}):`);
-        console.log(tc.arm64.error.split("\n").slice(0, 8).join("\n"));
+        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 = [];
@@ -588,24 +713,29 @@ 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;
 
-// =========================================================================
+// =======================================================================
 // Squaring Scale & Memory Profiling Benchmark
-// Expression: s = {()x,()y}times; 987654321 s s s s s s s s s s
-// =========================================================================
+// Expressions: s = {()x,()y}times; and s = {()x,()y}karatsuba;
+// =======================================================================
 
 function countBitsValue(val) {
   let count = 0;
@@ -644,189 +774,274 @@ const squaringInputText = process.env.SQUARING_INPUT || "987654321";
 const squaringStepTimeoutMs = parsePositiveIntEnv("SQUARING_STEP_TIMEOUT_MS", 60000);
 
 console.log("\n=================== SQUARING SCALE & MEMORY BENCHMARK ===================");
-console.log(`Expression: s = {()x,()y}times; ${squaringInputText} ${"s ".repeat(squaringSteps).trim()}`);
-console.log(`Evaluation: ${squaringSteps} successive squarings doubling bit length each step`);
+console.log(`Algorithms: times vs karatsuba (${squaringSteps} successive squarings doubling bit length)`);
 
-await evaluateInput("s = {()x,()y}times;", state);
-codes.load(state.codes);
-const sRel = prepareRelation(state, "s", {
-  source: `${arithmeticsLibrarySource}\ns = {()x,()y}times;\ns`,
-  sourceLabel: "@fraczak/k/Examples/arithmetics.k#s"
-});
+// Load and initialize Karatsuba multiplication relation
+const karatsubaPath = fileURLToPath(import.meta.resolve("@fraczak/k/Examples/karatsuba-mult.k"));
+const karatsubaSource = fs.readFileSync(karatsubaPath, "utf8");
+const karatsubaLibrarySource = karatsubaSource.replace(/\s*\(\)\s*$/, "\n");
+const stateKara = createState();
+await evaluateInput(`:load ${karatsubaPath}`, stateKara);
+codes.load(stateKara.codes);
 
 const sInitialVal = intValue(squaringInputText);
 const { inputWire: sInitWire, inputPattern: sInputPattern } = wireInput(sInitialVal);
 
+const squaringAlgos = [
+  {
+    id: "times",
+    name: "times",
+    title: "Long Multiplication (times)",
+    expr: "s = {()x,()y}times;",
+    librarySource: arithmeticsLibrarySource,
+    sourceLabel: "@fraczak/k/Examples/arithmetics.k#s",
+    state: state,
+    relName: "s"
+  },
+  {
+    id: "karatsuba",
+    name: "karatsuba",
+    title: "Karatsuba Multiplication (karatsuba)",
+    expr: "s = {()x,()y}karatsuba;",
+    librarySource: karatsubaLibrarySource,
+    sourceLabel: "@fraczak/k/Examples/karatsuba-mult.k#s",
+    state: stateKara,
+    relName: "s"
+  }
+];
+
 // Build executables for persistent servers
-let sLlvmServer = null;
-if (runLLVM) {
-  const sLlvmCompiled = tryCompileCase({
-    object: sRel.object,
-    relationName: sRel.relationName,
-    relHash: sRel.relHash,
-    inputPattern: sInputPattern,
-    cacheDir,
-    sourceLabel: "@fraczak/k/Examples/arithmetics.k#s"
+for (const algo of squaringAlgos) {
+  await evaluateInput(algo.expr, algo.state);
+  codes.load(algo.state.codes);
+  algo.rel = prepareRelation(algo.state, algo.relName, {
+    source: `${algo.librarySource}\n${algo.expr}\n${algo.relName}`,
+    sourceLabel: algo.sourceLabel
   });
-  if (sLlvmCompiled.status === "ok") {
-    sLlvmServer = new PersistentExecutable(sLlvmCompiled.exePath);
-  }
-}
 
-let sWasmServer = null;
-if (runWasm) {
-  try {
-    const sWasmPath = path.join(cacheDir, "perf_int_wasm_s.wasm");
-    const sWasmExe = path.join(cacheDir, "perf_int_wasm_s.exe");
-    const wasmBuf = await compileWasmArtifactFromObject(sRel.object, { entry: "__main__" });
-    fs.writeFileSync(sWasmPath, wasmBuf);
-    const runBin = fileURLToPath(import.meta.resolve("../backends/wasm/bin/k-wasm-run.mjs"));
-    fs.writeFileSync(sWasmExe, `#!/bin/sh\nexec node "${runBin}" "${sWasmPath}" "$@"\n`, { mode: 0o755 });
-    sWasmServer = new PersistentExecutable(sWasmExe);
-  } catch (e) {
-    console.log("Failed to build Wasm executable for 's':", e.message);
+  algo.llvmServer = null;
+  if (runLLVM) {
+    const sLlvmCompiled = tryCompileCase({
+      object: algo.rel.object,
+      relationName: algo.rel.relationName,
+      relHash: algo.rel.relHash,
+      inputPattern: sInputPattern,
+      cacheDir,
+      sourceLabel: algo.sourceLabel,
+      usePKIR: false
+    });
+    if (sLlvmCompiled.status === "ok") {
+      algo.llvmServer = new PersistentExecutable(sLlvmCompiled.exePath);
+    }
   }
-}
 
-let sArm64Server = null;
-if (runARM64) {
-  try {
-    const sArm64Exe = path.join(cacheDir, "perf_int_arm64_s");
-    compileARM64ArtifactFromObject(sRel.object, {
-      entry: "__main__",
-      outputPath: sArm64Exe,
-      optLevel: arm64OptLevel
+  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
     });
-    sArm64Server = new PersistentExecutable(sArm64Exe);
-  } catch (e) {
-    console.log("Failed to build ARM64 executable for 's':", e.message);
+    if (sLlvmPkirCompiled.status === "ok") {
+      algo.llvmPkirServer =
+        new PersistentExecutable(sLlvmPkirCompiled.exePath);
+    }
   }
+
+  algo.wasmServer = null;
+  if (runWasm && !squaringLlvmOnly) {
+    try {
+      const sWasmPath = path.join(cacheDir, `perf_int_wasm_${algo.id}.wasm`);
+      const sWasmExe = path.join(cacheDir, `perf_int_wasm_${algo.id}.exe`);
+      const wasmBuf = await compileWasmArtifactFromObject(algo.rel.object, { entry: "__main__" });
+      fs.writeFileSync(sWasmPath, wasmBuf);
+      const runBin = fileURLToPath(import.meta.resolve("../backends/wasm/bin/k-wasm-run.mjs"));
+      fs.writeFileSync(sWasmExe, `#!/bin/sh\nexec node "${runBin}" "${sWasmPath}" "$@"\n`, { mode: 0o755 });
+      algo.wasmServer = new PersistentExecutable(sWasmExe);
+    } catch (e) {
+      console.log(`Failed to build Wasm executable for '${algo.id}':`, e.message);
+    }
+  }
+
+  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 = {};
 }
 
 const squaringLanes = [];
-if (runBaselines) {
+if (runBaselines && !squaringLlvmOnly) {
   squaringLanes.push({ id: "jsAware", name: "Native JS (Aware)", type: "jsAware", memLabel: "heap" });
   squaringLanes.push({ id: "jsFree", name: "Native JS (Free)", type: "jsFree", memLabel: "heap" });
   squaringLanes.push({ id: "kvm", name: "kVM (Env-Free)", type: "kvm", memLabel: "heap" });
 }
-if (runLLVM && sLlvmServer) {
-  squaringLanes.push({ id: "llvm", name: llvmLaneName(), type: "persistent", server: sLlvmServer, memLabel: "peak RSS" });
+if (runLLVM) {
+  squaringLanes.push({
+    id: "llvm",
+    name: llvmLaneNameStr(),
+    type: "persistent",
+    memLabel: "peak RSS"
+  });
 }
-if (runWasm && sWasmServer) {
-  squaringLanes.push({ id: "wasm", name: wasmLaneName(), type: "persistent", server: sWasmServer, memLabel: "peak RSS" });
+if (runLLVMPKIR) {
+  squaringLanes.push({
+    id: "llvm-pkir",
+    name: llvmPkirLaneNameStr(),
+    type: "persistent",
+    memLabel: "peak RSS"
+  });
 }
-if (runARM64 && sArm64Server) {
-  squaringLanes.push({ id: "arm64", name: arm64LaneName(arm64OptLevel), type: "persistent", server: sArm64Server, 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" });
 }
 
-const squaringResults = {};
-for (const lane of squaringLanes) squaringResults[lane.id] = [];
+for (const algo of squaringAlgos) {
+  for (const lane of squaringLanes) {
+    algo.results[lane.id] = [];
+  }
+}
 const stepMetadata = [];
 
 try {
-  // 1. Persistent child processes (ARM64, Wasm, LLVM)
+  // 1. Persistent child processes (Wasm, PKIR, LLVM)
   for (const lane of squaringLanes.filter(l => l.type === "persistent")) {
-    console.log(`==> Running ${lane.name} squaring lane...`);
-    let curWire = sInitWire;
-    for (let step = 1; step <= squaringSteps; step++) {
-      try {
-        const t0 = performance.now();
-        curWire = await lane.server.request(curWire);
-        const t1 = performance.now();
-        const timeMs = t1 - t0;
-        const mem = getProcessMemory(lane.server.child.pid);
-        squaringResults[lane.id].push({ status: "ok", timeMs, memMb: mem.peakRssMb, wire: curWire });
-        if (!stepMetadata[step - 1]) {
-          stepMetadata[step - 1] = {
-            wireLen: curWire.length,
-            bits: null,
-            canonicalWire: curWire
-          };
+    for (const algo of squaringAlgos) {
+      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;
+      for (let step = 1; step <= squaringSteps; step++) {
+        try {
+          const t0 = performance.now();
+          curWire = await server.request(curWire);
+          const t1 = performance.now();
+          const timeMs = t1 - t0;
+          const mem = getProcessMemory(server.child.pid);
+          algo.results[lane.id].push({ status: "ok", timeMs, memMb: mem.peakRssMb, wire: curWire });
+          if (!stepMetadata[step - 1]) {
+            stepMetadata[step - 1] = {
+              wireLen: curWire.length,
+              bits: null,
+              canonicalWire: curWire
+            };
+          }
+          if (timeMs > squaringStepTimeoutMs) break;
+        } catch (e) {
+          algo.results[lane.id].push({ status: "failed", error: e.message?.split("\n")[0] || String(e) });
+          break;
         }
-        if (timeMs > squaringStepTimeoutMs) break;
-      } catch (e) {
-        squaringResults[lane.id].push({ status: "failed", error: e.message?.split("\n")[0] || String(e) });
-        break;
       }
     }
   }
 
   // 2. In-process baselines (JS Aware, JS Free, kVM)
-  if (runBaselines) {
-    // JS Aware
-    console.log("==> Running Native JS (Envelope-Aware) squaring lane...");
-    let curValAware = sInitialVal;
-    run.defs = state;
-    for (let step = 1; step <= squaringSteps; step++) {
-      try {
-        const t0 = performance.now();
-        curValAware = run(codes.find, sRel.relDef.def, curValAware, sRel.relDef.typePatternGraph);
-        const t1 = performance.now();
-        const timeMs = t1 - t0;
-        const mem = getNodeMemory();
-        squaringResults.jsAware.push({ status: "ok", timeMs, memMb: mem.heapMb, value: curValAware });
-        if (stepMetadata[step - 1] && stepMetadata[step - 1].bits == null) {
-          stepMetadata[step - 1].bits = countBitsValue(curValAware);
+  if (runBaselines && !squaringLlvmOnly) {
+    for (const algo of squaringAlgos) {
+      // JS Aware
+      console.log(`==> Running Native JS (Aware) squaring [${algo.name}]...`);
+      let curValAware = sInitialVal;
+      run.defs = algo.state;
+      for (let step = 1; step <= squaringSteps; step++) {
+        try {
+          const t0 = performance.now();
+          curValAware = run(codes.find, algo.rel.relDef.def, curValAware, algo.rel.relDef.typePatternGraph);
+          const t1 = performance.now();
+          const timeMs = t1 - t0;
+          const mem = getNodeMemory();
+          algo.results.jsAware.push({ status: "ok", timeMs, memMb: mem.heapMb, value: curValAware });
+          if (stepMetadata[step - 1] && stepMetadata[step - 1].bits == null) {
+            stepMetadata[step - 1].bits = countBitsValue(curValAware);
+          }
+          if (timeMs > squaringStepTimeoutMs) break;
+        } catch (e) {
+          algo.results.jsAware.push({ status: "failed", error: e.message?.split("\n")[0] || String(e) });
+          break;
         }
-        if (timeMs > squaringStepTimeoutMs) break;
-      } catch (e) {
-        squaringResults.jsAware.push({ status: "failed", error: e.message?.split("\n")[0] || String(e) });
-        break;
       }
-    }
 
-    // JS Free
-    console.log("==> Running Native JS (Envelope-Free) squaring lane...");
-    let curValFree = sInitialVal;
-    run_converged.defs = state;
-    for (let step = 1; step <= squaringSteps; step++) {
-      try {
-        const t0 = performance.now();
-        curValFree = run_converged(codes.find, sRel.relDef.def, curValFree, sRel.relDef.typePatternGraph);
-        const t1 = performance.now();
-        const timeMs = t1 - t0;
-        const mem = getNodeMemory();
-        squaringResults.jsFree.push({ status: "ok", timeMs, memMb: mem.heapMb, value: curValFree });
-        if (stepMetadata[step - 1] && stepMetadata[step - 1].bits == null) {
-          stepMetadata[step - 1].bits = countBitsValue(curValFree);
+      // JS Free
+      console.log(`==> Running Native JS (Free) squaring [${algo.name}]...`);
+      let curValFree = sInitialVal;
+      run_converged.defs = algo.state;
+      for (let step = 1; step <= squaringSteps; step++) {
+        try {
+          const t0 = performance.now();
+          curValFree = run_converged(codes.find, algo.rel.relDef.def, curValFree, algo.rel.relDef.typePatternGraph);
+          const t1 = performance.now();
+          const timeMs = t1 - t0;
+          const mem = getNodeMemory();
+          algo.results.jsFree.push({ status: "ok", timeMs, memMb: mem.heapMb, value: curValFree });
+          if (stepMetadata[step - 1] && stepMetadata[step - 1].bits == null) {
+            stepMetadata[step - 1].bits = countBitsValue(curValFree);
+          }
+          if (timeMs > squaringStepTimeoutMs) break;
+        } catch (e) {
+          algo.results.jsFree.push({ status: "failed", error: e.message?.split("\n")[0] || String(e) });
+          break;
         }
-        if (timeMs > squaringStepTimeoutMs) break;
-      } catch (e) {
-        squaringResults.jsFree.push({ status: "failed", error: e.message?.split("\n")[0] || String(e) });
-        break;
       }
-    }
 
-    // kVM
-    console.log("==> Running kVM Interpreter (Env-Free) squaring lane...");
-    let curValKvm = sInitialVal;
-    const kvmContext = { rels: state.rels, findCode: codes.find, options: { envelopeFree: true } };
-    for (let step = 1; step <= squaringSteps; step++) {
-      try {
-        const t0 = performance.now();
-        curValKvm = executeKVM(sRel.kvmFunc, curValKvm, kvmContext);
-        const t1 = performance.now();
-        const timeMs = t1 - t0;
-        const mem = getNodeMemory();
-        squaringResults.kvm.push({ status: "ok", timeMs, memMb: mem.heapMb, value: curValKvm });
-        if (stepMetadata[step - 1] && stepMetadata[step - 1].bits == null) {
-          stepMetadata[step - 1].bits = countBitsValue(curValKvm);
+      // kVM
+      console.log(`==> Running kVM Interpreter squaring [${algo.name}]...`);
+      let curValKvm = sInitialVal;
+      const kvmContext = { rels: algo.state.rels, findCode: codes.find, options: { envelopeFree: true } };
+      for (let step = 1; step <= squaringSteps; step++) {
+        try {
+          const t0 = performance.now();
+          curValKvm = executeKVM(algo.rel.kvmFunc, curValKvm, kvmContext);
+          const t1 = performance.now();
+          const timeMs = t1 - t0;
+          const mem = getNodeMemory();
+          algo.results.kvm.push({ status: "ok", timeMs, memMb: mem.heapMb, value: curValKvm });
+          if (stepMetadata[step - 1] && stepMetadata[step - 1].bits == null) {
+            stepMetadata[step - 1].bits = countBitsValue(curValKvm);
+          }
+          if (timeMs > squaringStepTimeoutMs) break;
+        } catch (e) {
+          algo.results.kvm.push({ status: "failed", error: e.message?.split("\n")[0] || String(e) });
+          break;
         }
-        if (timeMs > squaringStepTimeoutMs) break;
-      } catch (e) {
-        squaringResults.kvm.push({ status: "failed", error: e.message?.split("\n")[0] || String(e) });
-        break;
       }
     }
   }
-
 } finally {
-  if (sArm64Server) sArm64Server.close();
-  if (sWasmServer) sWasmServer.close();
-  if (sLlvmServer) sLlvmServer.close();
+  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();
+  }
 }
 
-// For any remaining steps without bit counts, decode canonicalWire safely to get bits:
+// For any remaining steps without bit counts, decode canonicalWire safely
 for (let step = 1; step <= squaringSteps; step++) {
   const meta = stepMetadata[step - 1];
   if (meta && meta.bits == null && meta.canonicalWire) {
@@ -838,87 +1053,160 @@ for (let step = 1; step <= squaringSteps; step++) {
 }
 
 // Display results table
-console.log("\n======================== SQUARING SCALING & MEMORY BENCHMARK ========================");
-console.log(`Expression: s = {()x,()y}times; ${squaringInputText} ${"s ".repeat(squaringSteps).trim()}`);
-console.log(`Initial: ${squaringInputText} (${countBitsValue(sInitialVal)} bits)`);
-console.log("----------------------------------------------------------------------------------------------------------------------------------");
-const headerCols = ["Step", "Bits", "Wire(B)", ...squaringLanes.map(l => `${l.name} (${l.memLabel})`)];
-const colWidths = [4, 6, 7, ...squaringLanes.map(l => Math.max(22, l.name.length + l.memLabel.length + 5))];
-console.log(headerCols.map((h, i) => i < 3 ? h.padStart(colWidths[i]) : h.padEnd(colWidths[i])).join(" | "));
-console.log(colWidths.map(w => "-".repeat(w)).join("-|-"));
-
-for (let step = 1; step <= squaringSteps; step++) {
-  const meta = stepMetadata[step - 1] || { bits: "?", wireLen: "?" };
-  const cols = [
-    String(step).padStart(colWidths[0]),
-    String(meta.bits ?? "?").padStart(colWidths[1]),
-    String(meta.wireLen ?? "?").padStart(colWidths[2])
+const sep130 = "=".repeat(130);
+const line130 = "-".repeat(130);
+
+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 (${laneName}) ===================`);
+  console.log(`Algorithms: times vs karatsuba on ${laneName}`);
+  console.log(`Initial: ${squaringInputText} (${countBitsValue(sInitialVal)} bits)`);
+  console.log(line130);
+
+  const tAlgo = squaringAlgos[0];
+  const kAlgo = squaringAlgos[1];
+  const colW = [4, 6, 7, 34, 34, 15];
+  const hCols = [
+    "Step",
+    "Bits",
+    "Wire(B)",
+    `${laneName} times (peak RSS)`,
+    `${laneName} karatsuba (peak RSS)`,
+    "Speedup (T/K)"
   ];
-  for (let li = 0; li < squaringLanes.length; li++) {
-    const lane = squaringLanes[li];
-    const res = squaringResults[lane.id][step - 1];
-    const w = colWidths[3 + li];
-    if (!res) {
-      cols.push("-".padEnd(w));
-    } else if (res.status === "ok") {
-      const t = res.timeMs < 10 ? `${res.timeMs.toFixed(2)}ms` : `${res.timeMs.toFixed(1)}ms`;
-      const m = res.memMb != null ? `${res.memMb}MB` : "";
-      cols.push(`${t} / ${m}`.padEnd(w));
-    } else {
-      let errText = res.error;
-      if (errText.includes("Maximum call stack")) {
-        errText = "Stack overflow (V8)";
-      } else if (errText.includes("status null") || errText.includes("failed with status")) {
-        errText = "Arena limit reached";
+  console.log(hCols.map((h, i) => (i < 3 ? h.padStart(colW[i]) : h.padEnd(colW[i]))).join(" | "));
+  console.log(colW.map(w => "-".repeat(w)).join("-|-"));
+
+  for (let step = 1; step <= squaringSteps; step++) {
+    const meta = stepMetadata[step - 1] || { bits: "?", wireLen: "?" };
+    const tRes = tAlgo.results[laneId][step - 1];
+    const kRes = kAlgo.results[laneId][step - 1];
+
+    const formatCell = (res, w) => {
+      if (!res) return "-".padEnd(w);
+      if (res.status === "ok") {
+        const t = res.timeMs < 10 ? `${res.timeMs.toFixed(2)}ms` : `${res.timeMs.toFixed(1)}ms`;
+        const m = res.memMb != null ? `${res.memMb}MB` : "";
+        return `${t} / ${m}`.padEnd(w);
+      }
+      let errText = res.error || "error";
+      if (errText.includes("Maximum call stack")) errText = "Stack overflow (V8)";
+      else if (errText.includes("status null") || errText.includes("failed with status")) errText = "Arena limit reached";
+      return errText.slice(0, w - 1).padEnd(w);
+    };
+
+    let speedupStr = "-";
+    if (tRes?.status === "ok" && kRes?.status === "ok" && kRes.timeMs > 0) {
+      speedupStr = `${(tRes.timeMs / kRes.timeMs).toFixed(2)}x`;
+    }
+
+    const row = [
+      String(step).padStart(colW[0]),
+      String(meta.bits ?? "?").padStart(colW[1]),
+      String(meta.wireLen ?? "?").padStart(colW[2]),
+      formatCell(tRes, colW[3]),
+      formatCell(kRes, colW[4]),
+      speedupStr.padEnd(colW[5])
+    ];
+    console.log(row.join(" | "));
+  }
+  console.log(sep130);
+} else {
+  // Print each algorithm table
+  for (const algo of squaringAlgos) {
+    console.log(`\n${sep130}`);
+    console.log(`=================== SQUARING SCALE: ${algo.title.toUpperCase()} ===================`);
+    console.log(`Expression: ${algo.expr} ${squaringInputText} ${"s ".repeat(squaringSteps).trim()}`);
+    console.log(`Initial: ${squaringInputText} (${countBitsValue(sInitialVal)} bits)`);
+    console.log(line130);
+
+    const headerCols = ["Step", "Bits", "Wire(B)", ...squaringLanes.map(l => `${l.name} (${l.memLabel})`)];
+    const colWidths = [4, 6, 7, ...squaringLanes.map(l => Math.max(22, l.name.length + l.memLabel.length + 5))];
+    console.log(headerCols.map((h, i) => (i < 3 ? h.padStart(colWidths[i]) : h.padEnd(colWidths[i]))).join(" | "));
+    console.log(colWidths.map(w => "-".repeat(w)).join("-|-"));
+
+    for (let step = 1; step <= squaringSteps; step++) {
+      const meta = stepMetadata[step - 1] || { bits: "?", wireLen: "?" };
+      const cols = [
+        String(step).padStart(colWidths[0]),
+        String(meta.bits ?? "?").padStart(colWidths[1]),
+        String(meta.wireLen ?? "?").padStart(colWidths[2])
+      ];
+      for (let li = 0; li < squaringLanes.length; li++) {
+        const lane = squaringLanes[li];
+        const res = algo.results[lane.id][step - 1];
+        const w = colWidths[3 + li];
+        if (!res) {
+          cols.push("-".padEnd(w));
+        } else if (res.status === "ok") {
+          const t = res.timeMs < 10 ? `${res.timeMs.toFixed(2)}ms` : `${res.timeMs.toFixed(1)}ms`;
+          const m = res.memMb != null ? `${res.memMb}MB` : "";
+          cols.push(`${t} / ${m}`.padEnd(w));
+        } else {
+          let errText = res.error;
+          if (errText.includes("Maximum call stack")) {
+            errText = "Stack overflow (V8)";
+          } else if (errText.includes("status null") || errText.includes("failed with status")) {
+            errText = "Arena limit reached";
+          }
+          cols.push(errText.slice(0, w - 1).padEnd(w));
+        }
       }
-      cols.push(errText.slice(0, w - 1).padEnd(w));
+      console.log(cols.join(" | "));
     }
+    console.log(sep130);
   }
-  console.log(cols.join(" | "));
 }
-console.log("==================================================================================================================================");
 
-// Conformance check across all computed steps
+// Conformance check across all computed steps and algorithms
 let squaringConformanceOk = true;
 for (let step = 1; step <= squaringSteps; step++) {
   const meta = stepMetadata[step - 1];
   if (!meta?.canonicalWire) continue;
-  for (const lane of squaringLanes) {
-    const res = squaringResults[lane.id][step - 1];
-    if (res?.status === "ok") {
-      if (res.wire) {
-        if (Buffer.compare(res.wire, meta.canonicalWire) !== 0) {
-          squaringConformanceOk = false;
-          console.log(`Squaring conformance mismatch on step ${step} (${lane.name})`);
-        }
-      } else if (res.value) {
-        try {
-          const wireVal = decodeWire(meta.canonicalWire).value;
-          if (!safeDeepEqual(res.value, wireVal)) {
+  for (const algo of squaringAlgos) {
+    for (const lane of squaringLanes) {
+      const res = algo.results[lane.id][step - 1];
+      if (res?.status === "ok") {
+        if (res.wire) {
+          if (Buffer.compare(res.wire, meta.canonicalWire) !== 0) {
             squaringConformanceOk = false;
-            console.log(`Squaring conformance mismatch on step ${step} (${lane.name})`);
+            console.log(`Squaring conformance mismatch on step ${step} (${algo.name} / ${lane.name})`);
           }
-        } catch {}
+        } else if (res.value) {
+          try {
+            const wireVal = decodeWire(meta.canonicalWire).value;
+            if (!safeDeepEqual(res.value, wireVal)) {
+              squaringConformanceOk = false;
+              console.log(`Squaring conformance mismatch on step ${step} (${algo.name} / ${lane.name})`);
+            }
+          } catch {}
+        }
       }
     }
   }
 }
 
 console.log("\nSquaring Performance & Scaling Summary:");
-for (const lane of squaringLanes) {
-  const okSteps = squaringResults[lane.id].filter(r => r.status === "ok");
-  const maxStep = okSteps.length;
-  const lastOk = okSteps[okSteps.length - 1];
-  const peakMem = okSteps.reduce((max, r) => Math.max(max, r.memMb || 0), 0);
-  const failureReason = squaringResults[lane.id][maxStep]?.error;
-  let statusDetail = "";
-  if (failureReason) {
-    if (failureReason.includes("Maximum call stack")) statusDetail = " (V8 call stack overflow)";
-    else if (failureReason.includes("status null") || failureReason.includes("failed with status")) statusDetail = " (arena capacity limit reached)";
-    else statusDetail = ` (${failureReason.slice(0, 30)})`;
-  }
-  const timeStr = lastOk ? ` (step ${maxStep} in ${lastOk.timeMs < 10 ? lastOk.timeMs.toFixed(2) : lastOk.timeMs.toFixed(1)}ms)` : "";
-  console.log(`  - ${lane.name.padEnd(32)}: reached Step ${String(maxStep).padStart(2)}/${squaringSteps}${timeStr}, peak ${lane.memLabel}: ${peakMem}MB${statusDetail}`);
+for (const algo of squaringAlgos) {
+  console.log(`  Algorithm: ${algo.title}`);
+  for (const lane of squaringLanes) {
+    const okSteps = algo.results[lane.id].filter(r => r.status === "ok");
+    const maxStep = okSteps.length;
+    const lastOk = okSteps[okSteps.length - 1];
+    const peakMem = okSteps.reduce((max, r) => Math.max(max, r.memMb || 0), 0);
+    const failureReason = algo.results[lane.id][maxStep]?.error;
+    let statusDetail = "";
+    if (failureReason) {
+      if (failureReason.includes("Maximum call stack")) statusDetail = " (V8 call stack overflow)";
+      else if (failureReason.includes("status null") || failureReason.includes("failed with status")) statusDetail = " (arena capacity limit reached)";
+      else statusDetail = ` (${failureReason.slice(0, 30)})`;
+    }
+    const timeStr = lastOk ? ` (step ${maxStep} in ${lastOk.timeMs < 10 ? lastOk.timeMs.toFixed(2) : lastOk.timeMs.toFixed(1)}ms)` : "";
+    console.log(`    - ${lane.name.padEnd(32)}: reached Step ${String(maxStep).padStart(2)}/${squaringSteps}${timeStr}, peak ${lane.memLabel}: ${peakMem}MB${statusDetail}`);
+  }
 }
 
 if (squaringConformanceOk) {