knitting 0.1.56 → 0.1.61

package/src/runtime/inline-executor.js

@@ -1,27 +1,37 @@
 import { withResolvers } from "../common/with-resolvers.js";
 import RingQueue from "../ipc/tools/ring-queue.js";
 import { createRuntimeMessageChannel } from "../common/worker-runtime.js";
+// const objects, not `enum`s: Andromeda's Nova engine can't parse `enum`. Same
+// values and emit on Node/Deno/Bun.
+const SlotStateMacro = {
+    Free: -1,
+    Pending: 0,
+};
+const TimeoutKind = {
+    Reject: 0,
+    Resolve: 1,
+};
 const normalizeTimeout = (timeout) => {
     if (timeout == null)
         return undefined;
     if (typeof timeout === "number") {
         return timeout >= 0
-            ? { ms: timeout, kind: 0 /* TimeoutKind.Reject */, value: new Error("Task timeout") }
+            ? { ms: timeout, kind: TimeoutKind.Reject, value: new Error("Task timeout") }
             : undefined;
     }
     const ms = timeout.time;
     if (!(ms >= 0))
         return undefined;
     if ("default" in timeout) {
-        return { ms, kind: 1 /* TimeoutKind.Resolve */, value: timeout.default };
+        return { ms, kind: TimeoutKind.Resolve, value: timeout.default };
     }
     if (timeout.maybe === true) {
-        return { ms, kind: 1 /* TimeoutKind.Resolve */, value: undefined };
+        return { ms, kind: TimeoutKind.Resolve, value: undefined };
     }
     if ("error" in timeout) {
-        return { ms, kind: 0 /* TimeoutKind.Reject */, value: timeout.error };
+        return { ms, kind: TimeoutKind.Reject, value: timeout.error };
     }
-    return { ms, kind: 0 /* TimeoutKind.Reject */, value: new Error("Task timeout") };
+    return { ms, kind: TimeoutKind.Reject, value: new Error("Task timeout") };
 };
 const raceTimeout = (promise, spec) => new Promise((resolve, reject) => {
     let done = false;
@@ -29,7 +39,7 @@ const raceTimeout = (promise, spec) => new Promise((resolve, reject) => {
         if (done)
             return;
         done = true;
-        if (spec.kind === 1 /* TimeoutKind.Resolve */) {
+        if (spec.kind === TimeoutKind.Resolve) {
             resolve(spec.value);
         }
         else {
@@ -52,8 +62,10 @@ const raceTimeout = (promise, spec) => new Promise((resolve, reject) => {
 });
 const INLINE_ABORT_TOOLKIT = (() => {
     const hasAborted = () => false;
+    const now = () => performance.now();
     return {
         hasAborted,
+        now,
     };
 })();
 const composeInlineCallable = (fn, timeout, useAbortToolkit = false) => {
@@ -86,7 +98,7 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
     });
     const initCap = 16;
     let fnByIndex = new Int32Array(initCap);
-    let stateByIndex = new Int8Array(initCap).fill(-1 /* SlotStateMacro.Free */);
+    let stateByIndex = new Int8Array(initCap).fill(SlotStateMacro.Free);
     let argsByIndex = new Array(initCap);
     let taskIdByIndex = new Array(initCap).fill(-1);
     let deferredByIndex = new Array(initCap);
@@ -126,13 +138,13 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
         send();
     };
     const enqueueIfCurrent = (index, taskID) => {
-        if (stateByIndex[index] !== 0 /* SlotStateMacro.Pending */ ||
+        if (stateByIndex[index] !== SlotStateMacro.Pending ||
             taskIdByIndex[index] !== taskID)
             return;
         enqueue(index);
     };
     const settleIfCurrent = (index, taskID, isError, value) => {
-        if (stateByIndex[index] !== 0 /* SlotStateMacro.Pending */ ||
+        if (stateByIndex[index] !== SlotStateMacro.Pending ||
             taskIdByIndex[index] !== taskID)
             return;
         const deferred = deferredByIndex[index];
@@ -153,7 +165,7 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
         nextFnByIndex.set(fnByIndex);
         fnByIndex = nextFnByIndex;
         const nextStateByIndex = new Int8Array(newCap);
-        nextStateByIndex.fill(-1 /* SlotStateMacro.Free */);
+        nextStateByIndex.fill(SlotStateMacro.Free);
         nextStateByIndex.set(stateByIndex);
         stateByIndex = nextStateByIndex;
         argsByIndex.length = newCap;
@@ -172,7 +184,7 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
             if (maybeIndex === undefined)
                 break;
             const index = maybeIndex | 0;
-            if (stateByIndex[index] !== 0 /* SlotStateMacro.Pending */)
+            if (stateByIndex[index] !== SlotStateMacro.Pending)
                 continue;
             const taskID = taskIdByIndex[index];
             try {
@@ -213,7 +225,7 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
     }
     function cleanup(index) {
         working--;
-        stateByIndex[index] = -1 /* SlotStateMacro.Free */;
+        stateByIndex[index] = SlotStateMacro.Free;
         fnByIndex[index] = 0;
         taskIdByIndex[index] = -1;
         argsByIndex[index] = undefined;
@@ -230,7 +242,7 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
         argsByIndex[index] = args;
         fnByIndex[index] = fnNumber | 0;
         deferredByIndex[index] = deferred;
-        stateByIndex[index] = 0 /* SlotStateMacro.Pending */;
+        stateByIndex[index] = SlotStateMacro.Pending;
         working++;
         if (args instanceof Promise) {
             args.then((value) => {
@@ -250,7 +262,7 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
     return {
         kills: async () => {
             for (let index = 0; index < stateByIndex.length; index++) {
-                if (stateByIndex[index] !== 0 /* SlotStateMacro.Pending */)
+                if (stateByIndex[index] !== SlotStateMacro.Pending)
                     continue;
                 try {
                     deferredByIndex[index]?.reject("Thread closed");
@@ -271,7 +283,7 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
             taskIdByIndex.fill(-1);
             deferredByIndex.fill(undefined);
             fnByIndex.fill(0);
-            stateByIndex.fill(-1 /* SlotStateMacro.Free */);
+            stateByIndex.fill(SlotStateMacro.Free);
             working = 0;
             isInMacro = false;
             isInMicro = false;

package/src/runtime/pool.d.ts

@@ -1,11 +1,104 @@
+import { createHostTxQueue } from "./tx-queue.js";
 import { type ProcessSharedMemoryBacking } from "./process-worker.js";
 import { type Sab } from "../ipc/transport/shared-memory.js";
 import { ChannelHandler, type DispatcherCheck } from "./dispatcher.js";
-import { lock2 } from "../memory/lock.js";
-import type { DebugOptions, DispatcherSettings, WorkerContext, WorkerData, WorkerSettings } from "../types.js";
+import { lock2, type Task } from "../memory/lock.js";
+import "../memory/payloadCodec.js";
+import type { DebugOptions, DispatcherSettings, LockBuffers, WorkerContext, WorkerData, WorkerSettings } from "../types.js";
 import "../worker/loop.js";
 import { type PayloadBufferOptions } from "../memory/payload-config.js";
-export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug, hostDebug, totalNumberOfThread, source, at, workerOptions, workerExecArgv, permission, host, payload, bufferReferenceReturn, abortSignalCapacity, usesAbortSignal, sharedChannelHandler, }: {
+/**
+ * Build the buffers, host-side locks and pending registry that a stealing pool
+ * shares. One submit region for every worker to claim from, one private return
+ * region per worker, and a single pool-global queue so a response arriving on
+ * any lane settles the right promise.
+ *
+ * Region width follows paper §6.1: the largest power-of-two `g` leaving a spare
+ * region for a delayed claimant (`slots / g >= consumers + 1`). At 32 slots that
+ * caps how wide a region can be well before it caps the worker count.
+ */
+export declare const resolveStealRegionLanes: (consumers: number) => number;
+/** Maximum claimants that leave the protocol's required spare region. */
+export declare const MAX_STEAL_CONSUMERS: number;
+export declare const createStealPoolBuffers: ({ threads, payload, regionLanes, abortSignalCapacity, usesAbortSignal, }: {
+    threads: number;
+    payload?: PayloadBufferOptions;
+    regionLanes?: number;
+    abortSignalCapacity?: number;
+    usesAbortSignal?: boolean;
+}) => {
+    submitBuffers: LockBuffers;
+    returnBuffers: LockBuffers[];
+    hostSubmitLock: {
+        enlist: (task: Task) => true;
+        encode: (task: Task, state?: number) => boolean;
+        encodeManyFrom: (list: import("../ipc/tools/ring-queue.js").default<Task>) => number;
+        encodeAll: () => boolean;
+        publish: (task: Task) => boolean;
+        flushPending: () => boolean;
+        decode: () => boolean;
+        hasSpace: () => boolean;
+        resolved: import("../ipc/tools/ring-queue.js").default<Task>;
+        hostBits: Int32Array<import("../common/shared-buffer-region.js").SharedBuffer>;
+        workerBits: Int32Array<import("../common/shared-buffer-region.js").SharedBuffer>;
+        recyclecList: import("../ipc/tools/ring-queue.js").default<Task>;
+        resolveHost: ({ queue, onResolved, shouldSettle, activeRejectPlaceholder, }: {
+            queue: Task[];
+            onResolved?: (task: Task) => void;
+            shouldSettle?: (task: Task) => boolean;
+            activeRejectPlaceholder?: Task["reject"];
+        }) => () => number;
+        hasPendingFrames: () => boolean;
+        getPendingFrameCount: () => number;
+        getPendingPromiseCount: () => number;
+        resetPendingState: () => void;
+        deactivateStealConsumer: (id: number) => boolean;
+        takeDeferredCount: () => number;
+        setPromiseHandler: (handler?: import("../memory/lock.js").PromisePayloadHandler) => void;
+    };
+    hostReturnLocks: {
+        enlist: (task: Task) => true;
+        encode: (task: Task, state?: number) => boolean;
+        encodeManyFrom: (list: import("../ipc/tools/ring-queue.js").default<Task>) => number;
+        encodeAll: () => boolean;
+        publish: (task: Task) => boolean;
+        flushPending: () => boolean;
+        decode: () => boolean;
+        hasSpace: () => boolean;
+        resolved: import("../ipc/tools/ring-queue.js").default<Task>;
+        hostBits: Int32Array<import("../common/shared-buffer-region.js").SharedBuffer>;
+        workerBits: Int32Array<import("../common/shared-buffer-region.js").SharedBuffer>;
+        recyclecList: import("../ipc/tools/ring-queue.js").default<Task>;
+        resolveHost: ({ queue, onResolved, shouldSettle, activeRejectPlaceholder, }: {
+            queue: Task[];
+            onResolved?: (task: Task) => void;
+            shouldSettle?: (task: Task) => boolean;
+            activeRejectPlaceholder?: Task["reject"];
+        }) => () => number;
+        hasPendingFrames: () => boolean;
+        getPendingFrameCount: () => number;
+        getPendingPromiseCount: () => number;
+        resetPendingState: () => void;
+        deactivateStealConsumer: (id: number) => boolean;
+        takeDeferredCount: () => number;
+        setPromiseHandler: (handler?: import("../memory/lock.js").PromisePayloadHandler) => void;
+    }[];
+    sharedQueue: {
+        rejectAll: (reason: string) => void;
+        hasPendingFrames: () => boolean;
+        txIdle: () => boolean;
+        completeFrame: () => number;
+        setReturnHooks: (lane: number, hooks: (import("../connections/buffer-reference.js").BufferReferenceReturnHooks | ((token: bigint) => void)) | undefined) => void;
+        enqueue: (functionID: number, timeout?: import("../types.js").TaskTimeout, abortSignal?: import("../types.js").AbortSignalOption) => (rawArgs: unknown) => Promise<never> | import("../common/with-resolvers.js").PromiseWithMaybeReject<unknown>;
+        flushToWorker: () => boolean;
+        enqueueKnown: (task: Task) => boolean;
+        settlePromisePayload: (task: Task, isRejected: boolean, value: unknown) => boolean;
+    };
+    regionLanes: number;
+    abortSignalSAB: SharedArrayBuffer;
+    abortSignalMax: number;
+};
+export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug, hostDebug, totalNumberOfThread, source, at, workerOptions, workerExecArgv, permission, host, payload, bufferReferenceReturn, abortSignalCapacity, usesAbortSignal, sharedChannelHandler, stealPool, }: {
     list: string[];
     ids: number[];
     names: string[];
@@ -29,11 +122,34 @@ export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug
      * macro channel that runs all lane checks.
      */
     sharedChannelHandler?: ChannelHandler;
-}) => WorkerContext & {
+    /**
+     * Work-stealing wiring. When present the submit region, both host-side locks
+     * and the pending registry are owned by `createPool` and shared: every worker
+     * claims from one request region, and the host demultiplexes responses by
+     * task id. This lane only contributes its private return region and its
+     * worker. The dispatcher is owned by the pool too, so none is built here.
+     */
+    stealPool?: {
+        submitBuffers: LockBuffers;
+        returnBuffers: LockBuffers;
+        hostSubmitLock: ReturnType<typeof lock2>;
+        hostReturnLock: ReturnType<typeof lock2>;
+        sharedQueue: ReturnType<typeof createHostTxQueue>;
+        consumers: number;
+        consumerId: number;
+        regionLanes: number;
+        abortSignalSAB?: LockBuffers["headers"];
+        abortSignalMax?: number;
+    };
+}) => (WorkerContext & {
+    dispatcherCheck?: never;
+    laneWake?: never;
+    bindSend?: never;
+}) | (WorkerContext & {
     lock: ReturnType<typeof lock2>;
     processSharedMemoryBackings?: readonly ProcessSharedMemoryBacking[];
     dispatcherCheck?: DispatcherCheck;
     laneWake?: () => void;
     bindSend?: (fn: () => void) => void;
-};
+});
 export type CreateContext = WorkerContext;