timers: optimize setImmediate()

Save the setImmediate() callback arguments into an array instead of a closure, and invoke the callback on the arguments from an optimizable function. 60% faster setImmediate with 0 args (15% if self-recursive) 4x faster setImmediate with 1-3 args, 2x with > 3 seems to be faster with less memory pressure when memory is tight Changes: - use L.create() to build faster lists - use runCallback() from within tryOnImmediate() - save the arguments and do not build closures for the callbacks PR-URL: #6436 Reviewed-By: Benjamin Gruenbaum <[email protected]> Reviewed-By: Jeremiah Senkpiel <[email protected]>

Author: Andras

lib/internal/linkedlist.js

@@ -8,7 +8,7 @@ exports.init = init;
 
 // create a new linked list
 functioncreate(){
-varlist={_idleNext: null,_idlePrev: null};
+constlist={_idleNext: null,_idlePrev: null};
 init(list);
 returnlist;
 }

lib/timers.js

@@ -506,7 +506,7 @@ var immediateQueue = L.create();
 
 
 functionprocessImmediate(){
-varqueue=immediateQueue;
+constqueue=immediateQueue;
 vardomain,immediate;
 
 immediateQueue=L.create();
@@ -515,9 +515,13 @@ function processImmediate(){
 immediate=L.shift(queue);
 domain=immediate.domain;
 
+if(!immediate._onImmediate)
+continue;
+
 if(domain)
 domain.enter();
 
+immediate._callback=immediate._onImmediate;
 tryOnImmediate(immediate,queue);
 
 if(domain)
@@ -538,7 +542,8 @@ function processImmediate(){
 functiontryOnImmediate(immediate,queue){
 varthrew=true;
 try{
-immediate._onImmediate();
+// make the actual call outside the try/catch to allow it to be optimized
+runCallback(immediate);
 threw=false;
 }finally{
 if(threw&&!L.isEmpty(queue)){
@@ -552,67 +557,77 @@ function tryOnImmediate(immediate, queue){
 }
 }
 
+functionrunCallback(timer){
+constargv=timer._argv;
+constargc=argv ? argv.length : 0;
+switch(argc){
+// fast-path callbacks with 0-3 arguments
+case0:
+returntimer._callback();
+case1:
+returntimer._callback(argv[0]);
+case2:
+returntimer._callback(argv[0],argv[1]);
+case3:
+returntimer._callback(argv[0],argv[1],argv[2]);
+// more than 3 arguments run slower with .apply
+default:
+returntimer._callback.apply(timer,argv);
+}
+}
 
-functionImmediate(){}
-
-Immediate.prototype.domain=undefined;
-Immediate.prototype._onImmediate=undefined;
-Immediate.prototype._idleNext=undefined;
-Immediate.prototype._idlePrev=undefined;
 
+functionImmediate(){
+// assigning the callback here can cause optimize/deoptimize thrashing
+// so have caller annotate the object (node v6.0.0, v8 5.0.71.35)
+this._idleNext=null;
+this._idlePrev=null;
+this._callback=null;
+this._argv=null;
+this._onImmediate=null;
+this.domain=process.domain;
+}
 
 exports.setImmediate=function(callback,arg1,arg2,arg3){
 if(typeofcallback!=='function'){
 thrownewTypeError('"callback" argument must be a function');
 }
 
 vari,args;
-varlen=arguments.length;
-varimmediate=newImmediate();
-
-L.init(immediate);
 
-switch(len){
+switch(arguments.length){
 // fast cases
 case0:
 case1:
-immediate._onImmediate=callback;
 break;
 case2:
-immediate._onImmediate=function(){
-callback.call(immediate,arg1);
-};
+args=[arg1];
 break;
 case3:
-immediate._onImmediate=function(){
-callback.call(immediate,arg1,arg2);
-};
+args=[arg1,arg2];
 break;
 case4:
-immediate._onImmediate=function(){
-callback.call(immediate,arg1,arg2,arg3);
-};
+args=[arg1,arg2,arg3];
 break;
 // slow case
 default:
-args=newArray(len-1);
-for(i=1;i<len;i++)
+args=[arg1,arg2,arg3];
+for(i=4;i<arguments.length;i++)
+// extend array dynamically, makes .apply run much faster in v6.0.0
 args[i-1]=arguments[i];
-
-immediate._onImmediate=function(){
-callback.apply(immediate,args);
-};
 break;
 }
+// declaring it `const immediate` causes v6.0.0 to deoptimize this function
+varimmediate=newImmediate();
+immediate._callback=callback;
+immediate._argv=args;
+immediate._onImmediate=callback;
 
 if(!process._needImmediateCallback){
 process._needImmediateCallback=true;
 process._immediateCallback=processImmediate;
 }
 
-if(process.domain)
-immediate.domain=process.domain;
-
 L.append(immediateQueue,immediate);
 
 returnimmediate;

test/parallel/test-timers-immediate.js

@@ -5,6 +5,7 @@ var assert = require('assert');
 letimmediateA=false;
 letimmediateB=false;
 letimmediateC=[];
+letimmediateD=[];
 
 setImmediate(function(){
 try{
@@ -25,8 +26,13 @@ setImmediate(function(x, y, z){
 immediateC=[x,y,z];
 },1,2,3);
 
+setImmediate(function(x,y,z,a,b){
+immediateD=[x,y,z,a,b];
+},1,2,3,4,5);
+
 process.on('exit',function(){
 assert.ok(immediateA,'Immediate should happen after normal execution');
 assert.notStrictEqual(immediateB,true,'immediateB should not fire');
 assert.deepStrictEqual(immediateC,[1,2,3],'immediateC args should match');
+assert.deepStrictEqual(immediateD,[1,2,3,4,5],'5 args should match');
 });

test/parallel/test-timers-linked-list.js

@@ -103,8 +103,8 @@ assert.equal(C, L.shift(list));
 // list
 assert.ok(L.isEmpty(list));
 
-varlist2=L.create();
-varlist3=L.create();
+constlist2=L.create();
+constlist3=L.create();
 assert.ok(L.isEmpty(list2));
 assert.ok(L.isEmpty(list3));
 assert.ok(list2!=list3);