readline: reduce createInterface overhead

Speed up Interface construction:
- Hoist the history accessor property descriptors to module scope and
define them with a single ObjectDefineProperties call, instead of
allocating six closures and four descriptor objects per instance.
- Stop assigning the history options onto the input stream. This avoids
hidden class transitions on the user provided stream and no longer
mutates it observably.
- Only check process.env.TERM for a dumb terminal when the interface is
in terminal mode. Reading process.env goes through the environment
interceptor and is comparatively expensive, and _ttyWrite is never
called when terminal is false.
Signed-off-by: Matteo Collina <hello@matteocollina.com>
PR-URL: #64585
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Gürgün Dayıoğlu <hey@gurgun.day>

Author: mcollina

benchmark/readline/readline-createInterface.js

@@ -0,0 +1,26 @@
+'use strict';
+constcommon=require('../common.js');
+constreadline=require('readline');
+const{ Readable, Writable }=require('stream');
+
+constbench=common.createBenchmark(main,{
+n: [1e5],
+terminal: [0,1],
+});
+
+functionmain({ n, terminal }){
+bench.start();
+for(leti=0;i<n;i++){
+constinput=newReadable({read(){}});
+constoutput=newWritable({write(chunk,encoding,callback){
+callback();
+}});
+constrl=readline.createInterface({
+ input,
+ output,
+terminal: Boolean(terminal),
+});
+rl.close();
+}
+bench.end(n);
+}

lib/internal/readline/interface.js

