benchmarks: improve code base

benchmark/assert/deepequal-buffer.js

@@ -14,8 +14,6 @@ const bench = common.createBenchmark(main, {
 });
 
 function main({ len, n, method }) {
-  var i;
-
   const data = Buffer.allocUnsafe(len + 1);
   const actual = Buffer.alloc(len);
   const expected = Buffer.alloc(len);
@@ -24,40 +22,13 @@ function main({ len, n, method }) {
   data.copy(expected);
   data.copy(expectedWrong);
 
-  switch (method) {
-    case '':
-      // Empty string falls through to next line as default, mostly for tests.
-    case 'deepEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        // eslint-disable-next-line no-restricted-properties
-        assert.deepEqual(actual, expected);
-      }
-      bench.end(n);
-      break;
-    case 'deepStrictEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        assert.deepStrictEqual(actual, expected);
-      }
-      bench.end(n);
-      break;
-    case 'notDeepEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        // eslint-disable-next-line no-restricted-properties
-        assert.notDeepEqual(actual, expectedWrong);
-      }
-      bench.end(n);
-      break;
-    case 'notDeepStrictEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        assert.notDeepStrictEqual(actual, expectedWrong);
-      }
-      bench.end(n);
-      break;
-    default:
-      throw new Error('Unsupported method');
+  // eslint-disable-next-line no-restricted-properties
+  const fn = method !== '' ? assert[method] : assert.deepEqual;
+  const value2 = method.includes('not') ? expectedWrong : expected;
+
+  bench.start();
+  for (var i = 0; i < n; ++i) {
+    fn(actual, value2);
   }
+  bench.end(n);
 }

benchmark/assert/deepequal-map.js

@@ -117,6 +117,6 @@ function main({ n, len, method }) {
       benchmark(assert.notDeepEqual, n, values, values2);
       break;
     default:
-      throw new Error('Unsupported method');
+      throw new Error(`Unsupported method ${method}`);
   }
 }

benchmark/assert/deepequal-object.js

@@ -28,47 +28,19 @@ function createObj(source, add = '') {
 function main({ size, n, method }) {
   // TODO: Fix this "hack". `n` should not be manipulated.
   n = n / size;
-  var i;
 
   const source = Array.apply(null, Array(size));
   const actual = createObj(source);
   const expected = createObj(source);
   const expectedWrong = createObj(source, '4');
 
-  switch (method) {
-    case '':
-      // Empty string falls through to next line as default, mostly for tests.
-    case 'deepEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        // eslint-disable-next-line no-restricted-properties
-        assert.deepEqual(actual, expected);
-      }
-      bench.end(n);
-      break;
-    case 'deepStrictEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        assert.deepStrictEqual(actual, expected);
-      }
-      bench.end(n);
-      break;
-    case 'notDeepEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        // eslint-disable-next-line no-restricted-properties
-        assert.notDeepEqual(actual, expectedWrong);
-      }
-      bench.end(n);
-      break;
-    case 'notDeepStrictEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        assert.notDeepStrictEqual(actual, expectedWrong);
-      }
-      bench.end(n);
-      break;
-    default:
-      throw new Error('Unsupported method');
+  // eslint-disable-next-line no-restricted-properties
+  const fn = method !== '' ? assert[method] : assert.deepEqual;
+  const value2 = method.includes('not') ? expectedWrong : expected;
+
+  bench.start();
+  for (var i = 0; i < n; ++i) {
+    fn(actual, value2);
   }
+  bench.end(n);
 }

benchmark/assert/deepequal-prims-and-objs-big-array-set.js

@@ -30,12 +30,19 @@ const bench = common.createBenchmark(main, {
   ]
 });
 
+function run(fn, n, actual, expected) {
+  bench.start();
+  for (var i = 0; i < n; ++i) {
+    fn(actual, expected);
+  }
+  bench.end(n);
+}
+
 function main({ n, len, primitive, method }) {
   const prim = primValues[primitive];
   const actual = [];
   const expected = [];
   const expectedWrong = [];
-  var i;
 
   for (var x = 0; x < len; x++) {
     actual.push(prim);
@@ -51,69 +58,37 @@ function main({ n, len, primitive, method }) {
   const expectedWrongSet = new Set(expectedWrong);
 
   switch (method) {
+    // Empty string falls through to next line as default, mostly for tests.
     case '':
-      // Empty string falls through to next line as default, mostly for tests.
     case 'deepEqual_Array':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        // eslint-disable-next-line no-restricted-properties
-        assert.deepEqual(actual, expected);
-      }
-      bench.end(n);
+      // eslint-disable-next-line no-restricted-properties
+      run(assert.deepEqual, n, actual, expected);
       break;
     case 'deepStrictEqual_Array':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        assert.deepStrictEqual(actual, expected);
-      }
-      bench.end(n);
+      run(assert.deepStrictEqual, n, actual, expected);
       break;
     case 'notDeepEqual_Array':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        // eslint-disable-next-line no-restricted-properties
-        assert.notDeepEqual(actual, expectedWrong);
-      }
-      bench.end(n);
+      // eslint-disable-next-line no-restricted-properties
+      run(assert.notDeepEqual, n, actual, expectedWrong);
       break;
     case 'notDeepStrictEqual_Array':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        assert.notDeepStrictEqual(actual, expectedWrong);
-      }
-      bench.end(n);
+      run(assert.notDeepStrictEqual, n, actual, expectedWrong);
       break;
     case 'deepEqual_Set':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        // eslint-disable-next-line no-restricted-properties
