knitting 0.1.55 → 0.1.60

package/src/runtime/tx-queue.d.ts

@@ -0,0 +1,28 @@
+import "../memory/payloadCodec.js";
+import { type Lock2, type Task } from "../memory/lock.js";
+import type { AbortSignalOption, TaskTimeout } from "../types.js";
+import { type SignalAbortStore } from "../shared/abortSignal.js";
+import { type BufferReferenceReturnHooks } from "../connections/buffer-reference.js";
+type RawArguments = unknown;
+type FunctionID = number;
+type QueueTask = Task;
+export type MultiQueue = ReturnType<typeof createHostTxQueue>;
+type CreateHostTxQueueArgs = {
+    max?: number;
+    lock: Lock2;
+    returnLock: Lock2;
+    releaseBufferReferenceReturn?: ((token: bigint) => void) | BufferReferenceReturnHooks;
+    abortSignals?: Pick<SignalAbortStore, "getSignal" | "setSignal" | "resetSignal" | "closeNow">;
+    now?: () => number;
+};
+export declare function createHostTxQueue({ max, lock, returnLock, releaseBufferReferenceReturn, abortSignals, now, }: CreateHostTxQueueArgs): {
+    rejectAll: (reason: string) => void;
+    hasPendingFrames: () => boolean;
+    txIdle: () => boolean;
+    completeFrame: () => number;
+    enqueue: (functionID: FunctionID, timeout?: TaskTimeout, abortSignal?: AbortSignalOption) => (rawArgs: RawArguments) => Promise<never> | import("../common/with-resolvers.js").PromiseWithMaybeReject<unknown>;
+    flushToWorker: () => boolean;
+    enqueueKnown: (task: QueueTask) => boolean;
+    settlePromisePayload: (task: QueueTask, isRejected: boolean, value: unknown) => boolean;
+};
+export {};

package/src/runtime/tx-queue.js

