benchmark: (buffer) refactor

PR-URL: nodejs#18320
Reviewed-By: James M Snell <jasnell@gmail.com>

benchmark/buffers/buffer-bytelength.js

@@ -21,10 +21,9 @@ function main(conf) {
   const encoding = conf.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

benchmark/buffers/buffer-compare-offset.js

@@ -8,28 +8,22 @@ const bench = common.createBenchmark(main, {
 });
 
 function compareUsingSlice(b0, b1, len, iter) {
-  var i;
-  bench.start();
-  for (i = 0; i < iter; i++)
+  for (var i = 0; i < iter; i++)
     Buffer.compare(b0.slice(1, len), b1.slice(1, len));
-  bench.end(iter / 1e6);
 }
 
 function compareUsingOffset(b0, b1, len, iter) {
-  var i;
-  bench.start();
-  for (i = 0; i < iter; i++)
+  for (var i = 0; i < iter; i++)
     b0.compare(b1, 1, len, 1, len);
-  bench.end(iter / 1e6);
 }
 
-function main(conf) {
-  const iter = (conf.millions >>> 0) * 1e6;
-  const size = (conf.size >>> 0);
-  const method =
-    conf.method === 'slice' ? compareUsingSlice : compareUsingOffset;
-  method(Buffer.alloc(size, 'a'),
-         Buffer.alloc(size, 'b'),
-         size >> 1,
-         iter);
+function main({ millions, size, method }) {
+  const iter = millions * 1e6;
+  const fn = method === 'slice' ? compareUsingSlice : compareUsingOffset;
+  bench.start();
+  fn(Buffer.alloc(size, 'a'),
+     Buffer.alloc(size, 'b'),
+     size >> 1,
+     iter);
+  bench.end(millions);
 }

benchmark/buffers/buffer-creation.js

@@ -15,54 +15,39 @@ const bench = common.createBenchmark(main, {
   n: [1024]
 });
 
-function main(conf) {
-  const len = +conf.len;
-  const n = +conf.n;
-  switch (conf.type) {
+function main({ len, n, type }) {
+  let fn, i;
+  switch (type) {
     case '':
     case 'fast-alloc':
-      bench.start();
-      for (let i = 0; i < n * 1024; i++) {
-        Buffer.alloc(len);
-      }
-      bench.end(n);
+      fn = Buffer.alloc;
       break;
     case 'fast-alloc-fill':
       bench.start();
-      for (let i = 0; i < n * 1024; i++) {
+      for (i = 0; i < n * 1024; i++) {
         Buffer.alloc(len, 0);
       }
       bench.end(n);
-      break;
+      return;
     case 'fast-allocUnsafe':
-      bench.start();
-      for (let i = 0; i < n * 1024; i++) {
-        Buffer.allocUnsafe(len);
-      }
-      bench.end(n);
+      fn = Buffer.allocUnsafe;
       break;
     case 'slow-allocUnsafe':
-      bench.start();
-      for (let i = 0; i < n * 1024; i++) {
-        Buffer.allocUnsafeSlow(len);
-      }
-      bench.end(n);
+      fn = Buffer.allocUnsafeSlow;
       break;
     case 'slow':
-      bench.start();
-      for (let i = 0; i < n * 1024; i++) {
-        SlowBuffer(len);
-      }
-      bench.end(n);
+      fn = SlowBuffer;
       break;
     case 'buffer()':
-      bench.start();
-      for (let i = 0; i < n * 1024; i++) {
-        Buffer(len);
-      }
-      bench.end(n);
+      fn = Buffer;
       break;
     default:
-      assert.fail(null, null, 'Should not get here');
+      assert.fail('Should not get here');
+  }
+
+  bench.start();
+  for (i = 0; i < n * 1024; i++) {
+    fn(len);
   }
+  bench.end(n);
 }

benchmark/buffers/buffer-hex.js

@@ -11,15 +11,16 @@ function main(conf) {
   const len = conf.len | 0;
   const n = conf.n | 0;
   const buf = Buffer.alloc(len);
+  var i;
 
-  for (let i = 0; i < buf.length; i++)
+  for (i = 0; i < buf.length; i++)
     buf[i] = i & 0xff;
 
   const hex = buf.toString('hex');
 
   bench.start();
 
-  for (let i = 0; i < n; i += 1)
+  for (i = 0; i < n; i += 1)
     Buffer.from(hex, 'hex');
 
   bench.end(n);

benchmark/buffers/buffer-iterate.js

@@ -26,33 +26,23 @@ function main(conf) {
   methods[method](buffer, conf.n);
 }
 
-
 function benchFor(buffer, n) {
-  bench.start();
-
   for (var k = 0; k < n; k++) {
     for (var i = 0; i < buffer.length; i++) {
       assert(buffer[i] === 0);
     }
   }
-
-  bench.end(n);
 }
 
 function benchForOf(buffer, n) {
-  bench.start();
-
   for (var k = 0; k < n; k++) {
     for (const b of buffer) {
       assert(b === 0);
     }
   }
-  bench.end(n);
 }
 
 function benchIterator(buffer, n) {
-  bench.start();
-
   for (var k = 0; k < n; k++) {
     const iter = buffer[Symbol.iterator]();
     var cur = iter.next();
@@ -63,6 +53,4 @@ function benchIterator(buffer, n) {
     }
 
   }
-
-  bench.end(n);
 }

benchmark/buffers/buffer-read-float.js

@@ -0,0 +1,41 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  noAssert: ['false', 'true'],
+  type: ['Double', 'Float'],
+  endian: ['BE', 'LE'],
+  value: ['zero', 'big', 'small', 'inf', 'nan'],
+  millions: [1]
+});
+
+function main({ noAssert, millions, type, endian, value }) {
+  noAssert = noAssert === 'true';
+  type = type || 'Double';
+  const buff = Buffer.alloc(8);
+  const fn = `read${type}${endian}`;
+  const values = {
+    Double: {
+      zero: 0,
+      big: 2 ** 1023,
+      small: 2 ** -1074,
+      inf: Infinity,
+      nan: NaN,
+    },
+    Float: {
+      zero: 0,
+      big: 2 ** 127,
+      small: 2 ** -149,
+      inf: Infinity,
+      nan: NaN,
+    },
+  };
+
+  buff[`write${type}${endian}`](values[type][value], 0, noAssert);
+
+  bench.start();
+  for (var i = 0; i !== millions * 1e6; i++) {
+    buff[fn](0, noAssert);
+  }
+  bench.end(millions);
+}

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

@@ -0,0 +1,32 @@
+'use strict';
+const common = require('../common.js');
+
+const types = [
+  'IntBE',
+  'IntLE',
+  'UIntBE',
+  'UIntLE'
+];
+
+const bench = common.createBenchmark(main, {
+  noAssert: ['false', 'true'],
+  buffer: ['fast', 'slow'],
+  type: types,
+  millions: [1],
+  byteLength: [1, 2, 4, 6]
+});
+
+function main({ millions, noAssert, buf, type, byteLength }) {
+  noAssert = noAssert === 'true';
+  type = type || 'UInt8';
+  const clazz = buf === 'fast' ? Buffer : require('buffer').SlowBuffer;
+  const buff = new clazz(8);
+  const fn = `read${type}`;
+
+  buff.writeDoubleLE(0, 0, noAssert);
+  bench.start();
+  for (var i = 0; i !== millions * 1e6; i++) {
+    buff[fn](0, byteLength, noAssert);
+  }
+  bench.end(millions);
+}

benchmark/buffers/buffer-read.js

@@ -25,21 +25,17 @@ const bench = common.createBenchmark(main, {
   millions: [1]
 });
 
-function main(conf) {
-  const noAssert = conf.noAssert === 'true';
-  const len = +conf.millions * 1e6;
-  const clazz = conf.buf === 'fast' ? Buffer : require('buffer').SlowBuffer;
+function main({ noAssert, millions, buf, type }) {
+  noAssert = noAssert === 'true';
+  const clazz = buf === 'fast' ? Buffer : require('buffer').SlowBuffer;
   const buff = new clazz(8);
   const type = conf.type || 'UInt8';
   const fn = `read${type}`;
 
   buff.writeDoubleLE(0, 0, noAssert);
-  const testFunction = new Function('buff', `
-    for (var i = 0; i !== ${len}; i++) {
-      buff.${fn}(0, ${JSON.stringify(noAssert)});
-    }
-  `);
   bench.start();
-  testFunction(buff);
-  bench.end(len / 1e6);
+  for (var i = 0; i !== millions * 1e6; i++) {
+    buff[fn](0, noAssert);
+  }
+  bench.end(millions);
 }

benchmark/buffers/buffer-write.js

@@ -45,39 +45,31 @@ const mod = {
   writeUInt32LE: UINT32
 };
 
-function main(conf) {
-  const noAssert = conf.noAssert === 'true';
-  const len = +conf.millions * 1e6;
-  const clazz = conf.buf === 'fast' ? Buffer : require('buffer').SlowBuffer;
+function main({ noAssert, millions, buf, type }) {
+  const clazz = buf === 'fast' ? Buffer : require('buffer').SlowBuffer;
   const buff = new clazz(8);
   const type = conf.type || 'UInt8';
   const fn = `write${type}`;
 
   if (/Int/.test(fn))
-    benchInt(buff, fn, len, noAssert);
+    benchInt(buff, fn, millions, noAssert);
   else
-    benchFloat(buff, fn, len, noAssert);
+    benchFloat(buff, fn, millions, noAssert);
 }
 
-function benchInt(buff, fn, len, noAssert) {
+function benchInt(buff, fn, millions, noAssert) {
   const m = mod[fn];
-  const testFunction = new Function('buff', `
-    for (var i = 0; i !== ${len}; i++) {
-      buff.${fn}(i & ${m}, 0, ${JSON.stringify(noAssert)});
-    }
-  `);
   bench.start();
-  testFunction(buff);
-  bench.end(len / 1e6);
+  for (var i = 0; i !== millions * 1e6; i++) {
+    buff[fn](i & m, 0, noAssert);
+  }
+  bench.end(millions);
 }
 
-function benchFloat(buff, fn, len, noAssert) {
-  const testFunction = new Function('buff', `
-    for (var i = 0; i !== ${len}; i++) {
-      buff.${fn}(i, 0, ${JSON.stringify(noAssert)});
-    }
-  `);
+function benchFloat(buff, fn, millions, noAssert) {
   bench.start();
-  testFunction(buff);
-  bench.end(len / 1e6);
+  for (var i = 0; i !== millions * 1e6; i++) {
+    buff[fn](i, 0, noAssert);
+  }
+  bench.end(millions);
 }

benchmark/buffers/buffer_zero.js

@@ -10,14 +10,10 @@ const bench = common.createBenchmark(main, {
 const zeroBuffer = Buffer.alloc(0);
 const zeroString = '';
 
-function main(conf) {
-  const n = +conf.n;
-  bench.start();
-
-  if (conf.type === 'buffer')
-    for (let i = 0; i < n * 1024; i++) Buffer.from(zeroBuffer);
-  else if (conf.type === 'string')
-    for (let i = 0; i < n * 1024; i++) Buffer.from(zeroString);
+function main({ n, type }) {
+  const data = type === 'buffer' ? zeroBuffer : zeroString;
 
+  bench.start();
+  for (var i = 0; i < n * 1024; i++) Buffer.from(data);
   bench.end(n);
 }