@fraczak/k 6.3.2 → 6.4.0

package/backends/wasm/tests/integration.sh

@@ -0,0 +1,182 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+K_ROOT=${K_ROOT:-../..}
+TMP_DIR=`mktemp -d`
+trap 'rm -rf "$TMP_DIR"' EXIT
+
+echo "Running './tests/integration.sh' ..."
+
+compare_json_envelope() {
+  local name=$1
+  local input=$2
+  local program=$3
+  printf '%s\n' "$input" |
+    node "$K_ROOT/codecs/json.mjs" --parse |
+    node "$K_ROOT/k.mjs" "$program" > "$TMP_DIR/native.kv"
+  printf '%s\n' "$input" |
+    node "$K_ROOT/codecs/json.mjs" --parse |
+    node "$K_ROOT/kvm.mjs" "$program" > "$TMP_DIR/kvm.kv"
+  printf '%s\n' "$input" |
+    node "$K_ROOT/codecs/json.mjs" --parse |
+    node ./bin/k-wasm.mjs "$program" > "$TMP_DIR/wasm.kv"
+
+  if ! cmp -s "$TMP_DIR/native.kv" "$TMP_DIR/kvm.kv" ||
+     ! cmp -s "$TMP_DIR/native.kv" "$TMP_DIR/wasm.kv"; then
+    echo "output envelope mismatch for $name" >&2
+    exit 1
+  fi
+}
+
+node "$K_ROOT/codecs/unit.mjs" --parse |
+  node ./bin/k-wasm.mjs '|ok' |
+  node "$K_ROOT/codecs/k-print.mjs" |
+  grep -qx '"ok"'
+
+printf '{"a": {}, "b": {}}\n' |
+  node "$K_ROOT/codecs/k-parse.mjs" |
+  node ./bin/k-wasm.mjs '|ok' |
+  node "$K_ROOT/codecs/k-print.mjs" |
+  grep -qx '{"ok":{"a":{},"b":{}}}'
+
+printf '{"a":123,"b":true,"c":[1,2,"alsk"]}\n' |
+  node "$K_ROOT/codecs/json.mjs" --parse |
+  node ./bin/k-wasm.mjs '.c' |
+  node "$K_ROOT/codecs/json.mjs" --print |
+  grep -qx '\[1,2,"alsk"\]'
+
+compare_json_envelope "nested array string projection" \
+  '{"a":[1,2,"kupa"], "b": 123}' \
+  '.a.2'
+compare_json_envelope "projected JSON number" \
+  '{"a":[1,2,"kupa"], "b": 123}' \
+  '.b'
+compare_json_envelope "closed product filter" \
+  '{"a":[1,2,"kupa"], "b": 123}' \
+  '?{X a, Y b}'
+printf '{"a":[1,2,"kupa"], "b": 123}\n' |
+  node "$K_ROOT/codecs/json.mjs" --parse |
+  node ./bin/k-wasm.mjs '{ .a.2 word, .b number }' |
+  node "$K_ROOT/codecs/json.mjs" --print |
+  grep -qx '{"number":123,"word":"kupa"}'
+
+printf 'a\n' |
+  node "$K_ROOT/codecs/k-parse.mjs" --input-type '?< {} a, X b, ...>' |
+  node ./bin/k-wasm.mjs '{() i, /a o}' |
+  node "$K_ROOT/codecs/show.mjs" > "$TMP_DIR/polymorphic-relation.wire" 2> "$TMP_DIR/polymorphic-relation.show"
+grep -Fqx '{{}|a i, {} o} ?{<{}=X0 a, (...) b, ...> i, X0 o}' "$TMP_DIR/polymorphic-relation.show"
+node "$K_ROOT/codecs/k-print.mjs" "$TMP_DIR/polymorphic-relation.wire" |
+  grep -qx '{"i":"a","o":{}}'
+
+node ./bin/k-wasm-compile.mjs '.c' "$TMP_DIR/dot-c.wasm"
+printf '{"a":123,"b":true,"c":[1,2,"alsk"]}\n' |
+  node "$K_ROOT/codecs/json.mjs" --parse |
+  node ./bin/k-wasm-run.mjs "$TMP_DIR/dot-c.wasm" |
+  node "$K_ROOT/codecs/json.mjs" --print |
+  grep -qx '\[1,2,"alsk"\]'
+
+node "$K_ROOT/objects/compile.mjs" '.c' "$TMP_DIR/dot-c.ko"
+printf '{"a":123,"b":true,"c":[1,2,"alsk"]}\n' |
+  node "$K_ROOT/codecs/json.mjs" --parse |
+  node ./bin/k-wasm.mjs "$TMP_DIR/dot-c.ko" |
+  node "$K_ROOT/codecs/json.mjs" --print |
+  grep -qx '\[1,2,"alsk"\]'
+
+printf '{"a":123,"b":true,"c":[1,2,"alsk"]}\n' |
+  node "$K_ROOT/codecs/json.mjs" --parse |
+  node ./bin/k-wasm.mjs '?{X c, ...}' |
+  node "$K_ROOT/codecs/json.mjs" --print |
+  grep -qx '{"a":123,"b":true,"c":\[1,2,"alsk"\]}'
+
+printf '{"a":123,"b":true}\n' |
+  node "$K_ROOT/codecs/json.mjs" --parse |
+  node ./bin/k-wasm.mjs '?{...}' |
+  node "$K_ROOT/codecs/json.mjs" --print |
+  grep -qx '{"a":123,"b":true}'
+
+printf '"bar"\n' |
+  node "$K_ROOT/codecs/json.mjs" --parse |
+  node ./bin/k-wasm.mjs '?<...>' |
+  node "$K_ROOT/codecs/json.mjs" --print |
+  grep -qx '"bar"'
+
+printf '{"c":[1,2,"alsk"]}\n' |
+  node "$K_ROOT/codecs/json.mjs" --parse |
+  node ./bin/k-wasm.mjs '?{X c}' |
+  node "$K_ROOT/codecs/json.mjs" --print |
+  grep -qx '{"c":\[1,2,"alsk"\]}'
+
+if printf '{"a":123,"c":1}\n' |
+  node "$K_ROOT/codecs/json.mjs" --parse |
+  node ./bin/k-wasm.mjs '?{X c}' >/dev/null 2>&1; then
+  echo "closed product pattern unexpectedly accepted extra fields" >&2
+  exit 1
+fi
+
+if printf '"bar"\n' |
+  node "$K_ROOT/codecs/json.mjs" --parse |
+  node ./bin/k-wasm.mjs '?<X cons>' >/dev/null 2>&1; then
+  echo "closed union pattern unexpectedly accepted a wider value envelope" >&2
+  exit 1
+fi
+
+node "$K_ROOT/codecs/unit.mjs" --parse |
+  node "$K_ROOT/k.mjs" '|cons' |
+  node ./bin/k-wasm.mjs '?<{} cons>' |
+  node "$K_ROOT/codecs/k-print.mjs" |
+  grep -qx '"cons"'
+
+if node ./bin/k-wasm-compile.mjs 'f = .x f; f' "$TMP_DIR/non-converged.wasm" >/dev/null 2>&1; then
+  echo "non-converged type derivation unexpectedly compiled" >&2
+  exit 1
+fi
+
+printf '|ok\n' > "$TMP_DIR/ok.k"
+if node ./bin/k-wasm-compile.mjs -k "$TMP_DIR/ok.k" "$TMP_DIR/old-k.wasm" >/dev/null 2>&1; then
+  echo "-k source-file compatibility option unexpectedly worked" >&2
+  exit 1
+fi
+
+node ./bin/k-wasm-compile.mjs "$TMP_DIR/ok.k" "$TMP_DIR/ok.wasm"
+node "$K_ROOT/codecs/unit.mjs" --parse > "$TMP_DIR/unit.kv"
+node ./bin/k-wasm-run.mjs "$TMP_DIR/ok.wasm" "$TMP_DIR/unit.kv" |
+  node "$K_ROOT/codecs/k-print.mjs" |
+  grep -qx '"ok"'
+
+node ./bin/k-wasm.mjs "$TMP_DIR/ok.k" "$TMP_DIR/unit.kv" |
+  node "$K_ROOT/codecs/k-print.mjs" |
+  grep -qx '"ok"'
+
+node "$K_ROOT/objects/compile.mjs" "$TMP_DIR/ok.k" "$TMP_DIR/ok.ko"
+node ./bin/k-wasm-compile.mjs "$TMP_DIR/ok.ko" "$TMP_DIR/ok-ko.wasm"
+node ./bin/k-wasm-run.mjs "$TMP_DIR/ok-ko.wasm" "$TMP_DIR/unit.kv" |
+  node "$K_ROOT/codecs/k-print.mjs" |
+  grep -qx '"ok"'
+
+node "$K_ROOT/objects/compile.mjs" "$TMP_DIR/ok.k" "$TMP_DIR/ok.kvm"
+node ./bin/k-wasm-compile.mjs "$TMP_DIR/ok.kvm" "$TMP_DIR/ok-kvm.wasm"
+node ./bin/k-wasm-run.mjs "$TMP_DIR/ok-kvm.wasm" "$TMP_DIR/unit.kv" |
+  node "$K_ROOT/codecs/k-print.mjs" |
+  grep -qx '"ok"'
+
+node "$K_ROOT/objects/compile.mjs" --format kvm 'make_prod = { .x x, .y y }; proj_y = make_prod .y; proj_y' > "$TMP_DIR/project.kvm"
+node ./bin/k-wasm-compile.mjs "$TMP_DIR/project.kvm" "$TMP_DIR/project.wasm"
+printf '{"x":{"a":{}},"y":{"b":{}}}\n' |
+  node "$K_ROOT/codecs/k-parse.mjs" |
+  node ./bin/k-wasm-run.mjs "$TMP_DIR/project.wasm" |
+  node "$K_ROOT/codecs/k-print.mjs" |
+  grep -qx '"b"'
+
+node "$K_ROOT/objects/compile.mjs" "$K_ROOT/Examples/ieee.k" "$TMP_DIR/ieee.klib"
+if node ./bin/k-wasm-compile.mjs --lib "$TMP_DIR/ieee.klib" --lib "$TMP_DIR/ieee.klib" --export mul:times "{()x,()y} times .result" "$TMP_DIR/repeated-lib.wasm" >/dev/null 2>&1; then
+  echo "--lib unexpectedly accepted more than once" >&2
+  exit 1
+fi
+node ./bin/k-wasm-compile.mjs --lib "$TMP_DIR/ieee.klib" --export mul:times "{()x,()y} times .result" "$TMP_DIR/ieee-mul.wasm"
+echo 0.12 |
+  node "$K_ROOT/codecs/ieee.mjs" --parse |
+  node ./bin/k-wasm-run.mjs "$TMP_DIR/ieee-mul.wasm" |
+  node "$K_ROOT/codecs/ieee.mjs" --print |
+  grep -qx '0.0144'
+
+echo "Integration tests passed."

