benchmark: refactor console benchmark

Fix and refactor the console benchmark. It did not test console
so it got renamed and mainly tests the different ways of passing
arguments through.

PR-URL: #17707
Reviewed-By: Luigi Pinca <[email protected]>
Reviewed-By: James M Snell <[email protected]>

benchmark/misc/arguments.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const { createBenchmark } = require('../common.js');
+const { format } = require('util');
+
+const methods = [
+  'restAndSpread',
+  'argumentsAndApply',
+  'restAndApply',
+  'predefined'
+];
+
+const bench = createBenchmark(main, {
+  method: methods,
+  n: [1e6]
+});
+
+function usingRestAndSpread(...args) {
+  format(...args);
+}
+
+function usingRestAndApply(...args) {
+  format.apply(null, args);
+}
+
+function usingArgumentsAndApply() {
+  format.apply(null, arguments);
+}
+
+function usingPredefined() {
+  format('part 1', 'part', 2, 'part 3', 'part', 4);
+}
+
+function main({ n, method, args }) {
+  var fn;
+  switch (method) {
+    // '' is a default case for tests
+    case '':
+    case 'restAndSpread':
+      fn = usingRestAndSpread;
+      break;
+    case 'restAndApply':
+      fn = usingRestAndApply;
+      break;
+    case 'argumentsAndApply':
+      fn = usingArgumentsAndApply;
+      break;
+    case 'predefined':
+      fn = usingPredefined;
+      break;
+    default:
+      throw new Error(`Unexpected method "${method}"`);
+  }
+
+  bench.start();
+  for (var i = 0; i < n; i++)
+    fn('part 1', 'part', 2, 'part 3', 'part', 4);
+  bench.end(n);
+}

lib/console.js

@@ -132,12 +132,12 @@ function write(ignoreErrors, stream, string, errorhandler, groupIndent) {
 }
 
 
-// As of v8 5.0.71.32, the combination of rest param, template string
-// and .apply(null, args) benchmarks consistently faster than using
-// the spread operator when calling util.format.
 Console.prototype.log = function log(...args) {
   write(this._ignoreErrors,
         this._stdout,
+        // The performance of .apply and the spread operator seems on par in V8
+        // 6.3 but the spread operator, unlike .apply(), pushes the elements
+        // onto the stack. That is, it makes stack overflows more likely.
         util.format.apply(null, args),
         this._stdoutErrorHandler,
         this[kGroupIndent]);