lib: speed up AbortSignal

Speed up creating and aborting signals, adding and removing abort
listeners, AbortSignal.any() and AbortSignal.timeout(), and stop the
default abort reason from retaining the aborting caller.

- 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.
- Take positional arguments in AbortSignal's internal constructor
  instead of destructuring an options object that defaults to
  kEmptyObject. kEmptyObject is a null-prototype object, which V8 keeps
  in dictionary mode, so each of those reads was an uncached dictionary
  miss that cost more than the rest of the constructor.
- Create the default abort reason with Error.stackTraceLimit set to 0.
  Until a captured stack is formatted, V8 keeps the call sites, which
  retain the receivers and functions of the aborting caller's frames,
  so a retained signal kept the aborted work alive. Formatting the
  stack eagerly would fix that but costs several microseconds per
  abort(). The default AbortError no longer shows where abort() was
  called; callers that want that can pass their own reason.
- Add benchmarks for aborting, adding and removing abort listeners,
  and AbortSignal.any().

Refs: nodejs#66192
Refs: nodejs#66265
Assisted-by: claude:opus-5.5
Signed-off-by: Robert Nagy <ronagy@icloud.com>

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();
+}