-        assert.deepEqual(actualSet, expectedSet);
-      }
-      bench.end(n);
+      // eslint-disable-next-line no-restricted-properties
+      run(assert.deepEqual, n, actualSet, expectedSet);
       break;
     case 'deepStrictEqual_Set':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        assert.deepStrictEqual(actualSet, expectedSet);
-      }
-      bench.end(n);
+      run(assert.deepStrictEqual, n, actualSet, expectedSet);
       break;
     case 'notDeepEqual_Set':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        // eslint-disable-next-line no-restricted-properties
-        assert.notDeepEqual(actualSet, expectedWrongSet);
-      }
-      bench.end(n);
+      // eslint-disable-next-line no-restricted-properties
+      run(assert.notDeepEqual, n, actualSet, expectedWrongSet);
       break;
     case 'notDeepStrictEqual_Set':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        assert.notDeepStrictEqual(actualSet, expectedWrongSet);
-      }
-      bench.end(n);
+      run(assert.notDeepStrictEqual, n, actualSet, expectedWrongSet);
       break;
     default:
-      throw new Error('Unsupported method');
+      throw new Error(`Unsupported method "${method}"`);
   }
 }

benchmark/assert/deepequal-prims-and-objs-big-loop.js

@@ -29,43 +29,14 @@ function main({ n, primitive, method }) {
   const actual = prim;
   const expected = prim;
   const expectedWrong = 'b';
-  var i;
 
-  // Creates new array to avoid loop invariant code motion
-  switch (method) {
-    case '':
-      // Empty string falls through to next line as default, mostly for tests.
-    case 'deepEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        // eslint-disable-next-line no-restricted-properties
-        assert.deepEqual([actual], [expected]);
-      }
-      bench.end(n);
-      break;
-    case 'deepStrictEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        assert.deepStrictEqual([actual], [expected]);
-      }
-      bench.end(n);
-      break;
-    case 'notDeepEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        // eslint-disable-next-line no-restricted-properties
-        assert.notDeepEqual([actual], [expectedWrong]);
-      }
-      bench.end(n);
-      break;
-    case 'notDeepStrictEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        assert.notDeepStrictEqual([actual], [expectedWrong]);
-      }
-      bench.end(n);
-      break;
-    default:
-      throw new Error('Unsupported method');
+  // eslint-disable-next-line no-restricted-properties
+  const fn = method !== '' ? assert[method] : assert.deepEqual;
+  const value2 = method.includes('not') ? expectedWrong : expected;
+
+  bench.start();
+  for (var i = 0; i < n; ++i) {
+    fn([actual], [value2]);
   }
+  bench.end(n);
 }

benchmark/assert/deepequal-set.js

@@ -126,6 +126,6 @@ function main({ n, len, method }) {
       benchmark(assert.notDeepEqual, n, values, values2);
       break;
     default:
-      throw new Error('Unsupported method');
+      throw new Error(`Unsupported method "${method}"`);
   }
 }

benchmark/assert/deepequal-typedarrays.js

@@ -31,42 +31,14 @@ function main({ type, n, len, method }) {
   const expectedWrong = Buffer.alloc(len);
   const wrongIndex = Math.floor(len / 2);
   expectedWrong[wrongIndex] = 123;
-  var i;
 
-  switch (method) {
-    case '':
-      // Empty string falls through to next line as default, mostly for tests.
-    case 'deepEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        // eslint-disable-next-line no-restricted-properties
-        assert.deepEqual(actual, expected);
-      }
-      bench.end(n);
-      break;
-    case 'deepStrictEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        assert.deepStrictEqual(actual, expected);
-      }
-      bench.end(n);
-      break;
-    case 'notDeepEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        // eslint-disable-next-line no-restricted-properties
-        assert.notDeepEqual(actual, expectedWrong);
-      }
-      bench.end(n);
-      break;
-    case 'notDeepStrictEqual':
-      bench.start();
-      for (i = 0; i < n; ++i) {
-        assert.notDeepStrictEqual(actual, expectedWrong);
-      }
-      bench.end(n);
-      break;
-    default:
-      throw new Error('Unsupported method');
+  // eslint-disable-next-line no-restricted-properties
+  const fn = method !== '' ? assert[method] : assert.deepEqual;
+  const value2 = method.includes('not') ? expectedWrong : expected;
+
+  bench.start();
+  for (var i = 0; i < n; ++i) {
+    fn(actual, value2);
   }
+  bench.end(n);
 }

benchmark/async_hooks/gc-tracking.js

@@ -22,22 +22,23 @@ function endAfterGC(n) {
 }
 
 function main({ n, method }) {
+  var i;
   switch (method) {
     case 'trackingEnabled':
       bench.start();
-      for (let i = 0; i < n; i++) {
+      for (i = 0; i < n; i++) {
         new AsyncResource('foobar');
       }
       endAfterGC(n);
       break;
     case 'trackingDisabled':
       bench.start();
-      for (let i = 0; i < n; i++) {
+      for (i = 0; i < n; i++) {
         new AsyncResource('foobar', { requireManualDestroy: true });
       }
       endAfterGC(n);
       break;
     default:
-      throw new Error('Unsupported method');
+      throw new Error(`Unsupported method "${method}"`);
   }
 }

benchmark/buffers/buffer-bytelength.js

@@ -17,10 +17,9 @@ const chars = [
 
 function main({ n, len, encoding }) {
   var strings = [];
-  var results;
+  var results = [ len * 16 ];
   if (encoding === 'buffer') {
     strings = [ Buffer.alloc(len * 16, 'a') ];
-    results = [ len * 16 ];
   } else {
     for (const string of chars) {
       // Strings must be built differently, depending on encoding