Commit ddf5a06268f for nodejs

commit ddf5a06268f69bcb31ac16d87e32ed2c07a48a6a
Author: James M Snell <jasnell@gmail.com>
Date:   Wed Oct 7 14:51:48 2026 +0000

    stream: keep stream/iter broadcast waiters in reused lists

    Broadcast notified waiting consumers by swapping #waiters for a new
    SafeSet on every notification, so that a consumer re-waiting while being
    notified was not processed twice. That happens for every chunk that
    consumers wait for, and each Set operation allocates: the new Set, the
    for...of iterator, and clear() or deleting the last entries (120-150
    bytes each).

    The waiters are now kept in two RingBuffers that are swapped back and
    forth; the notified list is drained with shift() and cleared, keeping
    its storage. A nested notification while the spare list is in use gets a
    new one. A consumer detaching removes itself with indexOf()/removeAt(),
    as it did with delete(); it is in the list at most once, as before.

    Broadcast.from() fan-out, async source, two consumers, 16-byte chunks:
    2036 -> 1873 bytes allocated per chunk.

    Assisted-by: OpenCode
    Signed-off-by: James M Snell <jasnell@gmail.com>
    PR-URL: https://github.com/nodejs/node/pull/66504
    Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
    Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>

diff --git a/lib/internal/streams/iter/broadcast.js b/lib/internal/streams/iter/broadcast.js
index 3d15dc272bb..5aa21ef77f7 100644
--- a/lib/internal/streams/iter/broadcast.js
+++ b/lib/internal/streams/iter/broadcast.js
@@ -124,7 +124,12 @@ class BroadcastImpl {
   #buffer = new RingBuffer();
   #bufferStart = 0;
   #consumers = new SafeSet();
-  #waiters = new SafeSet();  // Consumers with pending resolve
+  // Consumers with a pending resolve, each at most once. A RingBuffer
+  // rather than a Set: adding, clearing and iterating a Set allocate, and
+  // this changes for every chunk that consumers wait for.
+  #waiters = new RingBuffer(4);
+  // The list #notifyConsumers() swaps in for #waiters (see there).
+  #spareWaiters = new RingBuffer(4);
   #ended = false;
   #error;
   #errored = false;
@@ -224,7 +229,7 @@ class BroadcastImpl {

     function detach() {
       state.detached = true;
-      self.#waiters.delete(state);
+      self.#deleteWaiter(state);
       if (state.resolve) {
         state.resolve(new IterResult(true, undefined));
       }
@@ -286,7 +291,7 @@ class BroadcastImpl {
             const reject = takeReject();
             state.resolve = resolve;
             state.reject = reject;
-            self.#waiters.add(state);
+            self.#waiters.push(state);
             return promise;
           },

@@ -526,11 +531,30 @@ class BroadcastImpl {

   #notifyConsumers() {
     const waiters = this.#waiters;
-    if (waiters.size === 0) return;
+    if (waiters.length === 0) return;
     // Swap out the waiters list so consumers that re-wait during
-    // resolve don't get processed twice in this cycle.
-    this.#waiters = new SafeSet();
-    for (const consumer of waiters) {
+    // resolve don't get processed twice in this cycle. This runs for every
+    // write that consumers are waiting for, so the two lists are swapped
+    // back and forth rather than a new one created each time; a nested
+    // call, while the spare list is in use, gets a new one.
+    this.#waiters = this.#spareWaiters ?? new RingBuffer(4);
+    this.#spareWaiters = null;
+    try {
+      this.#notifyWaiters(waiters);
+    } finally {
+      waiters.clear();
+      this.#spareWaiters = waiters;
+    }
+  }
+
+  #deleteWaiter(consumer) {
+    const index = this.#waiters.indexOf(consumer);
+    if (index !== -1) this.#waiters.removeAt(index);
+  }
+
+  #notifyWaiters(waiters) {
+    let consumer;
+    while ((consumer = waiters.shift()) !== undefined) {
       if (consumer.resolve) {
         const bufferIndex = consumer.cursor - this.#bufferStart;
         if (bufferIndex < this.#buffer.length) {
@@ -549,11 +573,11 @@ class BroadcastImpl {
           if (consumer.detached && this.#deleteConsumer(consumer)) {
             this.#tryTrimBuffer();
           } else if (this.#promotePending(consumer)) {
-            this.#waiters.add(consumer);
+            this.#waiters.push(consumer);
           }
         } else {
           // Still waiting -- put back
-          this.#waiters.add(consumer);
+          this.#waiters.push(consumer);
         }
       }
     }
diff --git a/test/parallel/test-stream-iter-broadcast-waiter-cleanup.js b/test/parallel/test-stream-iter-broadcast-waiter-cleanup.js
index 4e0f6dd4d47..3bb1c644324 100644
--- a/test/parallel/test-stream-iter-broadcast-waiter-cleanup.js
+++ b/test/parallel/test-stream-iter-broadcast-waiter-cleanup.js
@@ -31,4 +31,55 @@ async function testDetachedWaitersAreReleased() {
   shared.cancel();
 }

-testDetachedWaitersAreReleased().then(common.mustCall());
+// Consumers waiting for writes are notified once per write, across many
+// writes: some wait with one next() at a time, one queues several next()
+// calls, and one detaches while it is waiting. Every remaining consumer
+// gets every chunk, in order.
+async function testWaitersAcrossWrites() {
+  // A 4-byte budget, so that the writer also waits for the consumers.
+  const { writer, broadcast: shared } = broadcast({ budget: 4 });
+  const n = 200;
+  const readAll = async (iterator) => {
+    const seen = [];
+    for (;;) {
+      const { done, value } = await iterator.next();
+      if (done) return seen;
+      for (const chunk of value) seen.push(chunk[0]);
+    }
+  };
+  const readQueued = async (iterator) => {
+    const seen = [];
+    for (;;) {
+      const results = await Promise.all(
+        [iterator.next(), iterator.next(), iterator.next()]);
+      for (const { done, value } of results) {
+        if (done) return seen;
+        for (const chunk of value) seen.push(chunk[0]);
+      }
+    }
+  };
+  const a = readAll(shared.push()[Symbol.asyncIterator]());
+  const b = readAll(shared.push()[Symbol.asyncIterator]());
+  const c = readQueued(shared.push()[Symbol.asyncIterator]());
+  for (let i = 0; i < n; i++) {
+    if (i === n / 2) {
+      // Joins at the current position, waits, and detaches while waiting.
+      const detaching = shared.push()[Symbol.asyncIterator]();
+      const pending = detaching.next();
+      await detaching.return();
+      await pending;
+    }
+    await writer.write(new Uint8Array([i % 256]));
+    if (i % 7 === 0) await new Promise(setImmediate);
+  }
+  await writer.end();
+  const expected = Array.from({ length: n }, (_, i) => i % 256);
+  assert.deepStrictEqual(await a, expected);
+  assert.deepStrictEqual(await b, expected);
+  assert.deepStrictEqual(await c, expected);
+  assert.strictEqual(shared.consumerCount, 0);
+}
+
+testDetachedWaitersAreReleased()
+  .then(testWaitersAcrossWrites)
+  .then(common.mustCall());