3x faster setImmediate

benchmark/timers/immediate.js

@@ -0,0 +1,113 @@
+'use strict';
+var common = require('../common.js');
+
+var bench = common.createBenchmark(main, {
+  thousands: [2000],
+  type: ['depth', 'depth1', 'breadth', 'breadth1', 'breadth4', 'clear']
+});
+
+function main(conf) {
+  var N = +conf.thousands * 1e3;
+  switch (conf.type) {
+    case 'depth':
+      depth(N);
+      break;
+    case 'depth1':
+      depth1(N);
+      break;
+    case 'breadth':
+      breadth(N);
+      break;
+    case 'breadth1':
+      breadth1(N);
+      break;
+    case 'breadth4':
+      breadth4(N);
+      break;
+    case 'clear':
+      clear(N);
+      break;
+  }
+}
+
+// setImmediate tail recursion, 0 arguments
+function depth(N) {
+  var n = 0;
+  bench.start();
+  setImmediate(cb);
+  function cb() {
+    n++;
+    if (n === N)
+      bench.end(N / 1e3);
+    else
+      setImmediate(cb);
+  }
+}
+
+// setImmediate tail recursion, 1 argument
+function depth1(N) {
+  var n = 0;
+  bench.start();
+  setImmediate(cb, 1);
+  function cb(a1) {
+    n++;
+    if (n === N)
+      bench.end(N / 1e3);
+    else
+      setImmediate(cb, 1);
+  }
+}
+
+// concurrent setImmediate, 0 arguments
+function breadth(N) {
+  var n = 0;
+  bench.start();
+  function cb() {
+    n++;
+    if (n === N)
+      bench.end(N / 1e3);
+  }
+  for (var i = 0; i < N; i++) {
+    setImmediate(cb);
+  }
+}
+
+// concurrent setImmediate, 1 argument
+function breadth1(N) {
+  var n = 0;
+  bench.start();
+  function cb(a1) {
+    n++;
+    if (n === N)
+      bench.end(N / 1e3);
+  }
+  for (var i = 0; i < N; i++) {
+    setImmediate(cb, 1);
+  }
+}
+
+// concurrent setImmediate, 4 arguments
+function breadth4(N) {
+  var n = 0;
+  bench.start();
+  function cb(a1, a2, a3, a4) {
+    n++;
+    if (n === N)
+      bench.end(N / 1e3);
+  }
+  for (var i = 0; i < N; i++) {
+    setImmediate(cb, 1, 2, 3, 4);
+  }
+}
+
+function clear(N) {
+  bench.start();
+  function cb(a1) {
+    if (a1 === 2)
+      bench.end(N / 1e3);
+  }
+  for (var i = 0; i < N; i++) {
+    clearImmediate(setImmediate(cb, 1));
+  }
+  setImmediate(cb, 2);
+}

lib/internal/linkedlist.js

@@ -6,6 +6,13 @@ function init(list) {
 }
 exports.init = init;
 
