@nxtedition/scheduler 2.0.4 → 3.0.1

package/lib/index.d.ts

@@ -1,25 +1,29 @@
+export type Priority = -3 | -2 | -1 | 0 | 1 | 2 | 3 | 'lowest' | 'lower' | 'low' | 'normal' | 'high' | 'higher' | 'highest';
+export declare function parsePriority(p: Priority | string | number): number;
 export declare class Scheduler {
     #private;
-    static LOW: 0;
-    static NORMAL: 1;
-    static HIGH: 2;
+    static LOWEST: Priority;
+    static LOWER: Priority;
+    static LOW: Priority;
+    static NORMAL: Priority;
+    static HIGH: Priority;
+    static HIGHER: Priority;
+    static HIGHEST: Priority;
     get concurrency(): number;
     get stats(): {
         deferred: number;
         running: number;
         pending: number;
-        lowCount: number;
-        normalCount: number;
-        highCount: number;
-        lowLimit: number;
-        normalLimit: number;
-        highLimit: number;
+        queues: {
+            count: number;
+            age: number;
+        }[];
     };
     static makeSharedState(concurrency: number): SharedArrayBuffer;
     constructor(opts: SharedArrayBuffer | {
         concurrency?: number;
     });
-    run<T, U>(fn: (opaque?: U) => Promise<T> | T, priority?: 0 | 1 | 2 | 'low' | 'normal' | 'high', opaque?: U): Promise<T>;
-    acquire<U>(fn: (opaque?: U) => unknown, priority?: 0 | 1 | 2 | 'low' | 'normal' | 'high', opaque?: U): void;
+    run<T, U>(fn: (opaque?: U) => Promise<T> | T, priority?: Priority, opaque?: U): Promise<T>;
+    acquire<U>(fn: (opaque?: U) => unknown, priority?: Priority, opaque?: U): void;
     release(): void;
 }

package/lib/index.js

@@ -1,17 +1,76 @@
 const RUNNING_INDEX = 0
 const CONCURRENCY_INDEX = 1
 