package/backends/wasm/tests/perf-support.mjs

@@ -0,0 +1,336 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  isProduct,
+  isVariant,
+  lowerToKVM,
+  Value
+} from "@fraczak/k/backend-api.mjs";
+import { lowerToWasm, getTagId, getTagFromId } from "../src/kvm2wasm.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export function loadRuntimeWat() {
+  return fs.readFileSync(path.join(__dirname, "../runtime.wat"), "utf8");
+}
+
+export const cleanName = (h) => "rel_" + h.replace(/[^a-zA-Z0-9_]/g, "_");
+
+function scanCalls(insts, compiled, queue) {
+  for (const inst of insts) {
+    if (inst.op === "call" && !compiled.has(inst.func) && !queue.includes(inst.func)) {
+      queue.push(inst.func);
+    }
+    if (inst.branches) {
+      for (const branch of inst.branches) {
+        scanCalls(branch.body, compiled, queue);
+      }
+    }
+  }
+}
+
+function cleanInsts(insts) {
+  for (const inst of insts) {
+    if (inst.op === "call") {
+      inst.func = cleanName(inst.func);
+    }
+    if (inst.branches) {
+      for (const branch of inst.branches) {
+        cleanInsts(branch.body);
+      }
+    }
+  }
+}
+
+export function findAliasForHash(hash, state) {
+  if (!state?.relAliases) return hash;
+  let best = null;
+  for (const [alias, h] of Object.entries(state.relAliases)) {
+    if (h === hash) {
+      if (!best) {
+        best = alias;
+      } else {
+        const bestIsBench = best.startsWith("bench_");
+        const currentIsBench = alias.startsWith("bench_");
+        if (bestIsBench && !currentIsBench) {
+          best = alias;
+        } else if (bestIsBench === currentIsBench && alias.length < best.length) {
+          best = alias;
+        }
+      }
+    }
+  }
+  return best || hash;
+}
+
+export function compileMultiModule(mainHashes, state, options = {}) {
+  const compiled = new Set();
+  const queue = [...mainHashes];
+  const wats = [];
+  const profileGlobals = [];
+  const profileFunctions = [];
+
+  while (queue.length > 0) {
+    const hash = queue.shift();
+    if (compiled.has(hash)) continue;
+    compiled.add(hash);
+
+    const relDef = state.rels[hash];
+    if (!relDef) {
+      throw new Error(`Relation hash ${hash} not found`);
+    }
+
+    const kvmFunc = lowerToKVM(relDef, hash);
+    kvmFunc.typePatternGraph = relDef.typePatternGraph;
+    scanCalls(kvmFunc.body, compiled, queue);
+
+    kvmFunc.name = cleanName(hash);
+    cleanInsts(kvmFunc.body);
+    if (options.profile) {
+      const alias = findAliasForHash(hash, state);
+      profileFunctions.push({ name: alias, symbolName: kvmFunc.name, hash });
+      profileGlobals.push(`  (global $prof_${kvmFunc.name} (export "prof_${kvmFunc.name}") (mut i64) (i64.const 0))`);
+    }
+    wats.push(lowerToWasm(kvmFunc, kvmFunc.name, options));
+  }
+
+  const globalsText = profileGlobals.length > 0 ? profileGlobals.join("\n") + "\n\n" : "";
+  return {
+    wat: globalsText + wats.join("\n\n"),
+    profileFunctions
+  };
+}
+
+export function compileWat(watText, wabtInstance) {
+  const watModule = wabtInstance.parseWat("perf.wat", watText, {
+    mutable_globals: true,
+    sat_float_to_int: true,
+    sign_extension: true,
+    multi_value: true,
+    bulk_memory: true,
+    reference_types: true
+  });
+  watModule.resolveNames();
+  watModule.validate();
+  return watModule.toBinary({
+    log: false,
+    canonicalize_lebs: true,
+    relocatable: false,
+    write_debug_names: true
+  }).buffer;
+}
+
+export async function instantiateWasmModule(mainHashes, state, wabtInstance, options = {}) {
+  const runtimeWat = loadRuntimeWat();
+  const compiled = compileMultiModule(mainHashes, state, options);
+  const wats = typeof compiled === "string" ? compiled : compiled.wat;
+  const profileFunctions = typeof compiled === "string" ? [] : (compiled.profileFunctions || []);
+  const fullWat = runtimeWat.trim().slice(0, -1) + "\n" + wats + "\n)";
+  const binary = compileWat(fullWat, wabtInstance);
+  const module = await WebAssembly.compile(binary);
+  const instance = await WebAssembly.instantiate(module);
+  return { instance, exports: instance.exports, module, profileFunctions };
+}
+
+export function readWasmProfile(wasmExports, profileFunctions, reset = true) {
+  if (!wasmExports || !profileFunctions || profileFunctions.length === 0) return null;
+  const result = {};
+  for (const f of profileFunctions) {
+    const g = wasmExports[`prof_${f.symbolName}`];
+    if (g) {
+      const val = Number(g.value);
+      if (val > 0) {
+        result[f.name] = val;
+      }
+      if (reset) {
+        g.value = 0n;
+      }
+    }
+  }
+  return result;
+}
+
+export function resetWasmProfile(wasmExports, profileFunctions) {
+  if (!wasmExports || !profileFunctions) return;
+  for (const f of profileFunctions) {
+    const g = wasmExports[`prof_${f.symbolName}`];
+    if (g) g.value = 0n;
+  }
+}
+
+export function readArenaValue(exports, rootPtr, pattern, rootPatternNodeId, patternPropertyList) {
+  let rootValue;
+  const stack = [{
+    ptr: rootPtr,
+    patternNodeId: rootPatternNodeId,
+    assign: (v) => { rootValue = v; }
+  }];
+
+  while (stack.length > 0) {
+    const frame = stack.pop();
+
+    if (frame.finishProduct) {
+      const { productObj, assign } = frame;
+      assign(Value.product(productObj, patternPropertyList));
+      continue;
+    }
+
+    if (frame.finishVariant) {
+      const { tag, payloadBox, assign } = frame;
+      assign(Value.variant(tag, payloadBox[0], patternPropertyList));
+      continue;
+    }
+
+    const { ptr, patternNodeId, assign } = frame;
+    const patternNode = pattern.nodes[patternNodeId];
+    const view = new DataView(exports.memory.buffer);
+
+    if (patternNode.kind === 1 || patternNode.kind === 3) {
+      const size = view.getUint32(ptr, true);
+      const N = view.getUint32(ptr + 4, true);
+      const productObj = {};
+
+      stack.push({
+        finishProduct: true,
+        productObj,
+        assign
+      });
+
+      for (let i = N - 1; i >= 0; i--) {
+        const edge = patternNode.edges[i];
+        const offsetVal = view.getUint32(ptr + 8 + 4 * i, true);
+        const childPtr = view.getUint32(ptr + offsetVal, true);
+        const label = edge.label;
+        stack.push({
+          ptr: childPtr,
+          patternNodeId: edge.target,
+          assign: (v) => { productObj[label] = v; }
+        });
+      }
+    } else if (patternNode.kind === 2 || patternNode.kind === 4) {
+      const size = view.getUint32(ptr, true);
+      const tagId = view.getUint32(ptr + 4, true);
+      const payloadPtr = view.getUint32(ptr + 8, true);
+
+      const tag = getTagFromId(tagId);
+      const edge = patternNode.edges.find(e => e.label === tag);
+      if (!edge) {
+        throw new Error(`Variant tag '${tag}' not found in pattern edges`);
+      }
+      const payloadBox = [null];
+
+      stack.push({
+        finishVariant: true,
+        tag,
+        payloadBox,
+        assign
+      });
+
+      stack.push({
+        ptr: payloadPtr,
+        patternNodeId: edge.target,
+        assign: (v) => { payloadBox[0] = v; }
+      });
+    } else {
+      throw new Error(`Unsupported pattern kind: ${patternNode.kind}`);
+    }
+  }
+
+  return rootValue;
+}
+
+export function writeValueToArena(exports, rootValue, pattern, rootPatternNodeId) {
+  let rootPtr;
+  const stack = [{
+    value: rootValue,
+    patternNodeId: rootPatternNodeId,
+    assign: (p) => { rootPtr = p; }
+  }];
+
+  while (stack.length > 0) {
+    const frame = stack.pop();
+
+    if (frame.finishProduct) {
+      const { ptr, totalSize, N, childPtrs, assign } = frame;
+      const view = new DataView(exports.memory.buffer);
+      view.setUint32(ptr, totalSize, true);
+      view.setUint32(ptr + 4, N, true);
+
+      for (let i = 0; i < N; i++) {
+        const offsetVal = 8 + 4 * N + 4 * i;
+        view.setUint32(ptr + 8 + 4 * i, offsetVal, true);
+        view.setUint32(ptr + offsetVal, childPtrs[i], true);
+      }
+      assign(ptr);
+      continue;
+    }
+
+    if (frame.finishVariant) {
+      const { tagId, childPtrBox, assign } = frame;
+      const ptr = exports.alloc(12);
+      const view = new DataView(exports.memory.buffer);
+
+      view.setUint32(ptr, 12, true);
+      view.setUint32(ptr + 4, tagId, true);
+      view.setUint32(ptr + 8, childPtrBox[0], true);
+      assign(ptr);
+      continue;
+    }
+
+    const { value, patternNodeId, assign } = frame;
+    const patternNode = pattern.nodes[patternNodeId];
+
+    if (isProduct(value)) {
+      const keys = Object.keys(value.product).sort();
+      const N = keys.length;
+      const totalSize = 8 + 8 * N;
+      const ptr = exports.alloc(totalSize);
+
+      const childPtrs = new Array(N);
+      stack.push({
+        finishProduct: true,
+        ptr,
+        totalSize,
+        N,
+        childPtrs,
+        assign
+      });
+
+      for (let i = N - 1; i >= 0; i--) {
+        const label = keys[i];
+        const edge = patternNode.edges.find(e => e.label === label);
+        const childVal = value.product[label];
+        const targetNode = edge ? edge.target : patternNodeId;
+        const index = i;
+        stack.push({
+          value: childVal,
+          patternNodeId: targetNode,
+          assign: (p) => { childPtrs[index] = p; }
+        });
+      }
+    } else if (isVariant(value)) {
+      const tagId = getTagId(value.tag);
+      const edge = patternNode.edges.find(e => e.label === value.tag);
+      const childPtrBox = [0];
+
+      stack.push({
+        finishVariant: true,
+        tagId,
+        childPtrBox,
+        assign
+      });
+
+      stack.push({
+        value: value.value,
+        patternNodeId: edge ? edge.target : patternNodeId,
+        assign: (p) => { childPtrBox[0] = p; }
+      });
+    } else {
+      throw new Error(`Unsupported value type: ${value}`);
+    }
+  }
+
+  return rootPtr;
+}