+// create a new linked list
+function create() {
+  const list = { _idleNext: null, _idlePrev: null };
+  init(list);
+  return list;
+}
+exports.create = create;
 
 // show the most idle item
 function peek(list) {
@@ -42,10 +49,17 @@ exports.remove = remove;
 
 // remove a item from its list and place at the end.
 function append(list, item) {
-  remove(item);
+  if (item._idleNext || item._idlePrev) {
+    remove(item);
+  }
+
+  // items are linked  with _idleNext -> (older) and _idlePrev -> (newer)
+  // TODO: swap the linkage to match the intuitive older items at "prev"
   item._idleNext = list._idleNext;
-  list._idleNext._idlePrev = item;
   item._idlePrev = list;
+
+  // the list _idleNext points to tail (newest) and _idlePrev to head (oldest)
+  list._idleNext._idlePrev = item;
   list._idleNext = item;
 }
 exports.append = append;

lib/timers.js

@@ -502,24 +502,26 @@ Timeout.prototype.close = function() {
 };
 
 
-var immediateQueue = {};
-L.init(immediateQueue);
+var immediateQueue = L.create();
 
 
 function processImmediate() {
   var queue = immediateQueue;
   var domain, immediate;
 
-  immediateQueue = {};
-  L.init(immediateQueue);
+  immediateQueue = L.create();
 
   while (L.isEmpty(queue) === false) {
     immediate = L.shift(queue);
     domain = immediate.domain;
 
+    if (!immediate._onImmediate)
+      continue;
+
     if (domain)
       domain.enter();
 
+    immediate._callback = immediate._onImmediate;
     tryOnImmediate(immediate, queue);
 
     if (domain)
@@ -540,7 +542,8 @@ function processImmediate() {
 function tryOnImmediate(immediate, queue) {
   var threw = 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)) {
@@ -554,67 +557,73 @@ function tryOnImmediate(immediate, queue) {
   }
 }
 
+function runCallback(timer) {
+  var argv = timer._argv;
+  var argc = argv ? argv.length : 0;
+  switch (argc) {
+    // fast-path callbacks with 0-3 arguments
+    case 0:
+      return timer._callback();
+    case 1:
+      return timer._callback(argv[0]);
+    case 2:
+      return timer._callback(argv[0], argv[1]);
+    case 3:
+      return timer._callback(argv[0], argv[1], argv[2]);
+    // more then 3 arguments run slower with .apply
+    default:
+      return timer._callback.apply(timer, argv);
+  }
+}
 
-function Immediate() { }
-
-Immediate.prototype.domain = undefined;
-Immediate.prototype._onImmediate = undefined;
-Immediate.prototype._idleNext = undefined;
-Immediate.prototype._idlePrev = undefined;
 
+function createImmediate(callback, args) {
+  return {
+    _idleNext: null,
+    _idlePrev: null,
+    _callback: callback,
+    _argv: args,
+    _onImmediate: callback,
+    domain: process.domain,
+  };
+}
 
 exports.setImmediate = function(callback, arg1, arg2, arg3) {
   if (typeof callback !== 'function') {
     throw new TypeError('"callback" argument must be a function');
   }
 
   var i, args;
-  var len = arguments.length;
-  var immediate = new Immediate();
-
-  L.init(immediate);
 
-  switch (len) {
+  switch (arguments.length) {
     // fast cases
     case 0:
     case 1:
-      immediate._onImmediate = callback;
       break;
     case 2:
-      immediate._onImmediate = function() {
-        callback.call(immediate, arg1);
-      };
+      args = [arg1];
       break;
     case 3:
-      immediate._onImmediate = function() {
-        callback.call(immediate, arg1, arg2);
-      };
+      args = [arg1, arg2];
       break;
     case 4:
-      immediate._onImmediate = function() {
-        callback.call(immediate, arg1, arg2, arg3);
-      };
+      args = [arg1, arg2, arg3];
       break;
     // slow case
     default:
+      var len = arguments.length;
       args = new Array(len - 1);
       for (i = 1; i < len; i++)
         args[i - 1] = arguments[i];
-
-      immediate._onImmediate = function() {
-        callback.apply(immediate, args);
-      };
       break;
   }
+  var immediate = createImmediate(callback, args);
 
   if (!process._needImmediateCallback) {
     process._needImmediateCallback = true;
     process._immediateCallback = processImmediate;
   }
 
-  if (process.domain)
-    immediate.domain = process.domain;
-
   L.append(immediateQueue, immediate);
 
   return immediate;
@@ -626,9 +635,6 @@ exports.clearImmediate = function(immediate) {
 
   immediate._onImmediate = undefined;
 
-  L.remove(immediate);
-
-  if (L.isEmpty(immediateQueue)) {
-    process._needImmediateCallback = false;
-  }
+  // leave queued, much faster overall to skip it later in processImmediate
+  return;
 };

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

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