stream: hoist repeated loads in readable paths

fromList() re-read state.length and each chunk's length several times
per call and re-loaded buffer[idx] around every copy, and read() loaded
state.length three times in its read(0) check; the engine cannot fold
these loads across the intervening copy and slice calls. Cache them in
locals instead. Ported from Bun's fork of the same functions
(src/js/internal/streams/readable.ts fromList/read), which carries
these hoists on top of the shared readable-stream lineage.
benchmark/compare.js against the unmodified baseline (60-run capture
plus an independent 30-run repeat, Welch t-test):
streams/readable-unevenread +0.65% (p=4.3e-4) / +0.59% (p=5.9e-3) and
streams/pipe.js +0.74% (p=2.0e-4) / +0.52% (p=8.8e-3), with no
significant regression across the captured streams benchmarks.
Refs: https://github.com/oven-sh/bun/blob/main/src/js/internal/streams/readable.ts
Signed-off-by: Yagiz Nizipli <yagiz@nizipli.com>
Assisted-by: Grok (Grok Build)
PR-URL: #64312
Reviewed-By: Robert Nagy <ronagy@icloud.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: anonrig

lib/internal/streams/readable.js

@@ -673,15 +673,17 @@ Readable.prototype.read = function(n) {
 
 // If we're doing read(0) to trigger a readable event, but we
 // already have a bunch of data in the buffer, then just trigger
-// the 'readable' event and move on.
+// the 'readable' event and move on. `state.length` cannot change
+// within this block, so it is loaded once instead of three times.
+conststateLength=state.length;
 if(n===0&&
 (state[kState]&kNeedReadable)!==0&&
 ((state.highWaterMark!==0 ?
-state.length>=state.highWaterMark :
-state.length>0)||
+stateLength>=state.highWaterMark :
+stateLength>0)||
 (state[kState]&kEnded)!==0)){
 debug('read: emitReadable');
-if(state.length===0&&(state[kState]&kEnded)!==0)
+if(stateLength===0&&(state[kState]&kEnded)!==0)
 endReadable(this);
 else
 emitReadable(this);
@@ -1624,8 +1626,14 @@ Readable._fromList = fromList;
 // This function is designed to be inlinable, so please take care when making
 // changes to the function body.
 functionfromList(n,state){
+// `state.length` cannot change while this function runs (only the
+// caller updates it, after this returns) and the chunk lengths feeding
+// the copy loops cannot change across the copy calls, so every
+// repeated property load below is hoisted into a local.
+conststateLength=state.length;
+
 // nothing buffered.
-if(state.length===0)
+if(stateLength===0)
 returnnull;
 
 letidx=state.bufferIndex;
@@ -1637,7 +1645,7 @@ function fromList(n, state) {
 if((state[kState]&kObjectMode)!==0){
 ret=buf[idx];
 buf[idx++]=null;
-}elseif(!n||n>=state.length){
+}elseif(!n||n>=stateLength){
 // Read it all, truncate the list.
 if((state[kState]&kDecoder)!==0){
 ret='';
@@ -1651,61 +1659,68 @@ function fromList(n, state) {
 ret=buf[idx];
 buf[idx++]=null;
 }else{
-ret=Buffer.allocUnsafe(state.length);
+ret=Buffer.allocUnsafe(stateLength);
 
 leti=0;
 while(idx<len){
-TypedArrayPrototypeSet(ret,buf[idx],i);
-i+=buf[idx].length;
+constdata=buf[idx];
+TypedArrayPrototypeSet(ret,data,i);
+i+=data.length;
 buf[idx++]=null;
 }
 }
-}elseif(n<buf[idx].length){
-// `slice` is the same for buffers and strings.
-ret=buf[idx].slice(0,n);
-buf[idx]=buf[idx].slice(n);
-}elseif(n===buf[idx].length){
-// First chunk is a perfect match.
-ret=buf[idx];
-buf[idx++]=null;
-}elseif((state[kState]&kDecoder)!==0){
-ret='';
-while(idx<len){
-conststr=buf[idx];
-if(n>str.length){
-ret+=str;
-n-=str.length;
-buf[idx++]=null;
-}else{
-if(n===str.length){
+}else{
+constfirst=buf[idx];
+constfirstLength=first.length;
+if(n<firstLength){
+// `slice` is the same for buffers and strings.
+ret=first.slice(0,n);
+buf[idx]=first.slice(n);
+}elseif(n===firstLength){
+// First chunk is a perfect match.
+ret=first;
+buf[idx++]=null;
+}elseif((state[kState]&kDecoder)!==0){
+ret='';
+while(idx<len){
+conststr=buf[idx];
+conststrLength=str.length;
+if(n>strLength){
 ret+=str;
+n-=strLength;
 buf[idx++]=null;
 }else{
-ret+=str.slice(0,n);
-buf[idx]=str.slice(n);
+if(n===strLength){
+ret+=str;
+buf[idx++]=null;
+}else{
+ret+=str.slice(0,n);
+buf[idx]=str.slice(n);
+}
+break;
 }
-break;
 }
-}
-}else{
-ret=Buffer.allocUnsafe(n);
-
-constretLen=n;
-while(idx<len){
-constdata=buf[idx];
-if(n>data.length){
-TypedArrayPrototypeSet(ret,data,retLen-n);
-n-=data.length;
-buf[idx++]=null;
-}else{
-if(n===data.length){
+}else{
+ret=Buffer.allocUnsafe(n);
+
+constretLen=n;
+while(idx<len){
+constdata=buf[idx];
+constdataLength=data.length;
+if(n>dataLength){
 TypedArrayPrototypeSet(ret,data,retLen-n);
+n-=dataLength;
 buf[idx++]=null;
 }else{
-TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
-buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,data.length-n);
+if(n===dataLength){
+TypedArrayPrototypeSet(ret,data,retLen-n);
+buf[idx++]=null;
+}else{
+TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
+buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,dataLength-n);
+}
+break;
 }
-break;
 }
 }
 }

lib/internal/streams/readable.js

@@ -673,15 +673,17 @@ Readable.prototype.read = function(n) {
 
 // If we're doing read(0) to trigger a readable event, but we
 // already have a bunch of data in the buffer, then just trigger
-// the 'readable' event and move on.
+// the 'readable' event and move on. `state.length` cannot change
+// within this block, so it is loaded once instead of three times.
+conststateLength=state.length;
 if(n===0&&
 (state[kState]&kNeedReadable)!==0&&
 ((state.highWaterMark!==0 ?
-state.length>=state.highWaterMark :
-state.length>0)||
+stateLength>=state.highWaterMark :
+stateLength>0)||
 (state[kState]&kEnded)!==0)){
 debug('read: emitReadable');
-if(state.length===0&&(state[kState]&kEnded)!==0)
+if(stateLength===0&&(state[kState]&kEnded)!==0)
 endReadable(this);
 else
 emitReadable(this);
@@ -1624,8 +1626,14 @@ Readable._fromList = fromList;
 // This function is designed to be inlinable, so please take care when making
 // changes to the function body.
 functionfromList(n,state){
+// `state.length` cannot change while this function runs (only the
+// caller updates it, after this returns) and the chunk lengths feeding
+// the copy loops cannot change across the copy calls, so every
+// repeated property load below is hoisted into a local.
+conststateLength=state.length;
+
 // nothing buffered.
-if(state.length===0)
+if(stateLength===0)
 returnnull;
 
 letidx=state.bufferIndex;
@@ -1637,7 +1645,7 @@ function fromList(n, state) {
 if((state[kState]&kObjectMode)!==0){
 ret=buf[idx];
 buf[idx++]=null;
-}elseif(!n||n>=state.length){
+}elseif(!n||n>=stateLength){
 // Read it all, truncate the list.
 if((state[kState]&kDecoder)!==0){
 ret='';
@@ -1651,61 +1659,68 @@ function fromList(n, state) {
 ret=buf[idx];
 buf[idx++]=null;
 }else{
-ret=Buffer.allocUnsafe(state.length);
+ret=Buffer.allocUnsafe(stateLength);
 
 leti=0;
 while(idx<len){
-TypedArrayPrototypeSet(ret,buf[idx],i);
-i+=buf[idx].length;
+constdata=buf[idx];
+TypedArrayPrototypeSet(ret,data,i);
+i+=data.length;
 buf[idx++]=null;
 }
 }
-}elseif(n<buf[idx].length){
-// `slice` is the same for buffers and strings.
-ret=buf[idx].slice(0,n);
-buf[idx]=buf[idx].slice(n);
-}elseif(n===buf[idx].length){
-// First chunk is a perfect match.
-ret=buf[idx];
-buf[idx++]=null;
-}elseif((state[kState]&kDecoder)!==0){
-ret='';
-while(idx<len){
-conststr=buf[idx];
-if(n>str.length){
-ret+=str;
-n-=str.length;
-buf[idx++]=null;
-}else{
-if(n===str.length){
+}else{
+constfirst=buf[idx];
+constfirstLength=first.length;
+if(n<firstLength){
+// `slice` is the same for buffers and strings.
+ret=first.slice(0,n);
+buf[idx]=first.slice(n);
+}elseif(n===firstLength){
+// First chunk is a perfect match.
+ret=first;
+buf[idx++]=null;
+}elseif((state[kState]&kDecoder)!==0){
+ret='';
+while(idx<len){
+conststr=buf[idx];
+conststrLength=str.length;
+if(n>strLength){
 ret+=str;
+n-=strLength;
 buf[idx++]=null;
 }else{
-ret+=str.slice(0,n);
-buf[idx]=str.slice(n);
+if(n===strLength){
+ret+=str;
+buf[idx++]=null;
+}else{
+ret+=str.slice(0,n);
+buf[idx]=str.slice(n);
+}
+break;
 }
-break;
 }
-}
-}else{
-ret=Buffer.allocUnsafe(n);
-
-constretLen=n;
-while(idx<len){
-constdata=buf[idx];
-if(n>data.length){
-TypedArrayPrototypeSet(ret,data,retLen-n);
-n-=data.length;
-buf[idx++]=null;
-}else{
-if(n===data.length){
+}else{
+ret=Buffer.allocUnsafe(n);
+
+constretLen=n;
+while(idx<len){
+constdata=buf[idx];
+constdataLength=data.length;
+if(n>dataLength){
 TypedArrayPrototypeSet(ret,data,retLen-n);
+n-=dataLength;
 buf[idx++]=null;
 }else{
-TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
-buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,data.length-n);
+if(n===dataLength){
+TypedArrayPrototypeSet(ret,data,retLen-n);
+buf[idx++]=null;
+}else{
+TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
+buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,dataLength-n);
+}
+break;
 }
-break;
 }
 }
 }

lib/internal/streams/readable.js

@@ -673,15 +673,17 @@ Readable.prototype.read = function(n) {
 
 // If we're doing read(0) to trigger a readable event, but we
 // already have a bunch of data in the buffer, then just trigger
-// the 'readable' event and move on.
+// the 'readable' event and move on. `state.length` cannot change
+// within this block, so it is loaded once instead of three times.
+conststateLength=state.length;
 if(n===0&&
 (state[kState]&kNeedReadable)!==0&&
 ((state.highWaterMark!==0 ?
-state.length>=state.highWaterMark :
-state.length>0)||
+stateLength>=state.highWaterMark :
+stateLength>0)||
 (state[kState]&kEnded)!==0)){
 debug('read: emitReadable');
-if(state.length===0&&(state[kState]&kEnded)!==0)
+if(stateLength===0&&(state[kState]&kEnded)!==0)
 endReadable(this);
 else
 emitReadable(this);
@@ -1624,8 +1626,14 @@ Readable._fromList = fromList;
 // This function is designed to be inlinable, so please take care when making
 // changes to the function body.
 functionfromList(n,state){
+// `state.length` cannot change while this function runs (only the
+// caller updates it, after this returns) and the chunk lengths feeding
+// the copy loops cannot change across the copy calls, so every
+// repeated property load below is hoisted into a local.
+conststateLength=state.length;
+
 // nothing buffered.
-if(state.length===0)
+if(stateLength===0)
 returnnull;
 
 letidx=state.bufferIndex;
@@ -1637,7 +1645,7 @@ function fromList(n, state) {
 if((state[kState]&kObjectMode)!==0){
 ret=buf[idx];
 buf[idx++]=null;
-}elseif(!n||n>=state.length){
+}elseif(!n||n>=stateLength){
 // Read it all, truncate the list.
 if((state[kState]&kDecoder)!==0){
 ret='';
@@ -1651,61 +1659,68 @@ function fromList(n, state) {
 ret=buf[idx];
 buf[idx++]=null;
 }else{
-ret=Buffer.allocUnsafe(state.length);
+ret=Buffer.allocUnsafe(stateLength);
 
 leti=0;
 while(idx<len){
-TypedArrayPrototypeSet(ret,buf[idx],i);
-i+=buf[idx].length;
+constdata=buf[idx];
+TypedArrayPrototypeSet(ret,data,i);
+i+=data.length;
 buf[idx++]=null;
 }
 }
-}elseif(n<buf[idx].length){
-// `slice` is the same for buffers and strings.
-ret=buf[idx].slice(0,n);
-buf[idx]=buf[idx].slice(n);
-}elseif(n===buf[idx].length){
-// First chunk is a perfect match.
-ret=buf[idx];
-buf[idx++]=null;
-}elseif((state[kState]&kDecoder)!==0){
-ret='';
-while(idx<len){
-conststr=buf[idx];
-if(n>str.length){
-ret+=str;
-n-=str.length;
-buf[idx++]=null;
-}else{
-if(n===str.length){
+}else{
+constfirst=buf[idx];
+constfirstLength=first.length;
+if(n<firstLength){
+// `slice` is the same for buffers and strings.
+ret=first.slice(0,n);
+buf[idx]=first.slice(n);
+}elseif(n===firstLength){
+// First chunk is a perfect match.
+ret=first;
+buf[idx++]=null;
+}elseif((state[kState]&kDecoder)!==0){
+ret='';
+while(idx<len){
+conststr=buf[idx];
+conststrLength=str.length;
+if(n>strLength){
 ret+=str;
+n-=strLength;
 buf[idx++]=null;
 }else{
-ret+=str.slice(0,n);
-buf[idx]=str.slice(n);
+if(n===strLength){
+ret+=str;
+buf[idx++]=null;
+}else{
+ret+=str.slice(0,n);
+buf[idx]=str.slice(n);
+}
+break;
 }
-break;
 }
-}
-}else{
-ret=Buffer.allocUnsafe(n);
-
-constretLen=n;
-while(idx<len){
-constdata=buf[idx];
-if(n>data.length){
-TypedArrayPrototypeSet(ret,data,retLen-n);
-n-=data.length;
-buf[idx++]=null;
-}else{
-if(n===data.length){
+}else{
+ret=Buffer.allocUnsafe(n);
+
+constretLen=n;
+while(idx<len){
+constdata=buf[idx];
+constdataLength=data.length;
+if(n>dataLength){
 TypedArrayPrototypeSet(ret,data,retLen-n);
+n-=dataLength;
 buf[idx++]=null;
 }else{
-TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
-buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,data.length-n);
+if(n===dataLength){
+TypedArrayPrototypeSet(ret,data,retLen-n);
+buf[idx++]=null;
+}else{
+TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
+buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,dataLength-n);
+}
+break;
 }
-break;
 }
 }
 }

lib/internal/streams/readable.js

@@ -673,15 +673,17 @@ Readable.prototype.read = function(n) {
 
 // If we're doing read(0) to trigger a readable event, but we
 // already have a bunch of data in the buffer, then just trigger
-// the 'readable' event and move on.
+// the 'readable' event and move on. `state.length` cannot change
+// within this block, so it is loaded once instead of three times.
+conststateLength=state.length;
 if(n===0&&
 (state[kState]&kNeedReadable)!==0&&
 ((state.highWaterMark!==0 ?
-state.length>=state.highWaterMark :
-state.length>0)||
+stateLength>=state.highWaterMark :
+stateLength>0)||
 (state[kState]&kEnded)!==0)){
 debug('read: emitReadable');
-if(state.length===0&&(state[kState]&kEnded)!==0)
+if(stateLength===0&&(state[kState]&kEnded)!==0)
 endReadable(this);
 else
 emitReadable(this);
@@ -1624,8 +1626,14 @@ Readable._fromList = fromList;
 // This function is designed to be inlinable, so please take care when making
 // changes to the function body.
 functionfromList(n,state){
+// `state.length` cannot change while this function runs (only the
+// caller updates it, after this returns) and the chunk lengths feeding
+// the copy loops cannot change across the copy calls, so every
+// repeated property load below is hoisted into a local.
+conststateLength=state.length;
+
 // nothing buffered.
-if(state.length===0)
+if(stateLength===0)
 returnnull;
 
 letidx=state.bufferIndex;
@@ -1637,7 +1645,7 @@ function fromList(n, state) {
 if((state[kState]&kObjectMode)!==0){
 ret=buf[idx];
 buf[idx++]=null;
-}elseif(!n||n>=state.length){
+}elseif(!n||n>=stateLength){
 // Read it all, truncate the list.
 if((state[kState]&kDecoder)!==0){
 ret='';
@@ -1651,61 +1659,68 @@ function fromList(n, state) {
 ret=buf[idx];
 buf[idx++]=null;
 }else{
-ret=Buffer.allocUnsafe(state.length);
+ret=Buffer.allocUnsafe(stateLength);
 
 leti=0;
 while(idx<len){
-TypedArrayPrototypeSet(ret,buf[idx],i);
-i+=buf[idx].length;
+constdata=buf[idx];
+TypedArrayPrototypeSet(ret,data,i);
+i+=data.length;
 buf[idx++]=null;
 }
 }
-}elseif(n<buf[idx].length){
-// `slice` is the same for buffers and strings.
-ret=buf[idx].slice(0,n);
-buf[idx]=buf[idx].slice(n);
-}elseif(n===buf[idx].length){
-// First chunk is a perfect match.
-ret=buf[idx];
-buf[idx++]=null;
-}elseif((state[kState]&kDecoder)!==0){
-ret='';
-while(idx<len){
-conststr=buf[idx];
-if(n>str.length){
-ret+=str;
-n-=str.length;
-buf[idx++]=null;
-}else{
-if(n===str.length){
+}else{
+constfirst=buf[idx];
+constfirstLength=first.length;
+if(n<firstLength){
+// `slice` is the same for buffers and strings.
+ret=first.slice(0,n);
+buf[idx]=first.slice(n);
+}elseif(n===firstLength){
+// First chunk is a perfect match.
+ret=first;
+buf[idx++]=null;
+}elseif((state[kState]&kDecoder)!==0){
+ret='';
+while(idx<len){
+conststr=buf[idx];
+conststrLength=str.length;
+if(n>strLength){
 ret+=str;
+n-=strLength;
 buf[idx++]=null;
 }else{
-ret+=str.slice(0,n);
-buf[idx]=str.slice(n);
+if(n===strLength){
+ret+=str;
+buf[idx++]=null;
+}else{
+ret+=str.slice(0,n);
+buf[idx]=str.slice(n);
+}
+break;
 }
-break;
 }
-}
-}else{
-ret=Buffer.allocUnsafe(n);
-
-constretLen=n;
-while(idx<len){
-constdata=buf[idx];
-if(n>data.length){
-TypedArrayPrototypeSet(ret,data,retLen-n);
-n-=data.length;
-buf[idx++]=null;
-}else{
-if(n===data.length){
+}else{
+ret=Buffer.allocUnsafe(n);
+
+constretLen=n;
+while(idx<len){
+constdata=buf[idx];
+constdataLength=data.length;
+if(n>dataLength){
 TypedArrayPrototypeSet(ret,data,retLen-n);
+n-=dataLength;
 buf[idx++]=null;
 }else{
-TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
-buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,data.length-n);
+if(n===dataLength){
+TypedArrayPrototypeSet(ret,data,retLen-n);
+buf[idx++]=null;
+}else{
+TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
+buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,dataLength-n);
+}
+break;
 }
-break;
 }
 }
 }

lib/internal/streams/readable.js

@@ -673,15 +673,17 @@ Readable.prototype.read = function(n) {
 
 // If we're doing read(0) to trigger a readable event, but we
 // already have a bunch of data in the buffer, then just trigger
-// the 'readable' event and move on.
+// the 'readable' event and move on. `state.length` cannot change
+// within this block, so it is loaded once instead of three times.
+conststateLength=state.length;
 if(n===0&&
 (state[kState]&kNeedReadable)!==0&&
 ((state.highWaterMark!==0 ?
-state.length>=state.highWaterMark :
-state.length>0)||
+stateLength>=state.highWaterMark :
+stateLength>0)||
 (state[kState]&kEnded)!==0)){
 debug('read: emitReadable');
-if(state.length===0&&(state[kState]&kEnded)!==0)
+if(stateLength===0&&(state[kState]&kEnded)!==0)
 endReadable(this);
 else
 emitReadable(this);
@@ -1624,8 +1626,14 @@ Readable._fromList = fromList;
 // This function is designed to be inlinable, so please take care when making
 // changes to the function body.
 functionfromList(n,state){
+// `state.length` cannot change while this function runs (only the
+// caller updates it, after this returns) and the chunk lengths feeding
+// the copy loops cannot change across the copy calls, so every
+// repeated property load below is hoisted into a local.
+conststateLength=state.length;
+
 // nothing buffered.
-if(state.length===0)
+if(stateLength===0)
 returnnull;
 
 letidx=state.bufferIndex;
@@ -1637,7 +1645,7 @@ function fromList(n, state) {
 if((state[kState]&kObjectMode)!==0){
 ret=buf[idx];
 buf[idx++]=null;
-}elseif(!n||n>=state.length){
+}elseif(!n||n>=stateLength){
 // Read it all, truncate the list.
 if((state[kState]&kDecoder)!==0){
 ret='';
@@ -1651,61 +1659,68 @@ function fromList(n, state) {
 ret=buf[idx];
 buf[idx++]=null;
 }else{
-ret=Buffer.allocUnsafe(state.length);
+ret=Buffer.allocUnsafe(stateLength);
 
 leti=0;
 while(idx<len){
-TypedArrayPrototypeSet(ret,buf[idx],i);
-i+=buf[idx].length;
+constdata=buf[idx];
+TypedArrayPrototypeSet(ret,data,i);
+i+=data.length;
 buf[idx++]=null;
 }
 }
-}elseif(n<buf[idx].length){
-// `slice` is the same for buffers and strings.
-ret=buf[idx].slice(0,n);
-buf[idx]=buf[idx].slice(n);
-}elseif(n===buf[idx].length){
-// First chunk is a perfect match.
-ret=buf[idx];
-buf[idx++]=null;
-}elseif((state[kState]&kDecoder)!==0){
-ret='';
-while(idx<len){
-conststr=buf[idx];
-if(n>str.length){
-ret+=str;
-n-=str.length;
-buf[idx++]=null;
-}else{
-if(n===str.length){
+}else{
+constfirst=buf[idx];
+constfirstLength=first.length;
+if(n<firstLength){
+// `slice` is the same for buffers and strings.
+ret=first.slice(0,n);
+buf[idx]=first.slice(n);
+}elseif(n===firstLength){
+// First chunk is a perfect match.
+ret=first;
+buf[idx++]=null;
+}elseif((state[kState]&kDecoder)!==0){
+ret='';
+while(idx<len){
+conststr=buf[idx];
+conststrLength=str.length;
+if(n>strLength){
 ret+=str;
+n-=strLength;
 buf[idx++]=null;
 }else{
-ret+=str.slice(0,n);
-buf[idx]=str.slice(n);
+if(n===strLength){
+ret+=str;
+buf[idx++]=null;
+}else{
+ret+=str.slice(0,n);
+buf[idx]=str.slice(n);
+}
+break;
 }
-break;
 }
-}
-}else{
-ret=Buffer.allocUnsafe(n);
-
-constretLen=n;
-while(idx<len){
-constdata=buf[idx];
-if(n>data.length){
-TypedArrayPrototypeSet(ret,data,retLen-n);
-n-=data.length;
-buf[idx++]=null;
-}else{
-if(n===data.length){
+}else{
+ret=Buffer.allocUnsafe(n);
+
+constretLen=n;
+while(idx<len){
+constdata=buf[idx];
+constdataLength=data.length;
+if(n>dataLength){
 TypedArrayPrototypeSet(ret,data,retLen-n);
+n-=dataLength;
 buf[idx++]=null;
 }else{
-TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
-buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,data.length-n);
+if(n===dataLength){
+TypedArrayPrototypeSet(ret,data,retLen-n);
+buf[idx++]=null;
+}else{
+TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
+buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,dataLength-n);
+}
+break;
 }
-break;
 }
 }
 }

lib/internal/streams/readable.js

@@ -673,15 +673,17 @@ Readable.prototype.read = function(n) {
 
 // If we're doing read(0) to trigger a readable event, but we
 // already have a bunch of data in the buffer, then just trigger
-// the 'readable' event and move on.
+// the 'readable' event and move on. `state.length` cannot change
+// within this block, so it is loaded once instead of three times.
+conststateLength=state.length;
 if(n===0&&
 (state[kState]&kNeedReadable)!==0&&
 ((state.highWaterMark!==0 ?
-state.length>=state.highWaterMark :
-state.length>0)||
+stateLength>=state.highWaterMark :
+stateLength>0)||
 (state[kState]&kEnded)!==0)){
 debug('read: emitReadable');
-if(state.length===0&&(state[kState]&kEnded)!==0)
+if(stateLength===0&&(state[kState]&kEnded)!==0)
 endReadable(this);
 else
 emitReadable(this);
@@ -1624,8 +1626,14 @@ Readable._fromList = fromList;
 // This function is designed to be inlinable, so please take care when making
 // changes to the function body.
 functionfromList(n,state){
+// `state.length` cannot change while this function runs (only the
+// caller updates it, after this returns) and the chunk lengths feeding
+// the copy loops cannot change across the copy calls, so every
+// repeated property load below is hoisted into a local.
+conststateLength=state.length;
+
 // nothing buffered.
-if(state.length===0)
+if(stateLength===0)
 returnnull;
 
 letidx=state.bufferIndex;
@@ -1637,7 +1645,7 @@ function fromList(n, state) {
 if((state[kState]&kObjectMode)!==0){
 ret=buf[idx];
 buf[idx++]=null;
-}elseif(!n||n>=state.length){
+}elseif(!n||n>=stateLength){
 // Read it all, truncate the list.
 if((state[kState]&kDecoder)!==0){
 ret='';
@@ -1651,61 +1659,68 @@ function fromList(n, state) {
 ret=buf[idx];
 buf[idx++]=null;
 }else{
-ret=Buffer.allocUnsafe(state.length);
+ret=Buffer.allocUnsafe(stateLength);
 
 leti=0;
 while(idx<len){
-TypedArrayPrototypeSet(ret,buf[idx],i);
-i+=buf[idx].length;
+constdata=buf[idx];
+TypedArrayPrototypeSet(ret,data,i);
+i+=data.length;
 buf[idx++]=null;
 }
 }
-}elseif(n<buf[idx].length){
-// `slice` is the same for buffers and strings.
-ret=buf[idx].slice(0,n);
-buf[idx]=buf[idx].slice(n);
-}elseif(n===buf[idx].length){
-// First chunk is a perfect match.
-ret=buf[idx];
-buf[idx++]=null;
-}elseif((state[kState]&kDecoder)!==0){
-ret='';
-while(idx<len){
-conststr=buf[idx];
-if(n>str.length){
-ret+=str;
-n-=str.length;
-buf[idx++]=null;
-}else{
-if(n===str.length){
+}else{
+constfirst=buf[idx];
+constfirstLength=first.length;
+if(n<firstLength){
+// `slice` is the same for buffers and strings.
+ret=first.slice(0,n);
+buf[idx]=first.slice(n);
+}elseif(n===firstLength){
+// First chunk is a perfect match.
+ret=first;
+buf[idx++]=null;
+}elseif((state[kState]&kDecoder)!==0){
+ret='';
+while(idx<len){
+conststr=buf[idx];
+conststrLength=str.length;
+if(n>strLength){
 ret+=str;
+n-=strLength;
 buf[idx++]=null;
 }else{
-ret+=str.slice(0,n);
-buf[idx]=str.slice(n);
+if(n===strLength){
+ret+=str;
+buf[idx++]=null;
+}else{
+ret+=str.slice(0,n);
+buf[idx]=str.slice(n);
+}
+break;
 }
-break;
 }
-}
-}else{
-ret=Buffer.allocUnsafe(n);
-
-constretLen=n;
-while(idx<len){
-constdata=buf[idx];
-if(n>data.length){
-TypedArrayPrototypeSet(ret,data,retLen-n);
-n-=data.length;
-buf[idx++]=null;
-}else{
-if(n===data.length){
+}else{
+ret=Buffer.allocUnsafe(n);
+
+constretLen=n;
+while(idx<len){
+constdata=buf[idx];
+constdataLength=data.length;
+if(n>dataLength){
 TypedArrayPrototypeSet(ret,data,retLen-n);
+n-=dataLength;
 buf[idx++]=null;
 }else{
-TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
-buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,data.length-n);
+if(n===dataLength){
+TypedArrayPrototypeSet(ret,data,retLen-n);
+buf[idx++]=null;
+}else{
+TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
+buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,dataLength-n);
+}
+break;
 }
-break;
 }
 }
 }

lib/internal/streams/readable.js

@@ -673,15 +673,17 @@ Readable.prototype.read = function(n) {
 
 // If we're doing read(0) to trigger a readable event, but we
 // already have a bunch of data in the buffer, then just trigger
-// the 'readable' event and move on.
+// the 'readable' event and move on. `state.length` cannot change
+// within this block, so it is loaded once instead of three times.
+conststateLength=state.length;
 if(n===0&&
 (state[kState]&kNeedReadable)!==0&&
 ((state.highWaterMark!==0 ?
-state.length>=state.highWaterMark :
-state.length>0)||
+stateLength>=state.highWaterMark :
+stateLength>0)||
 (state[kState]&kEnded)!==0)){
 debug('read: emitReadable');
-if(state.length===0&&(state[kState]&kEnded)!==0)
+if(stateLength===0&&(state[kState]&kEnded)!==0)
 endReadable(this);
 else
 emitReadable(this);
@@ -1624,8 +1626,14 @@ Readable._fromList = fromList;
 // This function is designed to be inlinable, so please take care when making
 // changes to the function body.
 functionfromList(n,state){
+// `state.length` cannot change while this function runs (only the
+// caller updates it, after this returns) and the chunk lengths feeding
+// the copy loops cannot change across the copy calls, so every
+// repeated property load below is hoisted into a local.
+conststateLength=state.length;
+
 // nothing buffered.
-if(state.length===0)
+if(stateLength===0)
 returnnull;
 
 letidx=state.bufferIndex;
@@ -1637,7 +1645,7 @@ function fromList(n, state) {
 if((state[kState]&kObjectMode)!==0){
 ret=buf[idx];
 buf[idx++]=null;
-}elseif(!n||n>=state.length){
+}elseif(!n||n>=stateLength){
 // Read it all, truncate the list.
 if((state[kState]&kDecoder)!==0){
 ret='';
@@ -1651,61 +1659,68 @@ function fromList(n, state) {
 ret=buf[idx];
 buf[idx++]=null;
 }else{
-ret=Buffer.allocUnsafe(state.length);
+ret=Buffer.allocUnsafe(stateLength);
 
 leti=0;
 while(idx<len){
-TypedArrayPrototypeSet(ret,buf[idx],i);
-i+=buf[idx].length;
+constdata=buf[idx];
+TypedArrayPrototypeSet(ret,data,i);
+i+=data.length;
 buf[idx++]=null;
 }
 }
-}elseif(n<buf[idx].length){
-// `slice` is the same for buffers and strings.
-ret=buf[idx].slice(0,n);
-buf[idx]=buf[idx].slice(n);
-}elseif(n===buf[idx].length){
-// First chunk is a perfect match.
-ret=buf[idx];
-buf[idx++]=null;
-}elseif((state[kState]&kDecoder)!==0){
-ret='';
-while(idx<len){
-conststr=buf[idx];
-if(n>str.length){
-ret+=str;
-n-=str.length;
-buf[idx++]=null;
-}else{
-if(n===str.length){
+}else{
+constfirst=buf[idx];
+constfirstLength=first.length;
+if(n<firstLength){
+// `slice` is the same for buffers and strings.
+ret=first.slice(0,n);
+buf[idx]=first.slice(n);
+}elseif(n===firstLength){
+// First chunk is a perfect match.
+ret=first;
+buf[idx++]=null;
+}elseif((state[kState]&kDecoder)!==0){
+ret='';
+while(idx<len){
+conststr=buf[idx];
+conststrLength=str.length;
+if(n>strLength){
 ret+=str;
+n-=strLength;
 buf[idx++]=null;
 }else{
-ret+=str.slice(0,n);
-buf[idx]=str.slice(n);
+if(n===strLength){
+ret+=str;
+buf[idx++]=null;
+}else{
+ret+=str.slice(0,n);
+buf[idx]=str.slice(n);
+}
+break;
 }
-break;
 }
-}
-}else{
-ret=Buffer.allocUnsafe(n);
-
-constretLen=n;
-while(idx<len){
-constdata=buf[idx];
-if(n>data.length){
-TypedArrayPrototypeSet(ret,data,retLen-n);
-n-=data.length;
-buf[idx++]=null;
-}else{
-if(n===data.length){
+}else{
+ret=Buffer.allocUnsafe(n);
+
+constretLen=n;
+while(idx<len){
+constdata=buf[idx];
+constdataLength=data.length;
+if(n>dataLength){
 TypedArrayPrototypeSet(ret,data,retLen-n);
+n-=dataLength;
 buf[idx++]=null;
 }else{
-TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
-buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,data.length-n);
+if(n===dataLength){
+TypedArrayPrototypeSet(ret,data,retLen-n);
+buf[idx++]=null;
+}else{
+TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
+buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,dataLength-n);
+}
+break;
 }
-break;
 }
 }
 }

lib/internal/streams/readable.js

@@ -673,15 +673,17 @@ Readable.prototype.read = function(n) {
 
 // If we're doing read(0) to trigger a readable event, but we
 // already have a bunch of data in the buffer, then just trigger
-// the 'readable' event and move on.
+// the 'readable' event and move on. `state.length` cannot change
+// within this block, so it is loaded once instead of three times.
+conststateLength=state.length;
 if(n===0&&
 (state[kState]&kNeedReadable)!==0&&
 ((state.highWaterMark!==0 ?
-state.length>=state.highWaterMark :
-state.length>0)||
+stateLength>=state.highWaterMark :
+stateLength>0)||
 (state[kState]&kEnded)!==0)){
 debug('read: emitReadable');
-if(state.length===0&&(state[kState]&kEnded)!==0)
+if(stateLength===0&&(state[kState]&kEnded)!==0)
 endReadable(this);
 else
 emitReadable(this);
@@ -1624,8 +1626,14 @@ Readable._fromList = fromList;
 // This function is designed to be inlinable, so please take care when making
 // changes to the function body.
 functionfromList(n,state){
+// `state.length` cannot change while this function runs (only the
+// caller updates it, after this returns) and the chunk lengths feeding
+// the copy loops cannot change across the copy calls, so every
+// repeated property load below is hoisted into a local.
+conststateLength=state.length;
+
 // nothing buffered.
-if(state.length===0)
+if(stateLength===0)
 returnnull;
 
 letidx=state.bufferIndex;
@@ -1637,7 +1645,7 @@ function fromList(n, state) {
 if((state[kState]&kObjectMode)!==0){
 ret=buf[idx];
 buf[idx++]=null;
-}elseif(!n||n>=state.length){
+}elseif(!n||n>=stateLength){
 // Read it all, truncate the list.
 if((state[kState]&kDecoder)!==0){
 ret='';
@@ -1651,61 +1659,68 @@ function fromList(n, state) {
 ret=buf[idx];
 buf[idx++]=null;
 }else{
-ret=Buffer.allocUnsafe(state.length);
+ret=Buffer.allocUnsafe(stateLength);
 
 leti=0;
 while(idx<len){
-TypedArrayPrototypeSet(ret,buf[idx],i);
-i+=buf[idx].length;
+constdata=buf[idx];
+TypedArrayPrototypeSet(ret,data,i);
+i+=data.length;
 buf[idx++]=null;
 }
 }
-}elseif(n<buf[idx].length){
-// `slice` is the same for buffers and strings.
-ret=buf[idx].slice(0,n);
-buf[idx]=buf[idx].slice(n);
-}elseif(n===buf[idx].length){
-// First chunk is a perfect match.
-ret=buf[idx];
-buf[idx++]=null;
-}elseif((state[kState]&kDecoder)!==0){
-ret='';
-while(idx<len){
-conststr=buf[idx];
-if(n>str.length){
-ret+=str;
-n-=str.length;
-buf[idx++]=null;
-}else{
-if(n===str.length){
+}else{
+constfirst=buf[idx];
+constfirstLength=first.length;
+if(n<firstLength){
+// `slice` is the same for buffers and strings.
+ret=first.slice(0,n);
+buf[idx]=first.slice(n);
+}elseif(n===firstLength){
+// First chunk is a perfect match.
+ret=first;
+buf[idx++]=null;
+}elseif((state[kState]&kDecoder)!==0){
+ret='';
+while(idx<len){
+conststr=buf[idx];
+conststrLength=str.length;
+if(n>strLength){
 ret+=str;
+n-=strLength;
 buf[idx++]=null;
 }else{
-ret+=str.slice(0,n);
-buf[idx]=str.slice(n);
+if(n===strLength){
+ret+=str;
+buf[idx++]=null;
+}else{
+ret+=str.slice(0,n);
+buf[idx]=str.slice(n);
+}
+break;
 }
-break;
 }
-}
-}else{
-ret=Buffer.allocUnsafe(n);
-
-constretLen=n;
-while(idx<len){
-constdata=buf[idx];
-if(n>data.length){
-TypedArrayPrototypeSet(ret,data,retLen-n);
-n-=data.length;
-buf[idx++]=null;
-}else{
-if(n===data.length){
+}else{
+ret=Buffer.allocUnsafe(n);
+
+constretLen=n;
+while(idx<len){
+constdata=buf[idx];
+constdataLength=data.length;
+if(n>dataLength){
 TypedArrayPrototypeSet(ret,data,retLen-n);
+n-=dataLength;
 buf[idx++]=null;
 }else{
-TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
-buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,data.length-n);
+if(n===dataLength){
+TypedArrayPrototypeSet(ret,data,retLen-n);
+buf[idx++]=null;
+}else{
+TypedArrayPrototypeSet(ret,newFastBuffer(data.buffer,data.byteOffset,n),retLen-n);
+buf[idx]=newFastBuffer(data.buffer,data.byteOffset+n,dataLength-n);
+}
+break;
 }
-break;
 }
 }
 }