Commit 921a43b7556 for nodejs
commit 921a43b75560c62e98e1444351bc4fde58f95b2a
Author: James M Snell <jasnell@gmail.com>
Date: Wed Oct 7 04:02:16 2026 +0000
stream: read stream/iter from() async sources in one reaction
from() read an async source through yieldNormalizationAbortable(),
whose next() a cancellation can interrupt: for every batch it created a
promise with three closures, a reaction to the source's result, and an
iterator result, and the normalizer then took another reaction and
another iterator result. Only pipeTo() without a signal avoided this,
with kNextUncancellable.
Give yieldNormalizationAbortable() a read, kRead, that calls handlers
set once by the normalizer, so that it takes no closure, and handle the
source's result in the same reaction. The normalizer's pending read is
a promise of its own, which a cancellation rejects as before. A batch
passed on unchanged keeps the iterator result of the read.
For 16-byte chunks one per batch, iterating from() of an async
generator is 13-20% faster and allocates about 370 bytes less per
batch; piping one with a signal is 11-15% faster.
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/from.js b/lib/internal/streams/iter/from.js
index a926eb982bd..23b7021a649 100644
--- a/lib/internal/streams/iter/from.js
+++ b/lib/internal/streams/iter/from.js
@@ -154,6 +154,10 @@ const kNextUncancellable = Symbol('kNextUncancellable');
const kReadUncancellable = Symbol('kReadUncancellable');
const kToIterResult = Symbol('kToIterResult');
const kReadFailed = Symbol('kReadFailed');
+// A read of the source that a cancellation can interrupt, for
+// createAsyncSourceNormalizer(): see kRead in yieldNormalizationAbortable().
+const kSetReadHandlers = Symbol('kSetReadHandlers');
+const kRead = Symbol('kRead');
// The result kReadUncancellable gives once the source is done.
const kDoneSourceResult = ObjectFreeze({ __proto__: null, done: true, value: undefined });
@@ -516,6 +520,55 @@ function yieldNormalizationAbortable(source, context) {
}
}
+ // The handlers of kRead, set once by kSetReadHandlers, and whether a
+ // kRead is pending.
+ let onRead = null;
+ let onReadError = null;
+ let readPending = false;
+
+ // Fail a kRead, closing the source first if the normalization has
+ // been cancelled.
+ function failRead(error) {
+ if (context.cancelled) {
+ PromisePrototypeThen(closeSource(true), () => {
+ reading = false;
+ onReadError(error);
+ });
+ return;
+ }
+ reading = false;
+ onReadError(error);
+ }
+
+ // context.resolve while a kRead is pending.
+ function onReadCancelled() {
+ if (!readPending) return;
+ readPending = false;
+ context.resolve = null;
+ failRead(context.reason);
+ }
+
+ function onReadResult(result) {
+ if (!readPending) return;
+ readPending = false;
+ if (context.resolve === onReadCancelled) context.resolve = null;
+ let iterResult;
+ try {
+ iterResult = toIterResult(result);
+ } catch (error) {
+ failRead(error);
+ return;
+ }
+ onRead(iterResult);
+ }
+
+ function onReadRejected(error) {
+ if (!readPending) return;
+ readPending = false;
+ if (context.resolve === onReadCancelled) context.resolve = null;
+ failRead(error);
+ }
+
// Reject a pending next(), closing the source first if the
// normalization has been cancelled.
function rejectNext(reject, error) {
@@ -604,6 +657,38 @@ function yieldNormalizationAbortable(source, context) {
return PromiseResolve(next);
},
[kToIterResult]: onUncancellableResult,
+ // Like next(), calling the handlers set by kSetReadHandlers instead
+ // of settling a promise of its own: onRead with the result, or
+ // onReadError with the error, possibly synchronously. A cancellation
+ // calls onReadError with its reason. The handlers are the same for
+ // every read, so that a read takes no closure, and the caller can
+ // handle the result in the same reaction.
+ [kSetReadHandlers](resultHandler, errorHandler) {
+ onRead = resultHandler;
+ onReadError = errorHandler;
+ },
+ [kRead]() {
+ if (completed) {
+ onRead(new IterResult(true, undefined));
+ return;
+ }
+ if (context.cancelled) {
+ onReadError(context.reason);
+ return;
+ }
+ reading = true;
+ let next;
+ try {
+ next = FunctionPrototypeCall(nextMethod, iterator);
+ } catch (error) {
+ failRead(error);
+ return;
+ }
+ readPending = true;
+ context.resolve = onReadCancelled;
+ PromisePrototypeThen(PromiseResolve(next), onReadResult,
+ onReadRejected);
+ },
[kReadFailed]() {
reading = false;
},
@@ -799,6 +884,11 @@ function createAsyncSourceNormalizer(source, context) {
// kNextUncancellable method, for callers that never cancel the
// normalization while a read is pending.
let uncancellable = false;
+ // Whether the source is read with kRead, and the settling functions of
+ // the read's promise while it is pending.
+ let readable = false;
+ let resolveRead = null;
+ let rejectRead = null;
const { run, settled } = createOperationQueue();
function finish(result) {
@@ -832,16 +922,23 @@ function createAsyncSourceNormalizer(source, context) {
return finish(new IterResult(true, undefined));
}
try {
- return handleValue(result.value);
+ return handleValue(result.value, result);
} catch (error) {
return onBodyError(error);
}
}
- function handleValue(value) {
+ // `result` is the source's result for `value`. When the source is read
+ // with kRead or kReadUncancellable, it is an IterResult of
+ // yieldNormalizationAbortable(), passed on as it is for a batch passed on
+ // unchanged.
+ function handleValue(value, result) {
if (isUint8ArrayBatch(value)) {
if (value.length <= FROM_BATCH_SIZE) {
if (value.length === 0) return pullSource();
+ if (readable || uncancellable) {
+ return finish(result);
+ }
return finish(new IterResult(false, value));
}
boundedBatches = yieldBoundedBatch(value);
@@ -877,11 +974,44 @@ function createAsyncSourceNormalizer(source, context) {
return fail(error);
}
+ // The kRead handlers: the result is handled in the reaction to the
+ // source's result, and settles the read's promise.
+ function onRead(result) {
+ const resolve = resolveRead;
+ const reject = rejectRead;
+ resolveRead = rejectRead = null;
+ let settledWith;
+ try {
+ settledWith = onSourceResult(result);
+ } catch (error) {
+ reject(error);
+ return;
+ }
+ resolve(settledWith);
+ }
+
+ function onReadError(error) {
+ const reject = rejectRead;
+ resolveRead = rejectRead = null;
+ state = kDone;
+ settled();
+ reject(error);
+ }
+
function pullSource() {
if (uncancellable) {
return PromisePrototypeThen(iterator[kReadUncancellable](),
onUncancellableResult, onUncancellableError);
}
+ if (readable) {
+ // One promise for the read, which a cancellation rejects, instead of
+ // next()'s promise and a reaction to it.
+ const { promise, resolve, reject } = PromiseWithResolvers();
+ resolveRead = resolve;
+ rejectRead = reject;
+ iterator[kRead]();
+ return promise;
+ }
return PromisePrototypeThen(iterator.next(), onSourceResult, fail);
}
@@ -905,6 +1035,10 @@ function createAsyncSourceNormalizer(source, context) {
throwIfNormalizationCancelled(context);
const iterable = yieldNormalizationAbortable(source, context);
iterator = iterable[SymbolAsyncIterator]();
+ if (iterator[kSetReadHandlers] !== undefined) {
+ iterator[kSetReadHandlers](onRead, onReadError);
+ readable = true;
+ }
} catch (error) {
state = kDone;
settled();