--- /dev/null
+'use strict';
+
+var common = require('../common.js');
+var bench = common.createBenchmark(main, {
+ millions: [2]
+});
+
+function main(conf) {
+ var N = +conf.millions * 1e6;
+ var n = 0;
+
+ function cb1(arg1) {
+ n++;
+ if (n === N)
+ bench.end(n / 1e6);
+ }
+ function cb2(arg1, arg2) {
+ n++;
+ if (n === N)
+ bench.end(n / 1e6);
+ }
+ function cb3(arg1, arg2, arg3) {
+ n++;
+ if (n === N)
+ bench.end(n / 1e6);
+ }
+
+ bench.start();
+ for (var i = 0; i < N; i++) {
+ if (i % 3 === 0)
+ process.nextTick(cb3, 512, true, null);
+ else if (i % 2 === 0)
+ process.nextTick(cb2, false, 5.1);
+ else
+ process.nextTick(cb1, 0);
+ }
+}
--- /dev/null
+'use strict';
+
+var common = require('../common.js');
+var bench = common.createBenchmark(main, {
+ millions: [2]
+});
+
+process.maxTickDepth = Infinity;
+
+function main(conf) {
+ var n = +conf.millions * 1e6;
+
+ function cb3(arg1, arg2, arg3) {
+ if (--n) {
+ if (n % 3 === 0)
+ process.nextTick(cb3, 512, true, null);
+ else if (n % 2 === 0)
+ process.nextTick(cb2, false, 5.1);
+ else
+ process.nextTick(cb1, 0);
+ } else
+ bench.end(+conf.millions);
+ }
+ function cb2(arg1, arg2) {
+ if (--n) {
+ if (n % 3 === 0)
+ process.nextTick(cb3, 512, true, null);
+ else if (n % 2 === 0)
+ process.nextTick(cb2, false, 5.1);
+ else
+ process.nextTick(cb1, 0);
+ } else
+ bench.end(+conf.millions);
+ }
+ function cb1(arg1) {
+ if (--n) {
+ if (n % 3 === 0)
+ process.nextTick(cb3, 512, true, null);
+ else if (n % 2 === 0)
+ process.nextTick(cb2, false, 5.1);
+ else
+ process.nextTick(cb1, 0);
+ } else
+ bench.end(+conf.millions);
+ }
+ bench.start();
+ process.nextTick(cb1, true);
+}
// Run callbacks that have no domain.
// Using domains will cause this to be overridden.
function _tickCallback() {
- var callback, threw, tock;
+ var callback, args, tock;
do {
while (tickInfo[kIndex] < tickInfo[kLength]) {
tock = nextTickQueue[tickInfo[kIndex]++];
callback = tock.callback;
- threw = true;
- try {
- if (tock.args === undefined)
- callback();
- else
- callback.apply(null, tock.args);
- threw = false;
- } finally {
- if (threw)
- tickDone();
+ args = tock.args;
+ // Using separate callback execution functions helps to limit the
+ // scope of DEOPTs caused by using try blocks and allows direct
+ // callback invocation with small numbers of arguments to avoid the
+ // performance hit associated with using `fn.apply()`
+ if (args === undefined) {
+ doNTCallback0(callback);
+ } else {
+ switch (args.length) {
+ case 1:
+ doNTCallback1(callback, args[0]);
+ break;
+ case 2:
+ doNTCallback2(callback, args[0], args[1]);
+ break;
+ case 3:
+ doNTCallback3(callback, args[0], args[1], args[2]);
+ break;
+ default:
+ doNTCallbackMany(callback, args);
+ }
}
if (1e4 < tickInfo[kIndex])
tickDone();
}
function _tickDomainCallback() {
- var callback, domain, threw, tock;
+ var callback, domain, args, tock;
do {
while (tickInfo[kIndex] < tickInfo[kLength]) {
tock = nextTickQueue[tickInfo[kIndex]++];
callback = tock.callback;
domain = tock.domain;
+ args = tock.args;
if (domain)
domain.enter();
- threw = true;
- try {
- if (tock.args === undefined)
- callback();
- else
- callback.apply(null, tock.args);
- threw = false;
- } finally {
- if (threw)
- tickDone();
+ // Using separate callback execution functions helps to limit the
+ // scope of DEOPTs caused by using try blocks and allows direct
+ // callback invocation with small numbers of arguments to avoid the
+ // performance hit associated with using `fn.apply()`
+ if (args === undefined) {
+ doNTCallback0(callback);
+ } else {
+ switch (args.length) {
+ case 1:
+ doNTCallback1(callback, args[0]);
+ break;
+ case 2:
+ doNTCallback2(callback, args[0], args[1]);
+ break;
+ case 3:
+ doNTCallback3(callback, args[0], args[1], args[2]);
+ break;
+ default:
+ doNTCallbackMany(callback, args);
+ }
}
if (1e4 < tickInfo[kIndex])
tickDone();
} while (tickInfo[kLength] !== 0);
}
+ function doNTCallback0(callback) {
+ var threw = true;
+ try {
+ callback();
+ threw = false;
+ } finally {
+ if (threw)
+ tickDone();
+ }
+ }
+
+ function doNTCallback1(callback, arg1) {
+ var threw = true;
+ try {
+ callback(arg1);
+ threw = false;
+ } finally {
+ if (threw)
+ tickDone();
+ }
+ }
+
+ function doNTCallback2(callback, arg1, arg2) {
+ var threw = true;
+ try {
+ callback(arg1, arg2);
+ threw = false;
+ } finally {
+ if (threw)
+ tickDone();
+ }
+ }
+
+ function doNTCallback3(callback, arg1, arg2, arg3) {
+ var threw = true;
+ try {
+ callback(arg1, arg2, arg3);
+ threw = false;
+ } finally {
+ if (threw)
+ tickDone();
+ }
+ }
+
+ function doNTCallbackMany(callback, args) {
+ var threw = true;
+ try {
+ callback.apply(null, args);
+ threw = false;
+ } finally {
+ if (threw)
+ tickDone();
+ }
+ }
+
function TickObject(c, args) {
this.callback = c;
this.domain = process.domain || null;
at emitNone (events.js:*:*)
at Socket.emit (events.js:*:*)
at endReadableNT (_stream_readable.js:*:*)
+ at doNTCallback2 (node.js:*:*)
at process._tickCallback (node.js:*:*)
42
42
at emitNone (events.js:*:*)
at Socket.emit (events.js:*:*)
at endReadableNT (_stream_readable.js:*:*)
- at process._tickCallback (node.js:*:*)
+ at doNTCallback2 (node.js:*:*)
[stdin]:1
throw new Error("hello")
at emitNone (events.js:*:*)
at Socket.emit (events.js:*:*)
at endReadableNT (_stream_readable.js:*:*)
- at process._tickCallback (node.js:*:*)
+ at doNTCallback2 (node.js:*:*)
100
[stdin]:1
at emitNone (events.js:*:*)
at Socket.emit (events.js:*:*)
at endReadableNT (_stream_readable.js:*:*)
- at process._tickCallback (node.js:*:*)
+ at doNTCallback2 (node.js:*:*)
[stdin]:1
var ______________________________________________; throw 10