@nxtedition/scheduler 3.0.4 → 3.0.6

package/lib/index.js

@@ -1,15 +1,8 @@
-import os from 'node:os'
-
 const RUNNING_INDEX = 0
 const CONCURRENCY_INDEX = 1
 
 const maxInt = 2147483647
 
-// On x86/x64, aligned 32-bit reads do not tear, so a plain array access is safe
-// and avoids the overhead of Atomics.load() in V8. On other architectures (e.g. ARM),
-// use Atomics.load() to prevent tearing.
-const useAtomicLoad = os.arch() !== 'x64' && os.arch() !== 'ia32'
-
 class FastQueue {
   idx = 0
   cnt = 0
@@ -110,17 +103,17 @@ export class Scheduler {
       throw new Error('Invalid concurrency')
     }
     const stateBuffer = new SharedArrayBuffer(64)
-    const stateView = new Uint32Array(stateBuffer)
+    const stateView = new Int32Array(stateBuffer)
     Atomics.store(stateView, CONCURRENCY_INDEX, concurrency ?? 0)
     return stateBuffer
   }
 
   constructor(opts                                              ) {
     if (opts instanceof SharedArrayBuffer) {
-      this.#stateView = new Uint32Array(opts)
+      this.#stateView = new Int32Array(opts)
       this.#concurrency = Atomics.load(this.#stateView, CONCURRENCY_INDEX) || Infinity
     } else {
-      this.#concurrency = opts?.concurrency || Infinity
+      this.#concurrency = opts?.concurrency ?? Infinity
     }
   }
 
@@ -152,22 +145,21 @@ export class Scheduler {
     const queue = this.#queues[p + 3]
 
     if (this.#stateView) {
-      // NOTE: The read of stateView followed by Atomics.add is a TOCTOU race. Multiple
-      // workers may simultaneously read a value below the concurrency limit and all
-      // proceed, briefly exceeding it by up to N-1 (where N is the number of workers).
-      // This is by design — the concurrency limit is a soft / best-effort constraint.
-      // Small, transient over-subscriptions are acceptable and self-correcting on the
-      // next release() cycle.
-      // Plain array read on x86 (aligned 32-bit reads don't tear); Atomics.load elsewhere.
-      const running = useAtomicLoad
-        ? Atomics.load(this.#stateView, RUNNING_INDEX)
-        : this.#stateView[RUNNING_INDEX]
-      if (this.#running < 1 || running < this.#concurrency) {
+      // Make sure we are always running at least one local job even if we might globally over subscribe.
+      if (this.#running < 1) {
         Atomics.add(this.#stateView, RUNNING_INDEX, 1)
         this.#running += 1
         fn(opaque)
         return
       }
+
+      if (Atomics.add(this.#stateView, RUNNING_INDEX, 1) >= this.#concurrency) {
+        Atomics.sub(this.#stateView, RUNNING_INDEX, 1)
+      } else {
+        this.#running += 1
+        fn(opaque)
+        return
+      }
     } else if ((this.#running < 1 && this.#concurrency > 0) || this.#running < this.#concurrency) {
       this.#running += 1
       fn(opaque)
@@ -182,10 +174,16 @@ export class Scheduler {
   }
 
   release() {
-    let running = this.#stateView
-      ? Atomics.sub(this.#stateView, RUNNING_INDEX, 1) - 1
-      : this.#running - 1
-    this.#running -= 1
+    let running        
+    if (this.#running > 0) {
+      running = this.#stateView
+        ? Atomics.sub(this.#stateView, RUNNING_INDEX, 1) - 1
+        : this.#running - 1
+      this.#running -= 1
+    } else {
+      // Gracefully handle user error...
+      running = this.#stateView ? Atomics.load(this.#stateView, RUNNING_INDEX) : this.#running
+    }
 
     if (this.#pending === 0 || this.#releasing) {
       return
@@ -230,33 +228,39 @@ export class Scheduler {
           throw new Error('Invariant violation: pending > 0 but no tasks in queues')
         }
 
-        const fn = queue.arr[queue.idx++]                                 
-        const opaque = queue.arr[queue.idx++]
+        const fn = queue.arr[queue.idx]                                 
+        queue.arr[queue.idx++] = null
+        const opaque = queue.arr[queue.idx]
+        queue.arr[queue.idx++] = null
         queue.cnt -= 1
 
         if (queue.cnt === 0) {
           queue.idx = 0
           queue.arr.length = 0
         } else if (queue.idx > 1024) {
-          queue.idx = 0
           queue.arr.splice(0, queue.idx)
+          queue.idx = 0
         }
 
-        running = this.#stateView
-          ? Atomics.add(this.#stateView, RUNNING_INDEX, 1) + 1
-          : this.#running + 1
-
-        this.#counter += 1
         this.#pending -= 1
         this.#running += 1
+
+        if (this.#stateView) {
+          Atomics.add(this.#stateView, RUNNING_INDEX, 1)
+        }
+
         fn(opaque)
+
+        // Re-read running after fn() in case it synchronously called release()
+        running = this.#stateView ? Atomics.load(this.#stateView, RUNNING_INDEX) : this.#running
       }
-      this.#releasing = false
     } catch (err) {
       // Throwing here is undefined behavior...
       queueMicrotask(() => {
         throw new Error('Scheduler task error', { cause: err })
       })
+    } finally {
+      this.#releasing = false
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/scheduler",
-  "version": "3.0.4",
+  "version": "3.0.6",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -18,7 +18,8 @@
     "prepublishOnly": "yarn build",
     "typecheck": "tsc --noEmit",
     "test": "yarn build && node --test",
-    "test:ci": "yarn build && node --test"
+    "test:ci": "yarn build && node --test",
+    "test:coverage": "npx tsx --test --experimental-test-coverage src/index.test.ts"
   },
   "devDependencies": {
     "@types/node": "^25.2.3",
@@ -27,5 +28,5 @@
     "rimraf": "^6.1.2",
     "typescript": "^5.9.3"
   },
-  "gitHead": "17807cefcac092e20ebf99befddf0e742e5fc0e2"
+  "gitHead": "80ace3245dc851f38a288b0c3b167ca0024f0469"
 }