@@ -17,9 +17,10 @@ const {
  MathMax,
  MathMaxApply,
  NumberIsFinite,
-ObjectDefineProperty,
+ObjectDefineProperties,
  ObjectSetPrototypeOf,
  RegExpPrototypeExec,
+ RegExpPrototypeSymbolSplit,
  SafeStringIterator,
  StringPrototypeCodePointAt,
  StringPrototypeEndsWith,
@@ -172,6 +173,7 @@ function InterfaceConstructor(input, output, completer, terminal) {
 letcrlfDelay;
 letprompt='> ';
 letsignal;
+lethistoryOptions;
 
 if(input?.input){
 // An options object was given
@@ -210,12 +212,15 @@ function InterfaceConstructor(input, output, completer, terminal) {
 crlfDelay=input.crlfDelay;
 input=input.input;
 
-input.size=historySize;
-input.history=history;
-input.removeHistoryDuplicates=removeHistoryDuplicates;
+historyOptions={
+__proto__: null,
+size: historySize,
+ history,
+ removeHistoryDuplicates,
+};
 }
 
-this.setupHistoryManager(input);
+this.setupHistoryManager(historyOptions??input);
 
 if(completer!==undefined&&typeofcompleter!=='function'){
 thrownewERR_INVALID_ARG_VALUE('completer',completer);
@@ -358,6 +363,30 @@ function InterfaceConstructor(input, output, completer, terminal) {
 ObjectSetPrototypeOf(InterfaceConstructor.prototype,EventEmitter.prototype);
 ObjectSetPrototypeOf(InterfaceConstructor,EventEmitter);
 
+// Shared descriptors for the history accessors defined on each instance.
+// Hoisted to avoid allocating fresh closures on every construction.
+constkHistoryAccessorDescriptors={
+__proto__: null,
+history: {
+__proto__: null,configurable: true,enumerable: true,
+get(){returnthis.historyManager.history;},
+set(newHistory){returnthis.historyManager.history=newHistory;},
+},
+historyIndex: {
+__proto__: null,configurable: true,enumerable: true,
+get(){returnthis.historyManager.index;},
+set(historyIndex){returnthis.historyManager.index=historyIndex;},
+},
+historySize: {
+__proto__: null,configurable: true,enumerable: true,
+get(){returnthis.historyManager.size;},
+},
+isFlushing: {
+__proto__: null,configurable: true,enumerable: true,
+get(){returnthis.historyManager.isFlushing;},
+},
+};
+
 classInterfaceextendsInterfaceConstructor{
 getcolumns(){
 if(this.output?.columns)returnthis.output.columns;
@@ -388,27 +417,7 @@ class Interface extends InterfaceConstructor {
 this.historyManager.initialize(options.onHistoryFileLoaded);
 }
 
-ObjectDefineProperty(this,'history',{
-__proto__: null,configurable: true,enumerable: true,
-get(){returnthis.historyManager.history;},
-set(newHistory){returnthis.historyManager.history=newHistory;},
-});
-
-ObjectDefineProperty(this,'historyIndex',{
-__proto__: null,configurable: true,enumerable: true,
-get(){returnthis.historyManager.index;},
-set(historyIndex){returnthis.historyManager.index=historyIndex;},
-});
-
-ObjectDefineProperty(this,'historySize',{
-__proto__: null,configurable: true,enumerable: true,
-get(){returnthis.historyManager.size;},
-});
-
-ObjectDefineProperty(this,'isFlushing',{
-__proto__: null,configurable: true,enumerable: true,
-get(){returnthis.historyManager.isFlushing;},
-});
+ObjectDefineProperties(this,kHistoryAccessorDescriptors);
 }
 
 [kSetRawMode](mode){
@@ -622,37 +631,44 @@ class Interface extends InterfaceConstructor {
 this[kSawReturnAt]=0;
 }
 
-// Run test() on the new string chunk, not on the entire line buffer.
-letnewPartContainsEnding=RegExpPrototypeExec(lineEnding,string);
-if(newPartContainsEnding!==null){
-if(this[kLine_buffer]){
-string=this[kLine_buffer]+string;
-this[kLine_buffer]=null;
-lineEnding.lastIndex=0;// Start the search from the beginning of the string.
-newPartContainsEnding=RegExpPrototypeExec(lineEnding,string);
-}
-this[kSawReturnAt]=StringPrototypeEndsWith(string,'\r') ?
-DateNow() :
-0;
-
-constindexes=[0,newPartContainsEnding.index,lineEnding.lastIndex];
-letnextMatch;
-while((nextMatch=RegExpPrototypeExec(lineEnding,string))!==null){
-ArrayPrototypePush(indexes,nextMatch.index,lineEnding.lastIndex);
-}
-constlastIndex=indexes.length-1;
-// Either '' or (conceivably) the unfinished portion of the next line
-this[kLine_buffer]=StringPrototypeSlice(string,indexes[lastIndex]);
-for(leti=1;i<lastIndex;i+=2){
-this[kOnLine](StringPrototypeSlice(string,indexes[i-1],indexes[i]));
-}
-}elseif(string){
-// No newlines this time, save what we have for next time
+if(!string){
+return;
+}
+
+// Split the new string chunk, not the entire line buffer: a single
+// split pass avoids allocating a match object per line ending.
+// When the chunk contains none of the rare line endings, a plain
+// string split is much cheaper than the regular expression.
+constlines=
+StringPrototypeIncludes(string,'\r')||
+StringPrototypeIncludes(string,'\u2028')||
+StringPrototypeIncludes(string,'\u2029') ?
+RegExpPrototypeSymbolSplit(lineEnding,string) :
+StringPrototypeSplit(string,'\n');
+constlastIndex=lines.length-1;
+if(lastIndex===0){
+// No line endings this time, save what we have for next time.
 if(this[kLine_buffer]){
 this[kLine_buffer]+=string;
 }else{
 this[kLine_buffer]=string;
 }
+return;
+}
+
+this[kSawReturnAt]=StringPrototypeEndsWith(string,'\r') ?
+DateNow() :
+0;
+
+letfirst=lines[0];
+if(this[kLine_buffer]){
+first=this[kLine_buffer]+first;
+}
+// Either '' or (conceivably) the unfinished portion of the next line
+this[kLine_buffer]=lines[lastIndex];
+this[kOnLine](first);
+for(leti=1;i<lastIndex;i++){
+this[kOnLine](lines[i]);
 }
 }
 

lib/readline.js

@@ -115,7 +115,9 @@ function Interface(input, output, completer, terminal) {
 FunctionPrototypeCall(InterfaceConstructor,this,
 input,output,completer,terminal);
 
-if(process.env.TERM==='dumb'){
+// Reading process.env is expensive and _ttyWrite is only used in
+// terminal mode, so only check for a dumb terminal when relevant.
+if(this.terminal&&process.env.TERM==='dumb'){
 this._ttyWrite=FunctionPrototypeBind(_ttyWriteDumb,this);
 }
 }