@@ -0,0 +1,158 @@
+// Side-effect import: registers the payload codec (cycle break for Andromeda;
+// see lock.ts), ensuring registration before any lock2() call.
+import "../memory/payloadCodec.js";
+import { makeTask, resetTaskLocalFlags, runTaskFinalizers, TaskIndex, } from "../memory/lock.js";
+import { withResolvers } from "../common/with-resolvers.js";
+import { AbortSignalPoolExhausted, OneShotDeferred, } from "../shared/abortSignal.js";
+import { withBufferReferenceReturnReleaser, } from "../connections/buffer-reference.js";
+const SLOT_INDEX_MASK = 31;
+const SLOT_META_MASK = 0x07ffffff;
+const SLOT_META_SHIFT = 5;
+const FUNCTION_ID_MASK = 0xffff;
+const FUNCTION_META_MASK = 0xffff;
+const FUNCTION_META_SHIFT = 16;
+const ABORT_SIGNAL_META_OFFSET = 1;
+const NO_ABORT_SIGNAL = -1;
+const p_now = performance.now.bind(performance);
+export function createHostTxQueue({ max, lock, returnLock, releaseBufferReferenceReturn, abortSignals, now, }) {
+    const PLACE_HOLDER = (_) => {
+        throw ("UNREACHABLE FROM PLACE HOLDER (main)");
+    };
+    const newSlot = (id) => {
+        const task = makeTask();
+        task[TaskIndex.ID] = id;
+        task[TaskIndex.FunctionID] = 0;
+        task.value = null;
+        task.resolve = PLACE_HOLDER;
+        task.reject = PLACE_HOLDER;
+        return task;
+    };
+    const initialSize = max ?? 10;
+    const queue = Array.from({ length: initialSize }, (_, index) => newSlot(index));
+    const freeSockets = Array.from({ length: initialSize }, (_, i) => i);
+    const freePush = (id) => freeSockets.push(id);
+    const freePop = () => freeSockets.pop();
+    const queuePush = (task) => queue.push(task);
+    const { publish, flushPending, hasPendingFrames, getPendingFrameCount, getPendingPromiseCount, resetPendingState, } = lock;
+    let inUsed = 0 | 0;
+    const resetSignal = abortSignals?.resetSignal;
+    const nowTime = now ?? p_now;
+    const resolveReturn = returnLock.resolveHost({
+        queue,
+        activeRejectPlaceholder: PLACE_HOLDER,
+        onResolved: (task) => {
+            inUsed = (inUsed - 1) | 0;
+            resetTaskLocalFlags(task);
+            runTaskFinalizers(task);
+            task.value = null;
+            task.resolve = PLACE_HOLDER;
+            task.reject = PLACE_HOLDER;
+            freePush(task[TaskIndex.ID]);
+        },
+    });
+    const completeFrame = releaseBufferReferenceReturn === undefined
+        ? resolveReturn
+        : () => withBufferReferenceReturnReleaser(releaseBufferReferenceReturn, resolveReturn);
+    const hasActiveTasks = () => {
+        const count = (inUsed - getPendingPromiseCount()) | 0;
+        return count > 0;
+    };
+    const txIdle = () => getPendingFrameCount() === 0 && !hasActiveTasks();
+    const rejectAll = (reason) => {
+        for (let index = 0; index < queue.length; index++) {
+            const slot = queue[index];
+            if (slot.reject !== PLACE_HOLDER) {
+                try {
+                    slot.reject(reason);
+                }
+                catch {
+                }
+                runTaskFinalizers(slot);
+                slot.resolve = PLACE_HOLDER;
+                slot.reject = PLACE_HOLDER;
+                queue[index] = newSlot(index);
+            }
+        }
+        resetPendingState();
+        inUsed = 0 | 0;
+    };
+    const flushToWorker = () => flushPending();
+    const enqueueKnown = (task) => {
+        return publish(task);
+    };
+    return {
+        rejectAll,
+        hasPendingFrames,
+        txIdle,
+        completeFrame,
+        enqueue: (functionID, timeout, abortSignal) => {
+            const HAS_TIMER = timeout !== undefined;
+            const functionIDMasked = functionID & FUNCTION_ID_MASK;
+            const USE_SIGNAL = abortSignal !== undefined &&
+                abortSignals !== undefined;
+            return (rawArgs) => {
+                if (inUsed === queue.length) {
+                    const newSize = inUsed + 32;
+                    let current = queue.length;
+                    while (newSize > current) {
+                        queuePush(newSlot(current));
+                        freePush(current);
+                        current++;
+                    }
+                }
+                const index = freePop();
+                const slot = queue[index];
+                const deferred = withResolvers();
+                slot[TaskIndex.FunctionID] = functionIDMasked;
+                if (USE_SIGNAL) {
+                    const maybeSignal = abortSignals.getSignal();
+                    if (maybeSignal === abortSignals.closeNow) {
+                        return Promise.reject(AbortSignalPoolExhausted);
+                    }
+                    new OneShotDeferred(deferred, () => resetSignal(maybeSignal), () => {
+                        abortSignals.setSignal(maybeSignal);
+                    });
+                    const encodedSignalMeta = ((maybeSignal + ABORT_SIGNAL_META_OFFSET) & FUNCTION_META_MASK) >>>
+                        0;
+                    slot[TaskIndex.FunctionID] =
+                        ((encodedSignalMeta << FUNCTION_META_SHIFT) | functionIDMasked) >>>
+                            0;
+                }
+                slot.value = rawArgs;
+                slot[TaskIndex.ID] = index;
+                slot.resolve = deferred.resolve;
+                slot.reject = deferred.reject;
+                if (HAS_TIMER) {
+                    slot[TaskIndex.slotBuffer] = ((slot[TaskIndex.slotBuffer] & SLOT_INDEX_MASK) |
+                        ((((nowTime() >>> 0) & SLOT_META_MASK) << SLOT_META_SHIFT) >>> 0)) >>> 0;
+                }
+                void publish(slot);
+                inUsed = (inUsed + 1) | 0;
+                return deferred.promise;
+            };
+        },
+        flushToWorker,
+        enqueueKnown,
+        settlePromisePayload: (task, isRejected, value) => {
+            if (task.reject === PLACE_HOLDER)
+                return false;
+            if (isRejected) {
+                try {
+                    task.reject(value);
+                }
+                catch {
+                }
+                resetTaskLocalFlags(task);
+                runTaskFinalizers(task);
+                task.value = null;
+                task.resolve = PLACE_HOLDER;
+                task.reject = PLACE_HOLDER;
+                inUsed = (inUsed - 1) | 0;
+                freePush(task[TaskIndex.ID]);
+                return false;
+            }
+            task.value = value;
+            return enqueueKnown(task);
+        },
+    };
+}

package/src/shared/abortSignal.d.ts

@@ -0,0 +1,23 @@
+import { withResolvers } from "../common/with-resolvers.js";
+import { type SharedBufferSource } from "../common/shared-buffer-region.js";
+export declare const AbortSignalPoolExhausted: unique symbol;
+export declare const EnqueuedAbortSignal: unique symbol;
+export type SignalAbortStore = ReturnType<typeof signalAbortFactory>;
+export type SetSignalResult = -1 | 0 | 1;
+export declare const signalAbortFactory: ({ sab, maxSignals, }: {
+    sab: SharedBufferSource;
+    maxSignals?: number;
+}) => {
+    max: number;
+    closeNow: number;
+    getSignal: () => number;
+    setSignal: (signal: number) => SetSignalResult;
+    abortAll: () => number;
+    hasAborted: (signal: number) => boolean;
+    resetSignal: (signal: number) => boolean;
+    inUseCount: () => number;
+};
+export declare class OneShotDeferred<T> {
+    #private;
+    constructor(deferred: ReturnType<typeof withResolvers<T>>, onSettle: () => void, onEmptyReject?: () => void);
+}

package/src/shared/abortSignal.js

