process: improve nextTick() performance

benchmark/process/next-tick-depth-args.js

@@ -2,7 +2,7 @@
 
 var common = require('../common.js');
 var bench = common.createBenchmark(main, {
- millions: [2]
+ millions: [12]
 });
 
 process.maxTickDepth = Infinity;

benchmark/process/next-tick-depth.js

@@ -1,7 +1,7 @@
 'use strict';
 var common = require('../common.js');
 var bench = common.createBenchmark(main, {
- millions: [2]
+ millions: [12]
 });
 
 process.maxTickDepth = Infinity;

lib/internal/process/next_tick.js

@@ -10,6 +10,42 @@ exports.setup = setupNextTick;
 // Will be overwritten when setupNextTick() is called.
 exports.nextTick = null;
 
+class NextTickQueue {
+ constructor() {
+ this.head = null;
+ this.tail = null;
+ this.length = 0;
+ }
+
+ push(v) {
+ const entry = { data: v, next: null };
+ if (this.length > 0)
+ this.tail.next = entry;
+ else
+ this.head = entry;
+ this.tail = entry;
+ ++this.length;
+ }
+
+ shift() {
+ if (this.length === 0)
+ return;
+ const ret = this.head.data;
+ if (this.length === 1)
+ this.head = this.tail = null;
+ else
+ this.head = this.head.next;
+ --this.length;
+ return ret;
+ }
+
+ clear() {
+ this.head = null;
+ this.tail = null;
+ this.length = 0;
+ }
+}
+
 function setupNextTick() {
  const async_wrap = process.binding('async_wrap');
  const async_hooks = require('async_hooks');
@@ -27,7 +63,7 @@ function setupNextTick() {
  const { kInit, kBefore, kAfter, kDestroy, kAsyncUidCntr, kInitTriggerId } =
  async_wrap.constants;
  const { async_id_symbol, trigger_id_symbol } = async_wrap;
- var nextTickQueue = [];
+ var nextTickQueue = new NextTickQueue();
  var microtasksScheduled = false;
 
  // Used to run V8's micro task queue.
@@ -55,27 +91,29 @@ function setupNextTick() {
  function tickDone() {
  if (tickInfo[kLength] !== 0) {
  if (tickInfo[kLength] <= tickInfo[kIndex]) {
- nextTickQueue = [];
+ nextTickQueue.clear();
  tickInfo[kLength] = 0;
  } else {
- nextTickQueue.splice(0, tickInfo[kIndex]);
  tickInfo[kLength] = nextTickQueue.length;
  }
  }
  tickInfo[kIndex] = 0;
  }
 
+ const microTasksTickObject = {
+ callback: runMicrotasksCallback,
+ args: undefined,
+ domain: null,
+ [async_id_symbol]: 0,
+ [trigger_id_symbol]: 0
+ };
  function scheduleMicrotasks() {
  if (microtasksScheduled)
  return;
 
- const tickObject =
- new TickObject(runMicrotasksCallback, undefined, null);
  // For the moment all microtasks come from the void until the PromiseHook
  // API is implemented.
- tickObject[async_id_symbol] = 0;
- tickObject[trigger_id_symbol] = 0;
- nextTickQueue.push(tickObject);
+ nextTickQueue.push(microTasksTickObject);
 
  tickInfo[kLength]++;
  microtasksScheduled = true;
@@ -86,8 +124,9 @@ function setupNextTick() {
  _runMicrotasks();
 
  if (tickInfo[kIndex] < tickInfo[kLength] ||
- emitPendingUnhandledRejections())
+ emitPendingUnhandledRejections()) {
  scheduleMicrotasks();
+ }
  }
 
  function _combinedTickCallback(args, callback) {
@@ -133,7 +172,8 @@ function setupNextTick() {
  function _tickCallback() {
  do {
  while (tickInfo[kIndex] < tickInfo[kLength]) {
- const tock = nextTickQueue[tickInfo[kIndex]++];
+ ++tickInfo[kIndex];
+ const tock = nextTickQueue.shift();
  const callback = tock.callback;
  const args = tock.args;
 
@@ -174,7 +214,8 @@ function setupNextTick() {
  function _tickDomainCallback() {
  do {
  while (tickInfo[kIndex] < tickInfo[kLength]) {
- const tock = nextTickQueue[tickInfo[kIndex]++];
+ ++tickInfo[kIndex];
+ const tock = nextTickQueue.shift();
  const callback = tock.callback;
  const domain = tock.domain;
  const args = tock.args;
@@ -210,45 +251,48 @@ function setupNextTick() {
  } while (tickInfo[kLength] !== 0);
  }
 
- function TickObject(callback, args, domain) {
- this.callback = callback;
- this.domain = domain;
- this.args = args;
- this[async_id_symbol] = -1;
- this[trigger_id_symbol] = -1;
- }
-
- function setupInit(tickObject, triggerAsyncId) {
- tickObject[async_id_symbol] = ++async_uid_fields[kAsyncUidCntr];
- tickObject[trigger_id_symbol] = triggerAsyncId || initTriggerId();
- if (async_hook_fields[kInit] > 0) {
- emitInit(tickObject[async_id_symbol],
- 'TickObject',
- tickObject[trigger_id_symbol],
- tickObject);
+ class TickObject {
+ constructor(callback, args, asyncId, triggerAsyncId) {
+ this.callback = callback;
+ this.args = args;
+ this.domain = process.domain || null;
+ this[async_id_symbol] = asyncId;
+ this[trigger_id_symbol] = triggerAsyncId;
  }
  }
 
+ // `nextTick()` will not enqueue any callback when the process is about to
+ // exit since the callback would not have a chance to be executed.
  function nextTick(callback) {
  if (typeof callback !== 'function')
  throw new errors.TypeError('ERR_INVALID_CALLBACK');
- // on the way out, don't bother. it won't get fired anyway.
+
  if (process._exiting)
  return;
 
  var args;
- if (arguments.length > 1) {
- args = new Array(arguments.length - 1);
- for (var i = 1; i < arguments.length; i++)
- args[i - 1] = arguments[i];
+ switch (arguments.length) {
+ case 1: break;
+ case 2: args = [arguments[1]]; break;
+ case 3: args = [arguments[1], arguments[2]]; break;
+ case 4: args = [arguments[1], arguments[2], arguments[3]]; break;
+ default:
+ args = new Array(arguments.length - 1);
+ for (var i = 1; i < arguments.length; i++)
+ args[i - 1] = arguments[i];
  }
 
- var obj = new TickObject(callback, args, process.domain || null);
- setupInit(obj, null);
+ const asyncId = ++async_uid_fields[kAsyncUidCntr];
+ const triggerAsyncId = initTriggerId();
+ const obj = new TickObject(callback, args, asyncId, triggerAsyncId);
  nextTickQueue.push(obj);
- tickInfo[kLength]++;
+ ++tickInfo[kLength];
+ if (async_hook_fields[kInit] > 0)
+ emitInit(asyncId, 'TickObject', triggerAsyncId, obj);
  }
 
+ // `internalNextTick()` will not enqueue any callback when the process is
+ // about to exit since the callback would not have a chance to be executed.
  function internalNextTick(triggerAsyncId, callback) {
  if (typeof callback !== 'function')
  throw new TypeError('callback is not a function');
@@ -259,17 +303,25 @@ function setupNextTick() {
  return;
 
  var args;
- if (arguments.length > 2) {
- args = new Array(arguments.length - 2);
- for (var i = 2; i < arguments.length; i++)
- args[i - 2] = arguments[i];
+ switch (arguments.length) {
+ case 2: break;
+ case 3: args = [arguments[2]]; break;
+ case 4: args = [arguments[2], arguments[3]]; break;
+ case 5: args = [arguments[2], arguments[3], arguments[4]]; break;
+ default:
+ args = new Array(arguments.length - 2);
+ for (var i = 2; i < arguments.length; i++)
+ args[i - 2] = arguments[i];
  }
 
- var obj = new TickObject(callback, args, process.domain || null);
- setupInit(obj, triggerAsyncId);
+ const asyncId = ++async_uid_fields[kAsyncUidCntr];
+ const obj = new TickObject(callback, args, asyncId, triggerAsyncId);
+ nextTickQueue.push(obj);
+ ++tickInfo[kLength];
+ if (async_hook_fields[kInit] > 0)
+ emitInit(asyncId, 'TickObject', triggerAsyncId, obj);
+
  // The call to initTriggerId() was skipped, so clear kInitTriggerId.
  async_uid_fields[kInitTriggerId] = 0;
- nextTickQueue.push(obj);
- tickInfo[kLength]++;
  }
 }