lib: speed up AbortSignal

Speed up aborting, adding and removing abort listeners,
AbortSignal.any() and AbortSignal.timeout().

- Only allocate and dispatch the abort event when the signal has abort
  listeners, and only allocate the dependent signal list when there
  are dependent signals.
- Track whether an event is trusted with a private field instead of a
  WeakSet.
- Flatten addEventListener() options into locals instead of
  allocating a normalized options object, only validate the signal
  option when one is passed, and use the listener flags directly.
- Call the EventTarget kNewListener and kRemoveListener
  implementations directly. V8 does not optimize keyed super property
  access such as super[kNewListener]().
- Initialize the internal slots that AbortSignal.any() adds to its
  sources up front, and the composite-only slots for composites, so
  live signals don't change shape.
- Give every signal a single WeakRef that is shared by all the
  composites that follow it, and register each composite and each
  source once with their cleanup registries instead of registering
  every (source, composite) pair with an unregister token. Registering
  with an unregister token is several times more expensive.
- Register AbortSignal.timeout() timers through a holder that is
  emptied when the timer fires, instead of using the signal as an
  unregister token.
- Add benchmarks for aborting, adding and removing abort listeners,
  and AbortSignal.any().

Assisted-by: claude:opus-5.5

Author: ronag

benchmark/abort_controller/abort-controller-abort.js

@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  n: [1e6],
+  listeners: [0, 1],
+});
+
+function main({ n, listeners }) {
+  const reason = new Error('reason');
+  const noop = () => {};
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    const ac = new AbortController();
+    if (listeners > 0)
+      ac.signal.addEventListener('abort', noop);
+    ac.abort(reason);
+  }
+  bench.end(n);
+}

benchmark/abort_controller/abort-signal-add-remove.js

@@ -0,0 +1,43 @@
+'use strict';
+const common = require('../common.js');
+const { addAbortListener } = require('events');
+
+const bench = common.createBenchmark(main, {
+  n: [1e6],
+  kind: ['addEventListener', 'addEventListener-once', 'addAbortListener'],
+});
+
+function main({ n, kind }) {
+  const { signal } = new AbortController();
+  const noop = () => {};
+
+  switch (kind) {
+    case 'addEventListener':
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        signal.addEventListener('abort', noop);
+        signal.removeEventListener('abort', noop);
+      }
+      bench.end(n);
+      break;
+    case 'addEventListener-once': {
+      const options = { once: true };
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        signal.addEventListener('abort', noop, options);
+        signal.removeEventListener('abort', noop);
+      }
+      bench.end(n);
+      break;
+    }
+    case 'addAbortListener':
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        addAbortListener(signal, noop)[Symbol.dispose]();
+      }
+      bench.end(n);
+      break;
+    default:
+      throw new Error('Invalid kind');
+  }
+}

benchmark/abort_controller/abort-signal-any.js

@@ -0,0 +1,46 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  n: [2e5],
+  kind: ['create', 'listen', 'abort'],
+});
+
+// Combines a per-iteration signal with a long-lived one, like a request
+// signal combined with a server wide one. The work is split into batches
+// that run in separate macrotasks because WeakRef targets are kept alive
+// until the end of the current job, as they would be between requests.
+function main({ n, kind }) {
+  const reason = new Error('reason');
+  const noop = () => {};
+  const longLived = new AbortController().signal;
+  const batch = 1000;
+
+  function run(count) {
+    for (let i = 0; i < count; i++) {
+      const ac = new AbortController();
+      const signal = AbortSignal.any([ac.signal, longLived]);
+      if (kind === 'create')
+        continue;
+      signal.addEventListener('abort', noop, { once: true });
+      if (kind === 'listen')
+        signal.removeEventListener('abort', noop);
+      else
+        ac.abort(reason);
+    }
+  }
+
+  let left = n;
+  function step() {
+    const count = Math.min(batch, left);
+    run(count);
+    left -= count;
+    if (left > 0)
+      setImmediate(step);
+    else
+      bench.end(n);
+  }
+
+  bench.start();
+  step();
+}