@@ -0,0 +1,134 @@
+import { toSharedBufferRegion, } from "../common/shared-buffer-region.js";
+const SLOT_BITS = 32;
+const SLOT_MASK = SLOT_BITS - 1;
+export const AbortSignalPoolExhausted = Symbol.for("knitting.abortSignal.poolExhausted");
+export const EnqueuedAbortSignal = Symbol.for("knitting.abortSignal.enqueuedSignal");
+export const signalAbortFactory = ({ sab, maxSignals, }) => {
+    const sabRegion = toSharedBufferRegion(sab);
+    const atomicView = new Uint32Array(sabRegion.sab, sabRegion.byteOffset, sabRegion.byteLength / Uint32Array.BYTES_PER_ELEMENT);
+    const size = atomicView.length;
+    const inUse = new Uint32Array(size);
+    const physicalMax = size * SLOT_BITS;
+    const max = (() => {
+        if (!Number.isFinite(maxSignals))
+            return physicalMax;
+        const parsed = Math.floor(maxSignals);
+        if (parsed <= 0)
+            return physicalMax;
+        return Math.min(parsed, physicalMax);
+    })();
+    const closeNow = max + 1;
+    let current = 0;
+    let cursor = 0;
+    const getSignal = () => {
+        if (current >= max)
+            return closeNow;
+        for (let step = 0; step < size; step++) {
+            const word = (cursor + step) % size;
+            const wordBase = word << 5;
+            const remaining = max - wordBase;
+            if (remaining <= 0)
+                continue;
+            const allowedMask = remaining >= SLOT_BITS
+                ? 0xFFFFFFFF
+                : ((1 << remaining) - 1) >>> 0;
+            const freeBits = ((~inUse[word]) & allowedMask) >>> 0;
+            if (freeBits === 0)
+                continue;
+            const bit = (freeBits & -freeBits) >>> 0;
+            inUse[word] = (inUse[word] | bit) >>> 0;
+            current = (current + 1) | 0;
+            cursor = (word + 1) % size;
+            // Recycled slot must start in "not aborted" state.
+            Atomics.and(atomicView, word, ~bit);
+            const bitIndex = 31 - Math.clz32(bit);
+            return (word << 5) + bitIndex;
+        }
+        return closeNow;
+    };
+    const setSignal = (signal) => {
+        // 0 => sentinel "abort because pool/size is exhausted"
+        if (signal === closeNow)
+            return 0;
+        // -1 => invalid signal id
+        if (!Number.isInteger(signal))
+            return -1;
+        if (signal < 0 || signal >= max)
+            return -1;
+        // 1 => signal bit was set as aborted
+        const word = signal >>> 5;
+        const bit = 1 << (signal & SLOT_MASK);
+        Atomics.or(atomicView, word, bit);
+        return 1;
+    };
+    const abortAll = () => {
+        for (let word = 0; word < size; word++) {
+            Atomics.store(atomicView, word, inUse[word]);
+        }
+        return current;
+    };
+    const hasAborted = (signal) => {
+        if (signal === closeNow)
+            return true;
+        if (!Number.isInteger(signal))
+            return false;
+        if (signal < 0 || signal >= max)
+            return false;
+        const word = signal >>> 5;
+        const bit = 1 << (signal & SLOT_MASK);
+        return (Atomics.load(atomicView, word) & bit) !== 0;
+    };
+    const resetSignal = (signal) => {
+        if (signal === closeNow)
+            return false;
+        if (!Number.isInteger(signal))
+            return false;
+        if (signal < 0 || signal >= max)
+            return false;
+        const word = signal >>> 5;
+        const bit = 1 << (signal & SLOT_MASK);
+        const used = (inUse[word] & bit) !== 0;
+        if (!used)
+            return false;
+        inUse[word] = (inUse[word] & ~bit) >>> 0;
+        if (current > 0)
+            current = (current - 1) | 0;
+        cursor = word;
+        // Clear aborted flag for future reuse.
+        Atomics.and(atomicView, word, ~bit);
+        return true;
+    };
+    return {
+        max,
+        closeNow,
+        getSignal,
+        setSignal,
+        abortAll,
+        hasAborted,
+        resetSignal,
+        inUseCount: () => current,
+    };
+};
+export class OneShotDeferred {
+    #triggered = false;
+    constructor(deferred, onSettle, onEmptyReject) {
+        const settleOnce = (fn) => (...args) => {
+            if (this.#triggered)
+                return;
+            this.#triggered = true;
+            onSettle();
+            fn(...args);
+        };
+        deferred.resolve = settleOnce(deferred.resolve);
+        deferred.reject = settleOnce(deferred.reject);
+        deferred.promise.reject = (reason) => {
+            if (this.#triggered)
+                return;
+            if (reason === undefined && onEmptyReject !== undefined) {
+                onEmptyReject();
+                return;
+            }
+            deferred.reject(reason);
+        };
+    }
+}