util: improve inspect performance

benchmark/util/format.js

@@ -10,7 +10,7 @@ const types = [
  'no-replace'
 ];
 const bench = common.createBenchmark(main, {
- n: [1e6],
+ n: [2e6],
  type: types
 });
 

benchmark/util/inspect-array.js

@@ -4,23 +4,27 @@ const common = require('../common');
 const util = require('util');
 
 const bench = common.createBenchmark(main, {
- n: [1e2],
+ n: [1e3],
  len: [1e5],
  type: [
  'denseArray',
  'sparseArray',
- 'mixedArray'
+ 'mixedArray',
+ 'denseArray_showHidden',
  ]
 });
 
-function main(conf) {
- const { n, len, type } = conf;
+function main({ n, len, type }) {
  var arr = Array(len);
- var i;
+ var i, opts;
 
  switch (type) {
+ case 'denseArray_showHidden':
+ opts = { showHidden: true };
+ arr = arr.fill('denseArray');
+ break;
  case 'denseArray':
- arr = arr.fill(0);
+ arr = arr.fill('denseArray');
  break;
  case 'sparseArray':
  break;
@@ -33,7 +37,7 @@ function main(conf) {
  }
  bench.start();
  for (i = 0; i < n; i++) {
- util.inspect(arr);
+ util.inspect(arr, opts);
  }
  bench.end(n);
 }

benchmark/util/inspect-proxy.js

@@ -3,42 +3,13 @@
 const util = require('util');
 const common = require('../common.js');
 
-const bench = common.createBenchmark(main, {
- v: [1, 2],
- n: [1e6]
-});
+const bench = common.createBenchmark(main, { n: [1e6] });
 
-function twoDifferentProxies(n) {
- // This one should be slower because we're looking up multiple proxies.
+function main({ n }) {
  const proxyA = new Proxy({}, { get: () => {} });
- const proxyB = new Proxy({}, { get: () => {} });
+ const proxyB = new Proxy(() => {}, {});
  bench.start();
  for (var i = 0; i < n; i += 1)
  util.inspect({ a: proxyA, b: proxyB }, { showProxy: true });
  bench.end(n);
 }
-
-function oneProxy(n) {
- // This one should be a bit faster because of the internal caching.
- const proxy = new Proxy({}, { get: () => {} });
- bench.start();
- for (var i = 0; i < n; i += 1)
- util.inspect({ a: proxy, b: proxy }, { showProxy: true });
- bench.end(n);
-}
-
-function main(conf) {
- const n = conf.n | 0;
- const v = conf.v | 0;
-
- switch (v) {
- case 1:
- oneProxy(n);
- break;
- case 2:
- twoDifferentProxies(n);
- break;
- default:
- throw new Error('Should not get to here');
- }
-}

benchmark/util/inspect.js

@@ -3,14 +3,96 @@ var util = require('util');
 
 var common = require('../common.js');
 
-var bench = common.createBenchmark(main, { n: [5e6] });
-
-function main(conf) {
- var n = conf.n | 0;
+const opts = {
+ showHidden: { showHidden: true },
+ colors: { colors: true },
+ none: undefined
+};
+var bench = common.createBenchmark(main, {
+ n: [2e6],
+ method: [
+ 'Object',
+ 'Object_empty',
+ 'Object_deep_ln',
+ 'String',
+ 'String_complex',
+ 'String_boxed',
+ 'Date',
+ 'Set',
+ 'Error',
+ 'Array',
+ 'TypedArray',
+ 'TypedArray_extra'
+ ],
+ option: Object.keys(opts)
+});
 
+function benchmark(n, obj, options) {
  bench.start();
  for (var i = 0; i < n; i += 1) {
- util.inspect({ a: 'a', b: 'b', c: 'c', d: 'd' });
+ util.inspect(obj, options);
  }
  bench.end(n);
 }
+
+function main({ method, n, option }) {
+ var obj;
+ const options = opts[option];
+ switch (method) {
+ case 'Object':
+ benchmark(n, { a: 'a', b: 'b', c: 'c', d: 'd' }, options);
+ break;
+ case 'Object_empty':
+ benchmark(n, {}, options);
+ break;
+ case 'Object_deep_ln':
+ if (options)
+ options.depth = Infinity;
+ obj = { first:
+ { second:
+ { third:
+ { a: 'first',
+ b: 'second',
+ c: 'third',
+ d: 'fourth',
+ e: 'fifth',
+ f: 'sixth',
+ g: 'seventh' } } } };
+ benchmark(n, obj, options || { depth: Infinity });
+ break;
+ case 'String':
+ benchmark(n, 'Simple string', options);
+ break;
+ case 'String_complex':
+ benchmark(n, 'This string\nhas to be\tescaped!', options);
+ break;
+ case 'String_boxed':
+ benchmark(n, new String('string'), options);
+ break;
+ case 'Date':
+ benchmark(n, new Date(), options);
+ break;
+ case 'Set':
+ obj = new Set([5, 3]);
+ benchmark(n, obj, options);
+ break;
+ case 'Error':
+ benchmark(n, new Error('error'), options);
+ break;
+ case 'Array':
+ benchmark(n, Array(20).fill().map((_, i) => i), options);
+ break;
+ case 'TypedArray':
+ obj = new Uint8Array(Array(50).fill().map((_, i) => i));
+ benchmark(n, obj, options);
+ break;
+ case 'TypedArray_extra':
+ obj = new Uint8Array(Array(50).fill().map((_, i) => i));
+ obj.foo = 'bar';
+ obj[Symbol('baz')] = 5;
+ benchmark(n, obj, options);
+ break;
+ default:
+ throw new Error(`Unsupported method "${method}"`);
+ }
+}

benchmark/util/normalize-encoding.js

@@ -19,7 +19,7 @@ const inputs = [
 
 const bench = common.createBenchmark(main, {
  input: inputs.concat(Object.keys(groupedInputs)),
- n: [1e5]
+ n: [1e7]
 }, {
  flags: '--expose-internals'
 });

lib/internal/util.js

@@ -257,6 +257,20 @@ function promisify(original) {
 
 promisify.custom = kCustomPromisifiedSymbol;
 
+// The build-in Array#join is slower in v8 6.0
+function join(output, separator) {
+ var str = '';
+ if (output.length !== 0) {
+ for (var i = 0; i < output.length - 1; i++) {
+ // It is faster not to use a template string here
+ str += output[i];
+ str += separator;
+ }
+ str += output[i];
+ }
+ return str;
+}
+
 module.exports = {
  assertCrypto,
  cachedResult,
@@ -270,6 +284,7 @@ module.exports = {
  normalizeEncoding,
  objectToString,
  promisify,
+ join,
 
  // Symbol used to customize promisify conversion
  customPromisifyArgs: kCustomPromisifyArgsSymbol,