@divmain/jdm-asm 0.2.0 → 0.2.3

package/benchmarks/worker-pool.ts

@@ -1,223 +0,0 @@
-import { Worker } from "worker_threads";
-import { cpus } from "os";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
-
-// Message types matching worker.ts protocol
-type InitMessage = { type: "init"; wasmBinary: Uint8Array; marshalCode: string };
-type EvaluateMessage = {
-  type: "evaluate";
-  id: number;
-  input: Record<string, unknown>;
-};
-type ShutdownMessage = { type: "shutdown" };
-type ReadyMessage = { type: "ready" };
-type ResultMessage = {
-  type: "result";
-  id: number;
-  output: Record<string, unknown>;
-  latencyNs: string; // Worker-side execution latency (renamed to executionLatencyNs in our interface)
-};
-type ErrorMessage = { type: "error"; id: number; message: string };
-
-type WorkerMessage = ReadyMessage | ResultMessage | ErrorMessage;
-type ToWorkerMessage = InitMessage | EvaluateMessage | ShutdownMessage;
-
-interface PendingRequest {
-  resolve: (value: { output: Record<string, unknown>; executionLatencyNs: number; roundTripLatencyNs: number }) => void;
-  reject: (error: Error) => void;
-  startTime: bigint; // Track when request was sent for round-trip latency calculation
-}
-
-export class LatencyTracker {
-  private samples: number[] = [];
-
-  record(latencyNs: number): void {
-    this.samples.push(latencyNs);
-  }
-
-  getPercentile(p: number): number {
-    const sorted = [...this.samples].sort((a, b) => a - b);
-    const idx = Math.floor((sorted.length * p) / 100);
-    return sorted[idx] ?? 0;
-  }
-
-  report(): { p50: number; p95: number; p99: number } {
-    return {
-      p50: this.getPercentile(50),
-      p95: this.getPercentile(95),
-      p99: this.getPercentile(99),
-    };
-  }
-
-  clear(): void {
-    this.samples = [];
-  }
-}
-
-export class WorkerPool {
-  private workers: Worker[] = [];
-  private pendingRequests: Map<number, PendingRequest> = new Map();
-  private nextRequestId = 0;
-  private nextWorkerIndex = 0;
-  private readonly wasmBinary: Uint8Array;
-  private readonly marshalCode: string;
-
-  constructor(wasmBinary: Uint8Array, marshalCode: string) {
-    this.wasmBinary = wasmBinary;
-    this.marshalCode = marshalCode;
-  }
-
-  async initialize(): Promise<void> {
-    const workerCount = cpus().length;
-    const workerPath = join(
-      dirname(fileURLToPath(import.meta.url)),
-      "worker.ts"
-    );
-
-    const readyPromises: Promise<void>[] = [];
-
-    for (let i = 0; i < workerCount; i++) {
-      const worker = new Worker(workerPath);
-      this.workers.push(worker);
-
-      const readyPromise = new Promise<void>((resolve, reject) => {
-        const onMessage = (msg: WorkerMessage) => {
-          if (msg.type === "ready") {
-            worker.off("message", onMessage);
-            worker.off("error", onError);
-            resolve();
-          }
-        };
-
-        const onError = (err: Error) => {
-          worker.off("message", onMessage);
-          worker.off("error", onError);
-          reject(err);
-        };
-
-        worker.on("message", onMessage);
-        worker.on("error", onError);
-      });
-
-      readyPromises.push(readyPromise);
-
-      // Set up persistent message handler for results
-      worker.on("message", (msg: WorkerMessage) => {
-        this.handleWorkerMessage(msg);
-      });
-
-      worker.on("error", (err) => {
-        console.error("Worker error:", err);
-      });
-
-      // Send init message
-      const initMsg: InitMessage = {
-        type: "init",
-        wasmBinary: this.wasmBinary,
-        marshalCode: this.marshalCode,
-      };
-      worker.postMessage(initMsg);
-    }
-
-    await Promise.all(readyPromises);
-  }
-
-  private handleWorkerMessage(msg: WorkerMessage): void {
-    if (msg.type === "result") {
-      const pending = this.pendingRequests.get(msg.id);
-      if (pending) {
-        this.pendingRequests.delete(msg.id);
-        const roundTripLatencyNs = Number(process.hrtime.bigint() - pending.startTime);
-        pending.resolve({
-          output: msg.output,
-          executionLatencyNs: Number(msg.latencyNs),
-          roundTripLatencyNs,
-        });
-      }
-    } else if (msg.type === "error") {
-      const pending = this.pendingRequests.get(msg.id);
-      if (pending) {
-        this.pendingRequests.delete(msg.id);
-        pending.reject(new Error(msg.message));
-      }
-    }
-    // Ignore 'ready' messages here - handled in initialize()
-  }
-
-  async evaluateBatch(
-    inputs: Record<string, unknown>[]
-  ): Promise<{
-    outputs: Record<string, unknown>[];
-    roundTripLatencies: number[];  // Main thread perspective (fair comparison)
-    executionLatencies: number[];  // Worker-side WASM execution only (for analysis)
-  }> {
-    if (this.workers.length === 0) {
-      throw new Error("WorkerPool not initialized");
-    }
-
-    const promises: Promise<{ output: Record<string, unknown>; executionLatencyNs: number; roundTripLatencyNs: number }>[] = [];
-
-    for (const input of inputs) {
-      const id = this.nextRequestId++;
-      const workerIndex = this.nextWorkerIndex;
-      this.nextWorkerIndex = (this.nextWorkerIndex + 1) % this.workers.length;
-
-      const worker = this.workers[workerIndex];
-
-      // Record start time BEFORE posting the message to capture full round-trip latency
-      const startTime = process.hrtime.bigint();
-
-      const promise = new Promise<{ output: Record<string, unknown>; executionLatencyNs: number; roundTripLatencyNs: number }>(
-        (resolve, reject) => {
-          this.pendingRequests.set(id, { resolve, reject, startTime });
-        }
-      );
-
-      promises.push(promise);
-
-      const evalMsg: EvaluateMessage = {
-        type: "evaluate",
-        id,
-        input,
-      };
-      worker.postMessage(evalMsg);
-    }
-
-    const results = await Promise.all(promises);
-
-    const outputs: Record<string, unknown>[] = [];
-    const roundTripLatencies: number[] = [];
-    const executionLatencies: number[] = [];
-
-    for (const result of results) {
-      outputs.push(result.output);
-      roundTripLatencies.push(result.roundTripLatencyNs);
-      executionLatencies.push(result.executionLatencyNs);
-    }
-
-    return { outputs, roundTripLatencies, executionLatencies };
-  }
-
-  async shutdown(): Promise<void> {
-    const terminationPromises: Promise<number>[] = [];
-
-    for (const worker of this.workers) {
-      const shutdownMsg: ShutdownMessage = { type: "shutdown" };
-      worker.postMessage(shutdownMsg);
-      terminationPromises.push(
-        new Promise<number>((resolve) => {
-          worker.on("exit", resolve);
-        })
-      );
-    }
-
-    await Promise.all(terminationPromises);
-    this.workers = [];
-    this.pendingRequests.clear();
-  }
-
-  getWorkerCount(): number {
-    return this.workers.length;
-  }
-}

