@fraczak/k 7.0.2 → 7.1.0

package/scripts/perf-poly.mjs

@@ -62,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, and Wasm.
+Examples/poly.k across Native JS, kVM interpreter, LLVM, Wasm, and PKIR.
 
 Options:
   --trace
@@ -71,16 +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' 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).
   LIST_LENGTH
@@ -116,11 +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 runLLVM = !wasmOnly;
-const runWasm = !llvmOnly;
-const runBaselines = !process.env.BACKENDS_ONLY && (process.env.LLVM_ONLY !== "1") && (process.env.WASM_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}`]));
@@ -143,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");
@@ -294,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 = [];
@@ -343,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();
@@ -371,6 +471,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) {
@@ -378,8 +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 (runPKIR) lanes.push(pkirLaneName());
 
   console.log("==> Benchmark description");
   console.log("    source: @fraczak/k/Examples/poly.k");
@@ -391,11 +521,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");
@@ -431,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) {
@@ -476,6 +630,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=================== POLYMORPHIC BENCHMARK RESULTS ===================");
 console.log(`Polymorphic operations per iteration: ${testSuite.length}`);
 console.log(`Total requested operation calls: ${iterations * testSuite.length}`);
@@ -487,11 +660,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
@@ -518,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") {
@@ -557,6 +755,23 @@ 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.ok(safeDeepEqual(actual, tc.expected), `PKIR output mismatch for ${tc.op}`);
+        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.pkir.error.split("\n")[0]);
+      }
+    }
+  }
+
 }
 
 const validationSummary = [];
@@ -565,14 +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 (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;
 
 if (runTrace && process.exitCode !== 1) {
   console.log("\n=================== RUNNING MACRO-PHASE TRACING ===================");
@@ -588,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) {
@@ -597,6 +834,15 @@ if (runTrace && process.exitCode !== 1) {
     }
   }
 
+  const pkirServers = new Map();
+  if (runPKIR) {
+    for (const tc of testSuite) {
+      if (tc.pkir?.status === "ok") {
+        pkirServers.set(tc.op, new PersistentExecutable(tc.pkir.exePath));
+      }
+    }
+  }
+
   const averageTrace = (samples) => {
     if (!samples || samples.length === 0) return null;
     const avg = {};
@@ -641,6 +887,18 @@ if (runTrace && process.exitCode !== 1) {
       opData.llvm = averageTrace(samples);
     }
 
+    // 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.llvmPkir = averageTrace(samples);
+    }
+
     // 3. Wasm
     if (runWasm) {
       if (wasmPipe) {
@@ -701,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;
@@ -747,7 +1017,9 @@ if (runTrace && process.exitCode !== 1) {
   }
 
   for (const s of llvmServers.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 "      -     ";
@@ -766,19 +1038,31 @@ 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                    | 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 llvmCol = formatUs(item.llvm?.[phase.key]);
-      const wasmCol = formatUs(item.wasm?.[phase.key]);
-      const kvmCol = formatUs(item.kvm?.[phase.key]);
-      console.log(`${pName} | ${llvmCol}  | ${wasmCol}  | ${kvmCol}`);
+      const cols = [pName, ...activeTraceLanes.map(l => formatUs(item[l.id]?.[phase.key]))];
+      console.log(cols.join(" | "));
     }
 
     const hasProfile = item.wasmProfile || item.kvmProfile;
@@ -820,11 +1104,11 @@ if (runTrace && process.exitCode !== 1) {
   }
 
   console.log(`\n=== AVERAGE ACROSS ALL ${phaseResults.length} OPERATIONS ===`);
-  console.log("Phase                    | 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) => {
@@ -832,10 +1116,8 @@ if (runTrace && process.exitCode !== 1) {
       if (vals.length === 0) return null;
       return vals.reduce((a, b) => a + b, 0) / vals.length;
     };
-    const llvmCol = formatUs(avg("llvm"));
-    const wasmCol = formatUs(avg("wasm"));
-    const kvmCol = formatUs(avg("kvm"));
-    console.log(`${pName} | ${llvmCol}  | ${wasmCol}  | ${kvmCol}`);
+    const cols = [pName, ...activeTraceLanes.map(l => formatUs(avg(l.id)))];
+    console.log(cols.join(" | "));
   }
 
   if (phaseResults.some(r => r.wasmProfile || r.kvmProfile)) {

package/scripts/run-tests.mjs

@@ -51,6 +51,9 @@ const tests = [
   ["tests/test-arithmetics.mjs", node, ["tests/test-arithmetics.mjs"]],
   ["tests/test-karatsuba.mjs", node, ["tests/test-karatsuba.mjs"]],
   ["tests/test-poly.mjs", node, ["tests/test-poly.mjs"]],
+  ["tests/test-polymorphic-tdd.mjs", node, ["tests/test-polymorphic-tdd.mjs"]],
+  ["tests/test-access-table.mjs", node, ["tests/test-access-table.mjs"]],
+  ["tests/test-pkir.mjs", node, ["tests/test-pkir.mjs"]],
   ["tests/test-ieee-arithmetic.mjs", node, ["tests/test-ieee-arithmetic.mjs"]],
   ["tests/integration.sh", path.join(root, "tests/integration.sh"), []]
 ];