+const maxInt = 2147483647
+
+let fastNow = Date.now()
+setInterval(() => {
+  fastNow = Date.now()
+}, 1e3).unref()
+
 class FastQueue {
   idx = 0
   cnt = 0
   arr                        = []
-  lim = 0
+  age = fastNow
+}
+
+                      
+      
+      
+      
+     
+     
+     
+     
+            
+           
+         
+            
+          
+            
+             
+
+export function parsePriority(p                            )         {
+  if (typeof p === 'number') {
+    // Do nothing...
+  } else if (p === 'lowest') {
+    return -3
+  } else if (p === 'lower') {
+    return -2
+  } else if (p === 'low') {
+    return -1
+  } else if (p === 'normal') {
+    return 0
+  } else if (p === 'high') {
+    return 1
+  } else if (p === 'higher') {
+    return 2
+  } else if (p === 'highest') {
+    return 3
+  } else {
+    p = Number(p)
+  }
+
+  if (typeof p !== 'number' || Number.isNaN(p)) {
+    return 0
+  } else if (p < -3) {
+    return -3
+  } else if (p > 3) {
+    return 3
+  } else {
+    return Math.trunc(p)
+  }
 }
 
 export class Scheduler {
-  static LOW    = 0
-  static NORMAL    = 1
-  static HIGH    = 2
+  static LOWEST           = -3
+  static LOWER           = -2
+  static LOW           = -1
+  static NORMAL           = 0
+  static HIGH           = 1
+  static HIGHER           = 2
+  static HIGHEST           = 3
 
   #concurrency
   #stateView
@@ -22,9 +81,15 @@ export class Scheduler {
   #releasing = false
   #deferred = 0
 
-  #lowQueue = new FastQueue()
-  #normalQueue = new FastQueue()
-  #highQueue = new FastQueue()
+  #queues = [
+    new FastQueue(), // 0 lowest
+    new FastQueue(), // 1 lower
+    new FastQueue(), // 2 low
+    new FastQueue(), // 3 normal
+    new FastQueue(), // 4 high
+    new FastQueue(), // 5 higher
+    new FastQueue(), // 6 highest
+  ]
 
   get concurrency() {
     return this.#concurrency
@@ -35,12 +100,7 @@ export class Scheduler {
       deferred: this.#deferred,
       running: this.#running,
       pending: this.#pending,
-      lowCount: this.#lowQueue.cnt,
-      normalCount: this.#normalQueue.cnt,
-      highCount: this.#highQueue.cnt,
-      lowLimit: this.#lowQueue.lim,
-      normalLimit: this.#normalQueue.lim,
-      highLimit: this.#highQueue.lim,
+      queues: this.#queues.map((q) => ({ count: q.cnt, age: q.age })),
     }
   }
 
@@ -61,15 +121,11 @@ export class Scheduler {
     } else {
       this.#concurrency = opts?.concurrency || Infinity
     }
-
-    this.#lowQueue.lim = this.#concurrency / 4
-    this.#normalQueue.lim = this.#concurrency - this.#lowQueue.lim
-    this.#highQueue.lim = this.#concurrency
   }
 
   run      (
     fn                                ,
-    priority                                        = Scheduler.NORMAL,
+    priority = Scheduler.NORMAL,
     opaque    ,
   )             {
     return new Promise   ((resolve, reject) => {
@@ -89,46 +145,18 @@ export class Scheduler {
     })
   }
 
-  acquire   (
-    fn                         ,
-    priority                                        = Scheduler.NORMAL,
-    opaque    ,
-  )       {
-    if (typeof priority === 'number' && Number.isInteger(priority) && priority >= 0) {
-      // Do nothing
-    } else if (priority == null) {
-      priority = Scheduler.NORMAL
-    } else if (typeof priority === 'string') {
-      if (priority === 'low') {
-        priority = Scheduler.LOW
-      } else if (priority === 'normal') {
-        priority = Scheduler.NORMAL
-      } else if (priority === 'high') {
-        priority = Scheduler.HIGH
-      } else {
-        throw new Error('Invalid priority')
-      }
-    } else {
-      throw new Error('Invalid priority')
-    }
-
-    let queue
-    if (priority > Scheduler.NORMAL) {
-      queue = this.#highQueue
-    } else if (priority < Scheduler.NORMAL) {
-      queue = this.#lowQueue
-    } else {
-      queue = this.#normalQueue
-    }
+  acquire   (fn                         , priority           = Scheduler.NORMAL, opaque    )       {
+    const p = parsePriority(priority)          
+    const queue = this.#queues[p + 3]
 
     if (this.#stateView) {
-      if (this.#running < 1 || this.#stateView[RUNNING_INDEX] < queue.lim) {
+      if (this.#running < 1 || this.#stateView[RUNNING_INDEX] < this.#concurrency) {
         Atomics.add(this.#stateView, RUNNING_INDEX, 1)
         this.#running += 1
         fn(opaque)
         return
       }
-    } else if (this.#running < 1 || this.#running < queue.lim) {
+    } else if ((this.#running < 1 && this.#concurrency > 0) || this.#running < this.#concurrency) {
       this.#running += 1
       fn(opaque)
       return
@@ -137,6 +165,10 @@ export class Scheduler {
     queue.arr.push(fn, opaque)
     queue.cnt += 1
 
+    if (queue.cnt === 1) {
+      queue.age = fastNow
+    }
+
     this.#deferred += 1
     this.#pending += 1
   }
@@ -153,38 +185,54 @@ export class Scheduler {
 
     try {
       this.#releasing = true
-      while (this.#pending > 0) {
-        let queue
-        if (this.#highQueue.cnt > 0) {
-          queue = this.#highQueue
-        } else if (this.#normalQueue.cnt > 0) {
-          queue = this.#normalQueue
-        } else if (this.#lowQueue.cnt > 0) {
-          queue = this.#lowQueue
-        } else {
-          throw new Error('Invariant violation: pending > 0 but no tasks in queues')
+      while (this.#pending > 0 && (this.#running === 0 || running < this.#concurrency)) {
+        let queue                   = null
+
+        let idx = this.#queues.length - 1
+
+        // Avoid starvation by randomizing the starting queue.
+        {
+          this.#counter = (this.#counter + 1) & maxInt
+          if (this.#counter & 0b0000001) {
+            idx = 6 // highest: 50%
+          } else if (this.#counter & 0b0000010) {
+            idx = 5 // higher: 25%
+          } else if (this.#counter & 0b0000100) {
+            idx = 4 // high: 12.5%
+          } else if (this.#counter & 0b0001000) {
+            idx = 3 // normal: 6.25%
+          } else if (this.#counter & 0b0010000) {
+            idx = 2 // low: 3.125%
+          } else if (this.#counter & 0b0100000) {
+            idx = 1 // lower: 1.5625%
+          } else if (this.#counter & 0b1000000) {
+            idx = 0 // lowest: 0.78%
+          }
+        }
+
+        for (let n = idx; n >= 0 && (queue == null || queue.cnt === 0); n--) {
+          queue = this.#queues[n]
         }
 
-        if (this.#running > 0 && running >= queue.lim) {
-          break
+        for (let n = this.#queues.length - 1; n > idx && (queue == null || queue.cnt === 0); n--) {
+          queue = this.#queues[n]
         }
 
-        if ((this.#counter & 63) === 0 && this.#lowQueue.cnt > 0) {
-          queue = this.#lowQueue
-        } else if ((this.#counter & 15) === 0 && this.#normalQueue.cnt > 0) {
-          queue = this.#normalQueue
+        if (queue == null || queue.cnt === 0) {
+          throw new Error('Invariant violation: pending > 0 but no tasks in queues')
         }
 
         const fn = queue.arr[queue.idx++]
         const opaque = queue.arr[queue.idx++]
         queue.cnt -= 1
+        queue.age = fastNow
 
         if (queue.cnt === 0) {
           queue.idx = 0
           queue.arr.length = 0
         } else if (queue.idx > 1024) {
-          queue.arr.splice(0, queue.idx)
           queue.idx = 0
+          queue.arr.splice(0, queue.idx)
         }
 
         running = this.#stateView

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/scheduler",
-  "version": "2.0.4",
+  "version": "3.0.1",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -20,5 +20,5 @@
     "rimraf": "^6.1.2",
     "typescript": "^5.9.3"
   },
-  "gitHead": "aa8978d5b536477418eb6cc60255d4a36bb9d013"
+  "gitHead": "c88bafd0c4a7e250d9e4080d9f50a0a0a1a562ac"
 }