superlock 1.4.2 → 1.4.3

package/package.json

@@ -2,7 +2,7 @@
   "name": "superlock",
   "description": "Minimal async mutex and semaphore for serializing critical sections in Node.js.",
   "homepage": "https://github.com/Kikobeats/superlock",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "types": "src/index.d.ts",
   "main": "src/index.js",
   "exports": {

package/src/fair.js

@@ -5,11 +5,16 @@ const LinkedList = require('./linked-list')
 const SHARED = Symbol('shared')
 const NONE = Symbol('none')
 
+// Map keys use SameValueZero, so NaN is one key and === cannot find it.
+const sameKey = (a, b) => a === b || (Number.isNaN(a) && Number.isNaN(b))
+
 module.exports = (slots = 1) => {
   const queues = new Map()
   const ring = new LinkedList()
   let waiting = 0
   let last = NONE
+  let seq = 0
+  let barrier = 0
 
   const drop = entry => {
     const predecessor = entry.ringNode.prev
@@ -21,19 +26,48 @@ module.exports = (slots = 1) => {
   const enqueue = (key, waiter) => {
     let entry = queues.get(key)
     if (!entry) {
-      entry = { key, queue: new LinkedList(), ringNode: ring.enqueue(key) }
+      // The holder is the cursor and is not on the ring yet. Put that key
+      // at the head so the next grant starts on the keys already waiting
+      // and reaches the holder last. At the tail, the cursor would step
+      // into keys that arrive later and skip the ones already in front.
+      const ringNode = sameKey(key, last)
+        ? ring.prepend(key)
+        : ring.enqueue(key)
+      entry = { key, queue: new LinkedList(), ringNode }
       queues.set(key, entry)
     }
     waiting++
     waiter.entry = entry
+    waiter.joinSeq = ++seq
     waiter.node = entry.queue.enqueue(waiter)
   }
 
-  const grant = () => {
-    if (ring.size() === 0) return
+  // The key's oldest waiter decides. A later waiter on a key that joined
+  // this round has a newer sequence and must not inherit the round.
+  const eligible = entry => entry.queue.head.data.joinSeq <= barrier
+
+  // Start just after the cursor and wrap once. Stop is required: the
+  // ring is not circular, so the walk jumps from the tail back to the head.
+  const selectNode = () => {
     const current = queues.get(last)
-    const node =
+    const start =
       current && current.ringNode.next ? current.ringNode.next : ring.head
+    let node = start
+    do {
+      if (eligible(queues.get(node.data))) return node
+      node = node.next || ring.head
+    } while (node !== start)
+  }
+
+  const grant = () => {
+    if (ring.size() === 0) return
+    // Waiters past the barrier stay out until every earlier waiter has
+    // been served. When none of those remain, move the barrier up.
+    let node = selectNode()
+    if (!node) {
+      barrier = seq
+      node = selectNode()
+    }
     const entry = queues.get(node.data)
     const waiter = entry.queue.dequeue()
     waiting--

package/src/linked-list.js

@@ -21,6 +21,16 @@ module.exports = class LinkedList {
     return node
   }
 
+  prepend (data) {
+    const node = new Node(data)
+    node.next = this.head
+    if (this.head) this.head.prev = node
+    else this.tail = node
+    this.head = node
+    this.length++
+    return node
+  }
+
   dequeue () {
     if (!this.head) return
     const { data } = this.head