knitting 0.1.60 → 0.1.61

package/src/worker/rx-queue.d.ts

@@ -9,9 +9,19 @@ type ArgumentsForCreateWorkerQueue = {
     borrowReturnedBufferReferences?: boolean;
     hasAborted?: (signal: number) => boolean;
     now?: () => number;
+    /**
+     * Work-stealing discipline: only claim when this worker has nothing left to
+     * run. Without it a worker keeps claiming whole regions on top of a backlog
+     * it has not started, which is exactly the hoarding stealing exists to
+     * prevent — the queued tasks would be better taken by an idle peer.
+     *
+     * Off for the classic per-lane path, where the host has already assigned
+     * these tasks to this lane and batching them is a win.
+     */
+    stealing?: boolean;
 };
 export type CreateWorkerRxQueue = ReturnType<typeof createWorkerRxQueue>;
-export declare const createWorkerRxQueue: ({ listOfFunctions, workerOptions, lock, returnLock, borrowReturnedBufferReferences, hasAborted, now, }: ArgumentsForCreateWorkerQueue) => {
+export declare const createWorkerRxQueue: ({ listOfFunctions, workerOptions, lock, returnLock, borrowReturnedBufferReferences, hasAborted, now, stealing, }: ArgumentsForCreateWorkerQueue) => {
     hasCompleted: () => boolean;
     hasPending: () => boolean;
     writeBatch: (max: number) => number;

package/src/worker/rx-queue.js

@@ -2,7 +2,7 @@ import RingQueue from "../ipc/tools/ring-queue.js";
 import { attachPayloadTransportFinalizer, runTaskFinalizers, TaskFlag, TaskIndex, } from "../memory/lock.js";
 import { composeWorkerRunner } from "./composable-runners.js";
 import { BUFFER_REFERENCE_RETURN_RELEASE_TOKEN } from "../connections/buffer-reference.js";
-export const createWorkerRxQueue = ({ listOfFunctions, workerOptions, lock, returnLock, borrowReturnedBufferReferences, hasAborted, now, }) => {
+export const createWorkerRxQueue = ({ listOfFunctions, workerOptions, lock, returnLock, borrowReturnedBufferReferences, hasAborted, now, stealing, }) => {
     const PLACE_HOLDER = (_) => {
         throw ("UNREACHABLE FROM PLACE HOLDER (thread)");
     };
@@ -71,6 +71,9 @@ export const createWorkerRxQueue = ({ listOfFunctions, workerOptions, lock, retu
     const { decode, resolved } = lock;
     const resolvedShift = () => resolved.shiftNoClear();
     const enqueueLock = () => {
+        // Steal only when idle: leaving work unclaimed lets a free peer take it.
+        if (stealing && toWork.size !== 0)
+            return false;
         if (!decode())
             return false;
         let task = resolvedShift();

package/src/worker/timers.d.ts

@@ -4,7 +4,7 @@ type PauseOptions = {
 export type NativeWaitU32 = (buffer: ArrayBuffer | SharedArrayBuffer, byteOffset: number, expected: number, timeoutMs?: number) => unknown;
 export declare const whilePausing: ({ pauseInNanoseconds }: PauseOptions) => () => void;
 export declare const pauseGeneric: () => void;
-export declare const sleepUntilChanged: ({ at, opView, pauseInNanoseconds, rxStatus, txStatus, enqueueLock, write, nativeWaitU32, useSharedMemoryWait, }: {
+export declare const sleepUntilChanged: ({ at, opView, pauseInNanoseconds, rxStatus, txStatus, enqueueLock, write, nativeWaitU32, useSharedMemoryWait, flushBeforeClaim, }: {
     opView: Int32Array;
     rxStatus: Int32Array;
     txStatus: Int32Array;
@@ -14,5 +14,12 @@ export declare const sleepUntilChanged: ({ at, opView, pauseInNanoseconds, rxSta
     write?: () => number | boolean;
     nativeWaitU32?: NativeWaitU32;
     useSharedMemoryWait?: boolean;
+    /**
+     * Stealing only: write results back before attempting to claim more work.
+     * A claim can spin waiting for a peer to withdraw its intent, so claiming
+     * first puts arbitration latency in front of a finished response. Measured
+     * to hurt the per-lane path, so it stays off by default.
+     */
+    flushBeforeClaim?: boolean;
 }) => (value: number, spinMicroseconds: number, parkMs?: number) => void;
 export {};

package/src/worker/timers.js

@@ -30,7 +30,9 @@ const a_load = Atomics.load;
 const a_store = Atomics.store;
 const a_wait = typeof Atomics.wait === "function" ? Atomics.wait : undefined;
 const p_now = performance.now.bind(performance);
-const waitFallbackView = a_wait === undefined
+// `SharedArrayBuffer` is undeclared on pages that are not cross-origin
+// isolated, and this module has to load anyway so the pool can report why.
+const waitFallbackView = a_wait === undefined || typeof SharedArrayBuffer !== "function"
     ? undefined
     : new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
 const a_pause = "pause" in Atomics
@@ -59,26 +61,27 @@ export const whilePausing = ({ pauseInNanoseconds }) => {
     return () => a_pause(forNanoseconds);
 };
 export const pauseGeneric = whilePausing({});
-export const sleepUntilChanged = ({ at, opView, pauseInNanoseconds, rxStatus, txStatus, enqueueLock, write, nativeWaitU32, useSharedMemoryWait = true, }) => {
+export const sleepUntilChanged = ({ at, opView, pauseInNanoseconds, rxStatus, txStatus, enqueueLock, write, nativeWaitU32, useSharedMemoryWait = true, flushBeforeClaim = false, }) => {
     const pause = pauseInNanoseconds === undefined
         ? pauseGeneric
         : whilePausing({ pauseInNanoseconds });
-    const tryProgress = () => {
-        let progressed = false;
-        if (enqueueLock())
-            progressed = true;
-        if (write) {
-            const wrote = write();
-            if (typeof wrote === "number") {
-                if (wrote > 0)
-                    progressed = true;
-            }
-            else if (wrote === true) {
-                progressed = true;
-            }
-        }
-        return progressed;
+    const flushWrite = () => {
+        if (!write)
+            return false;
+        const wrote = write();
+        if (typeof wrote === "number")
+            return wrote > 0;
+        return wrote === true;
     };
+    const tryProgress = flushBeforeClaim
+        ? () => {
+            const wrote = flushWrite();
+            return enqueueLock() || wrote;
+        }
+        : () => {
+            const claimed = enqueueLock();
+            return flushWrite() || claimed;
+        };
     return (value, spinMicroseconds, parkMs) => {
         const until = p_now() + (spinMicroseconds / 1000);
         maybeGc();