benchmark: refactor buffer benchmarks

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);