package/benchmarks/worker.ts

@@ -1,374 +0,0 @@
-/**
- * Worker thread entry point for multi-threaded benchmarking.
- *
- * This worker receives WASM binary and marshal code on init,
- * creates its own WASM evaluator instance, and handles evaluate
- * requests with high-resolution timing.
- */
-
-import { parentPort } from "worker_threads";
-
-// ============================================================================
-// Constants and Utilities
-// ============================================================================
-
-const WASM_PAGE_SIZE_BYTES = 65536;
-
-/**
- * Ensure WASM memory is large enough for the required size.
- * Inlined from src/compiler/runtime.ts to avoid module resolution issues in workers.
- */
-function ensureMemory(memory: WebAssembly.Memory, required: number): void {
-  const current = memory.buffer.byteLength;
-  if (required <= current) {
-    return;
-  }
-  const pagesNeeded = Math.ceil((required - current) / WASM_PAGE_SIZE_BYTES);
-  const oldPages = memory.grow(pagesNeeded);
-  if (oldPages < 0) {
-    throw new Error(`Failed to grow memory by ${pagesNeeded} pages`);
-  }
-}
-
-// ============================================================================
-// Message Protocol Types
-// ============================================================================
-
-// Main -> Worker messages
-type InitMessage = {
-  type: "init";
-  wasmBinary: Uint8Array;
-  marshalCode: string;
-};
-
-type EvaluateMessage = {
-  type: "evaluate";
-  id: number;
-  input: Record<string, unknown>;
-};
-
-type ShutdownMessage = {
-  type: "shutdown";
-};
-
-type WorkerMessage = InitMessage | EvaluateMessage | ShutdownMessage;
-
-// Worker -> Main messages
-type ReadyMessage = {
-  type: "ready";
-};
-
-type ResultMessage = {
-  type: "result";
-  id: number;
-  output: Record<string, unknown>;
-  latencyNs: string; // bigint serialized as string
-};
-
-type ErrorMessage = {
-  type: "error";
-  id: number;
-  message: string;
-};
-
-type WorkerResponse = ReadyMessage | ResultMessage | ErrorMessage;
-
-// ============================================================================
-// Worker State
-// ============================================================================
-
-let instance: WebAssembly.Instance | null = null;
-let memory: WebAssembly.Memory | null = null;
-let evaluate: ((ptr: number) => number) | null = null;
-let collect: (() => void) | null = null;
-let unmarshalOutput: ((ptr: number, memory: WebAssembly.Memory) => Record<string, unknown>) | null =
-  null;
-let marshalMapInput:
-  | ((data: Record<string, unknown>, memory: WebAssembly.Memory, basePtr: number) => number)
-  | null = null;
-
-// ============================================================================
-// Marshal Map Input Function
-// ============================================================================
-
-/**
- * Create the marshalMapInput function.
- * This is copied from ReusableWasmEvaluator in tests/helpers/test-harness-wasm.ts.
- */
-function createMarshalMapInput(): (
-  data: Record<string, unknown>,
-  memory: WebAssembly.Memory,
-  basePtr: number,
-) => number {
-  return (
-    data: Record<string, unknown>,
-    memory: WebAssembly.Memory,
-    basePtr: number,
-  ): number => {
-    const view = new DataView(memory.buffer);
-    const entries = Object.entries(data);
-    const length = entries.length;
-
-    // Write map length at basePtr
-    view.setUint32(basePtr, length, true);
-
-    // Allocate and write keys and values
-    let currentOffset = basePtr + 4 + length * 8; // Skip map structure
-
-    const writeValue = (value: unknown): number => {
-      // Returns pointer to a fully allocated Value structure
-      const valuePtr = currentOffset;
-
-      if (value === null || value === undefined) {
-        view.setUint32(valuePtr, 0, true); // TAG_NULL = 0
-        currentOffset += 4;
-      } else if (typeof value === "boolean") {
-        view.setUint32(valuePtr, 1, true); // TAG_BOOLEAN = 1
-        view.setUint8(valuePtr + 4, value ? 1 : 0);
-        currentOffset += 5;
-      } else if (typeof value === "number") {
-        view.setUint32(valuePtr, 3, true); // TAG_FLOAT = 3
-        view.setFloat64(valuePtr + 4, value, true);
-        currentOffset += 12;
-      } else if (typeof value === "string") {
-        view.setUint32(valuePtr, 4, true); // TAG_STRING = 4
-        currentOffset += 8;
-        const stringDataPtr = currentOffset;
-        const len = value.length;
-        view.setUint32(stringDataPtr, len, true);
-        for (let i = 0; i < len; i++) {
-          view.setUint16(stringDataPtr + 4 + i * 2, value.charCodeAt(i), true);
-        }
-        currentOffset += 4 + len * 2;
-        view.setUint32(valuePtr + 4, stringDataPtr, true);
-      } else if (Array.isArray(value)) {
-        const arrLength = value.length;
-        currentOffset += 8;
-        const arrayPtr = currentOffset;
-        currentOffset += 4 + arrLength * 4;
-        view.setUint32(arrayPtr, arrLength, true);
-        let ptrOffset = arrayPtr + 4;
-        for (let i = 0; i < arrLength; i++) {
-          const elemPtr = writeValue(value[i]);
-          view.setUint32(ptrOffset, elemPtr, true);
-          ptrOffset += 4;
-        }
-        view.setUint32(valuePtr, 5, true); // TAG_ARRAY = 5
-        view.setUint32(valuePtr + 4, arrayPtr, true);
-      } else if (typeof value === "object") {
-        const obj = value as Record<string, unknown>;
-        const objEntries = Object.entries(obj);
-        currentOffset += 8;
-        const mapPtr = currentOffset;
-        currentOffset += 4 + objEntries.length * 8;
-        view.setUint32(mapPtr, objEntries.length, true);
-        let ptrOffset = mapPtr + 4;
-        for (const [key, val] of objEntries) {
-          const keyStrPtr = currentOffset;
-          const keyLen = key.length;
-          view.setUint32(keyStrPtr, keyLen, true);
-          for (let i = 0; i < keyLen; i++) {
-            view.setUint16(keyStrPtr + 4 + i * 2, key.charCodeAt(i), true);
-          }
-          currentOffset += 4 + keyLen * 2;
-          view.setUint32(ptrOffset, keyStrPtr, true);
-          const nestedValuePtr = writeValue(val);
-          view.setUint32(ptrOffset + 4, nestedValuePtr, true);
-          ptrOffset += 8;
-        }
-        view.setUint32(valuePtr, 6, true); // TAG_OBJECT = 6
-        view.setUint32(valuePtr + 4, mapPtr, true);
-      } else {
-        throw new Error(`Unsupported type: ${typeof value}`);
-      }
-
-      return valuePtr;
-    };
-
-    let ptrOffset = basePtr + 4;
-    for (let i = 0; i < length; i++) {
-      const [key, value] = entries[i];
-      const keyStrPtr = currentOffset;
-      const keyLen = key.length;
-      view.setUint32(keyStrPtr, keyLen, true);
-      for (let j = 0; j < keyLen; j++) {
-        view.setUint16(keyStrPtr + 4 + j * 2, key.charCodeAt(j), true);
-      }
-      currentOffset += 4 + keyLen * 2;
-      const valuePtr = writeValue(value);
-      view.setUint32(ptrOffset, keyStrPtr, true);
-      view.setUint32(ptrOffset + 4, valuePtr, true);
-      ptrOffset += 8;
-    }
-
-    return basePtr;
-  };
-}
-
-// ============================================================================
-// Message Handlers
-// ============================================================================
-
-/**
- * Handle init message - compile WASM and load marshal code.
- */
-async function handleInit(msg: InitMessage): Promise<void> {
-  // Compile and instantiate the WASM module from the binary
-  // Create a proper ArrayBuffer from the Uint8Array for WebAssembly.compile
-  const wasmArray = new Uint8Array(msg.wasmBinary);
-  const buffer = wasmArray.buffer.slice(
-    wasmArray.byteOffset,
-    wasmArray.byteOffset + wasmArray.byteLength,
-  );
-  const wasmModule = await WebAssembly.compile(buffer as ArrayBuffer);
-  instance = await WebAssembly.instantiate(wasmModule, {
-    env: {
-      abort: () => {
-        throw new Error("WASM abort called");
-      },
-      "Date.now": () => Date.now(),
-    },
-  });
-
-  memory = instance.exports.memory as WebAssembly.Memory;
-  evaluate = instance.exports.evaluate as (ptr: number) => number;
-  collect = instance.exports.__collect as (() => void) | null;
-
-  // Load the generated marshal code using new Function() approach
-  const cleanedCode = msg.marshalCode
-    .replace(/^export function marshalInput/gm, "function marshalInput")
-    .replace(/^export function unmarshalOutput/gm, "function unmarshalOutput")
-    .replace(/^export function readString/gm, "function readString")
-    .replace(/^export function readArray/gm, "function readArray")
-    .replace(/^export function readValue/gm, "function readValue");
-
-  const marshalCodeModule: Record<string, unknown> = {};
-  const executeCode = new Function(
-    "module",
-    cleanedCode +
-      "\nmodule.marshalInput = marshalInput;\nmodule.unmarshalOutput = unmarshalOutput;\nmodule.readString = readString;\nmodule.readArray = readArray;\nmodule.readValue = readValue;",
-  );
-  executeCode(marshalCodeModule);
-
-  unmarshalOutput = marshalCodeModule.unmarshalOutput as (
-    ptr: number,
-    memory: WebAssembly.Memory,
-  ) => Record<string, unknown>;
-
-  // Create the marshalMapInput function
-  marshalMapInput = createMarshalMapInput();
-
-  // Ensure enough memory for evaluation
-  const requiredMemory = 768 * 1024;
-  ensureMemory(memory, requiredMemory);
-
-  // Send ready message
-  const response: ReadyMessage = { type: "ready" };
-  parentPort!.postMessage(response);
-}
-
-/**
- * Handle evaluate message - run evaluation with timing.
- */
-function handleEvaluate(msg: EvaluateMessage): void {
-  if (!instance || !memory || !evaluate || !unmarshalOutput || !marshalMapInput) {
-    const response: ErrorMessage = {
-      type: "error",
-      id: msg.id,
-      message: "Worker not initialized. Send init message first.",
-    };
-    parentPort!.postMessage(response);
-    return;
-  }
-
-  try {
-    // Record start time with high-resolution timing
-    const startTime = process.hrtime.bigint();
-
-    // Place input data at 640KB - after the custom heap region (512KB+)
-    // Memory layout:
-    //   - Static data: 0 - ~50KB
-    //   - AS runtime heap: ~50KB - 192KB (grows during evaluation, stub runtime has no GC)
-    //   - Reserved: 192KB - 512KB
-    //   - Custom heap (output): 512KB - 640KB
-    //   - Input data: 640KB - 768KB
-    const inputPtr = 640 * 1024;
-
-    marshalMapInput(msg.input, memory, inputPtr);
-    const outputPtr = evaluate(inputPtr);
-    const result = unmarshalOutput(outputPtr, memory);
-
-    // Run garbage collection to free memory used during evaluation
-    if (collect) {
-      collect();
-    }
-
-    // Record end time and calculate latency
-    const endTime = process.hrtime.bigint();
-    const latencyNs = endTime - startTime;
-
-    // Send result message (bigint converted to string for postMessage)
-    const response: ResultMessage = {
-      type: "result",
-      id: msg.id,
-      output: result,
-      latencyNs: latencyNs.toString(),
-    };
-    parentPort!.postMessage(response);
-  } catch (error) {
-    const response: ErrorMessage = {
-      type: "error",
-      id: msg.id,
-      message: error instanceof Error ? error.message : String(error),
-    };
-    parentPort!.postMessage(response);
-  }
-}
-
-/**
- * Handle shutdown message - exit the worker.
- */
-function handleShutdown(): void {
-  process.exit(0);
-}
-
-// ============================================================================
-// Main Message Handler
-// ============================================================================
-
-if (!parentPort) {
-  throw new Error("This module must be run as a worker thread");
-}
-
-parentPort.on("message", async (msg: WorkerMessage) => {
-  switch (msg.type) {
-    case "init":
-      try {
-        await handleInit(msg);
-      } catch (error) {
-        const response: ErrorMessage = {
-          type: "error",
-          id: -1,
-          message: `Init failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-        parentPort!.postMessage(response);
-      }
-      break;
-
-    case "evaluate":
-      handleEvaluate(msg);
-      break;
-
-    case "shutdown":
-      handleShutdown();
-      break;
-
-    default:
-      const response: ErrorMessage = {
-        type: "error",
-        id: -1,
-        message: `Unknown message type: ${(msg as { type: string }).type}`,
-      };
-      parentPort!.postMessage(response);
-  }
-});