benchmark: refactor buffer benchmarks

Currently the buffer benchmarks take significantly too long to
complete. This drastically reduces the overall runtime by removing
obsolete checked variations and reducing the iteration count.

It also improves the benchmarks by removing the deprecated
`new Buffer(size)` usage and some other small improvements.

PR-URL: #26418
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Peter Marshall <petermarshall@chromium.org>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>

benchmark/buffers/buffer-bytelength.js

@@ -3,8 +3,8 @@ const common = require('../common');
 
 const bench = common.createBenchmark(main, {
   encoding: ['utf8', 'base64', 'buffer'],
-  len: [1, 2, 4, 16, 64, 256], // x16
-  n: [5e6]
+  len: [2, 16, 256], // x16
+  n: [4e6]
 });
 
 // 16 chars each

benchmark/buffers/buffer-compare-instance-method.js

@@ -2,8 +2,8 @@
 const common = require('../common.js');
 
 const bench = common.createBenchmark(main, {
-  size: [16, 512, 1024, 4096, 16386],
-  args: [1, 2, 3, 4, 5],
+  size: [16, 512, 4096, 16386],
+  args: [1, 2, 5],
   n: [1e6]
 });
 
@@ -16,22 +16,6 @@ function main({ n, size, args }) {
 
   b1[size - 1] = 'b'.charCodeAt(0);
 
-  switch (args) {
-    case 2:
-      b0.compare(b1, 0);
-      break;
-    case 3:
-      b0.compare(b1, 0, b1Len);
-      break;
-    case 4:
-      b0.compare(b1, 0, b1Len, 0);
-      break;
-    case 5:
-      b0.compare(b1, 0, b1Len, 0, b0Len);
-      break;
-    default:
-      b0.compare(b1);
-  }
   switch (args) {
     case 2:
       b0.compare(b1, 0);

benchmark/buffers/buffer-compare-offset.js

@@ -3,7 +3,7 @@ const common = require('../common.js');
 
 const bench = common.createBenchmark(main, {
   method: ['offset', 'slice'],
-  size: [16, 512, 1024, 4096, 16386],
+  size: [16, 512, 4096, 16386],
   n: [1e6]
 });
 

benchmark/buffers/buffer-compare.js

@@ -23,7 +23,7 @@
 const common = require('../common.js');
 
 const bench = common.createBenchmark(main, {
-  size: [16, 512, 1024, 4096, 16386],
+  size: [16, 512, 4096, 16386],
   n: [1e6]
 });
 

benchmark/buffers/buffer-concat.js

@@ -2,20 +2,20 @@
 const common = require('../common.js');
 
 const bench = common.createBenchmark(main, {
-  pieces: [1, 4, 16],
+  pieces: [4, 16],
   pieceSize: [1, 16, 256],
   withTotalLength: [0, 1],
-  n: [1024]
+  n: [8e5]
 });
 
 function main({ n, pieces, pieceSize, withTotalLength }) {
-  const list = new Array(pieces);
-  list.fill(Buffer.allocUnsafe(pieceSize));
+  const list = Array.from({ length: pieces })
+    .fill(Buffer.allocUnsafe(pieceSize));
 
   const totalLength = withTotalLength ? pieces * pieceSize : undefined;
 
   bench.start();
-  for (var i = 0; i < n * 1024; i++) {
+  for (var i = 0; i < n; i++) {
     Buffer.concat(list, totalLength);
   }
   bench.end(n);

benchmark/buffers/buffer-creation.js

@@ -1,5 +1,4 @@
 'use strict';
-const SlowBuffer = require('buffer').SlowBuffer;
 
 const common = require('../common.js');
 const assert = require('assert');
@@ -9,10 +8,9 @@ const bench = common.createBenchmark(main, {
     'fast-alloc-fill',
     'fast-allocUnsafe',
     'slow-allocUnsafe',
-    'slow',
-    'buffer()'],
-  len: [10, 1024, 2048, 4096, 8192],
-  n: [1024]
+  ],
+  len: [10, 1024, 4096, 8192],
+  n: [6e5]
 });
 
 function main({ len, n, type }) {
@@ -24,7 +22,7 @@ function main({ len, n, type }) {
       break;
     case 'fast-alloc-fill':
       bench.start();
-      for (i = 0; i < n * 1024; i++) {
+      for (i = 0; i < n; i++) {
         Buffer.alloc(len, 0);
       }
       bench.end(n);
@@ -35,18 +33,12 @@ function main({ len, n, type }) {
     case 'slow-allocUnsafe':
       fn = Buffer.allocUnsafeSlow;
       break;
-    case 'slow':
-      fn = SlowBuffer;
-      break;
-    case 'buffer()':
-      fn = Buffer;
-      break;
     default:
       assert.fail('Should not get here');
   }
 
   bench.start();
-  for (i = 0; i < n * 1024; i++) {
+  for (i = 0; i < n; i++) {
     fn(len);
   }
   bench.end(n);

benchmark/buffers/buffer-fill.js

@@ -14,7 +14,7 @@ const bench = common.createBenchmark(main, {
     'fill("t", 0)',
     'fill(Buffer.alloc(1), 0)',
   ],
-  size: [2 ** 8, 2 ** 13, 2 ** 16],
+  size: [2 ** 13, 2 ** 16],
   n: [2e4]
 });
 

benchmark/buffers/buffer-from.js

@@ -8,14 +8,13 @@ const bench = common.createBenchmark(main, {
     'arraybuffer',
     'arraybuffer-middle',
     'buffer',
-    'uint8array',
     'string',
     'string-utf8',
     'string-base64',
     'object',
   ],
-  len: [10, 2048],
-  n: [2048]
+  len: [100, 2048],
+  n: [8e5]
 });
 
 function main({ len, n, source }) {
@@ -26,17 +25,19 @@ function main({ len, n, source }) {
   const uint8array = new Uint8Array(len);
   const obj = { length: null }; // Results in a new, empty Buffer
 
+  let i = 0;
+
   switch (source) {
     case 'array':
       bench.start();
-      for (let i = 0; i < n * 1024; i++) {
+      for (i = 0; i < n; i++) {
         Buffer.from(array);
       }
       bench.end(n);
       break;
     case 'arraybuffer':
       bench.start();
-      for (let i = 0; i < n * 1024; i++) {
+      for (i = 0; i < n; i++) {
         Buffer.from(arrayBuf);
       }
       bench.end(n);
@@ -45,49 +46,49 @@ function main({ len, n, source }) {
       const offset = ~~(len / 4);
       const length = ~~(len / 2);
       bench.start();
-      for (let i = 0; i < n * 1024; i++) {
+      for (i = 0; i < n; i++) {
         Buffer.from(arrayBuf, offset, length);
       }
       bench.end(n);
       break;
     case 'buffer':
       bench.start();
-      for (let i = 0; i < n * 1024; i++) {
+      for (i = 0; i < n; i++) {
         Buffer.from(buffer);
       }
       bench.end(n);
       break;
     case 'uint8array':
       bench.start();
-      for (let i = 0; i < n * 1024; i++) {
+      for (i = 0; i < n; i++) {
         Buffer.from(uint8array);
       }
       bench.end(n);
       break;
     case 'string':
       bench.start();
-      for (let i = 0; i < n * 1024; i++) {
+      for (i = 0; i < n; i++) {
         Buffer.from(str);
       }
       bench.end(n);
       break;
     case 'string-utf8':
       bench.start();
-      for (let i = 0; i < n * 1024; i++) {
+      for (i = 0; i < n; i++) {
         Buffer.from(str, 'utf8');
       }
       bench.end(n);
       break;
     case 'string-base64':
       bench.start();
-      for (let i = 0; i < n * 1024; i++) {
+      for (i = 0; i < n; i++) {
         Buffer.from(str, 'base64');
       }
       bench.end(n);
       break;
     case 'object':
       bench.start();
-      for (let i = 0; i < n * 1024; i++) {
+      for (i = 0; i < n; i++) {
         Buffer.from(obj);
       }
       bench.end(n);

benchmark/buffers/buffer-hex.js

@@ -3,8 +3,8 @@
 const common = require('../common.js');
 
 const bench = common.createBenchmark(main, {
-  len: [0, 1, 64, 1024],
-  n: [1e7]
+  len: [64, 1024],
+  n: [1e6]
 });
 
 function main({ len, n }) {

benchmark/buffers/buffer-indexof-number.js

@@ -5,17 +5,19 @@ const path = require('path');
 
 const bench = common.createBenchmark(main, {
   value: ['@'.charCodeAt(0)],
-  n: [1e7]
+  n: [1e6]
 });
 
 function main({ n, value }) {
   const aliceBuffer = fs.readFileSync(
     path.resolve(__dirname, '../fixtures/alice.html')
   );
 
+  let count = 0;
   bench.start();
   for (var i = 0; i < n; i++) {
-    aliceBuffer.indexOf(value, 0, undefined);
+    count += aliceBuffer.indexOf(value, 0, undefined);
   }
   bench.end(n);
+  return count;
 }

benchmark/buffers/buffer-indexof.js

@@ -6,26 +6,22 @@ const path = require('path');
 const searchStrings = [
   '@',
   'SQ',
-  '10x',
   '--l',
   'Alice',
   'Gryphon',
-  'Panther',
   'Ou est ma chatte?',
   'found it very',
-  'among mad people',
   'neighbouring pool',
-  'Soo--oop',
   'aaaaaaaaaaaaaaaaa',
   'venture to go near the house till she had brought herself down to',
   '</i> to the Caterpillar',
 ];
 
 const bench = common.createBenchmark(main, {
   search: searchStrings,
-  encoding: ['undefined', 'utf8', 'ucs2', 'binary'],
+  encoding: ['utf8', 'ucs2'],
   type: ['buffer', 'string'],
-  n: [100000]
+  n: [5e4]
 });
 
 function main({ n, search, encoding, type }) {

benchmark/buffers/buffer-iterate.js

@@ -4,8 +4,8 @@ const common = require('../common.js');
 const assert = require('assert');
 
 const bench = common.createBenchmark(main, {
-  size: [16, 512, 1024, 4096, 16386],
-  type: ['fast', 'slow'],
+  size: [512, 4096, 16386],
+  type: ['fast'],
   method: ['for', 'forOf', 'iterator'],
   n: [1e3]
 });
@@ -17,9 +17,10 @@ const methods = {
 };
 
 function main({ size, type, method, n }) {
-  const clazz = type === 'fast' ? Buffer : SlowBuffer;
-  const buffer = new clazz(size);
-  buffer.fill(0);
+  const buffer = type === 'fast' ?
+    Buffer.alloc(size) :
+    SlowBuffer(size).fill(0);
+
   const fn = methods[method || 'for'];
 
   bench.start();
@@ -46,7 +47,7 @@ function benchForOf(buffer, n) {
 function benchIterator(buffer, n) {
   for (var k = 0; k < n; k++) {
     const iter = buffer[Symbol.iterator]();
-    var cur = iter.next();
+    let cur = iter.next();
 
     while (!cur.done) {
       assert(cur.value === 0);

benchmark/buffers/buffer-normalize-encoding.js

@@ -5,23 +5,18 @@ const common = require('../common.js');
 const bench = common.createBenchmark(main, {
   encoding: [
     'ascii',
-    'ASCII',
     'base64',
     'BASE64',
     'binary',
-    'BINARY',
     'hex',
     'HEX',
     'latin1',
     'LATIN1',
-    'ucs-2',
     'UCS-2',
-    'ucs2',
     'UCS2',
     'utf-16le',
     'UTF-16LE',
     'utf-8',
-    'UTF-8',
     'utf16le',
     'UTF16LE',
     'utf8',

benchmark/buffers/buffer-read-float.js

@@ -3,7 +3,7 @@ const common = require('../common.js');
 
 const bench = common.createBenchmark(main, {
   type: ['Double', 'Float'],
-  endian: ['BE', 'LE'],
+  endian: ['LE'],
   value: ['zero', 'big', 'small', 'inf', 'nan'],
   n: [1e6]
 });

benchmark/buffers/buffer-read-with-byteLength.js

@@ -9,15 +9,16 @@ const types = [
 ];
 
 const bench = common.createBenchmark(main, {
-  buffer: ['fast', 'slow'],
+  buffer: ['fast'],
   type: types,
   n: [1e6],
   byteLength: [1, 2, 3, 4, 5, 6]
 });
 
 function main({ n, buf, type, byteLength }) {
-  const clazz = buf === 'fast' ? Buffer : require('buffer').SlowBuffer;
-  const buff = new clazz(8);
+  const buff = buf === 'fast' ?
+    Buffer.alloc(8) :
+    require('buffer').SlowBuffer(8);
   const fn = `read${type || 'IntBE'}`;
 
   buff.writeDoubleLE(0, 0);