buffer: various performance improvements

benchmark/buffers/buffer-bytelength.js

@@ -2,7 +2,7 @@
 var common = require('../common');
 
 var bench = common.createBenchmark(main, {
-  encoding: ['utf8', 'base64'],
+  encoding: ['utf8', 'base64', 'buffer'],
   len: [1, 2, 4, 16, 64, 256], // x16
   n: [5e6]
 });
@@ -21,21 +21,27 @@ function main(conf) {
   var encoding = conf.encoding;
 
   var strings = [];
-  for (var string of chars) {
-    // Strings must be built differently, depending on encoding
-    var data = buildString(string, len);
-    if (encoding === 'utf8') {
-      strings.push(data);
-    } else if (encoding === 'base64') {
-      // Base64 strings will be much longer than their UTF8 counterparts
-      strings.push(Buffer.from(data, 'utf8').toString('base64'));
+  var results;
+  if (encoding === 'buffer') {
+    strings = [ Buffer.alloc(len * 16, 'a') ];
+    results = [ len * 16 ];
+  } else {
+    for (var string of chars) {
+      // Strings must be built differently, depending on encoding
+      var data = buildString(string, len);
+      if (encoding === 'utf8') {
+        strings.push(data);
+      } else if (encoding === 'base64') {
+        // Base64 strings will be much longer than their UTF8 counterparts
+        strings.push(Buffer.from(data, 'utf8').toString('base64'));
+      }
     }
-  }
 
-  // Check the result to ensure it is *properly* optimized
-  var results = strings.map(function(val) {
-    return Buffer.byteLength(val, encoding);
-  });
+    // Check the result to ensure it is *properly* optimized
+    results = strings.map(function(val) {
+      return Buffer.byteLength(val, encoding);
+    });
+  }
 
   bench.start();
   for (var i = 0; i < n; i++) {

benchmark/buffers/buffer-from.js

@@ -10,11 +10,12 @@ const bench = common.createBenchmark(main, {
     'buffer',
     'uint8array',
     'string',
+    'string-utf8',
     'string-base64',
     'object'
   ],
   len: [10, 2048],
-  n: [1024]
+  n: [2048]
 });
 
 function main(conf) {
@@ -75,6 +76,13 @@ function main(conf) {
       }
       bench.end(n);
       break;
+    case 'string-utf8':
+      bench.start();
+      for (i = 0; i < n * 1024; i++) {
+        Buffer.from(str, 'utf8');
+      }
+      bench.end(n);
+      break;
     case 'string-base64':
       bench.start();
       for (i = 0; i < n * 1024; i++) {

benchmark/buffers/buffer-tostring.js

@@ -3,25 +3,47 @@
 const common = require('../common.js');
 
 const bench = common.createBenchmark(main, {
-  arg: ['true', 'false'],
+  encoding: ['', 'utf8', 'ascii', 'latin1', 'binary', 'hex', 'UCS-2'],
+  args: [0, 1, 2, 3],
   len: [0, 1, 64, 1024],
   n: [1e7]
 });
 
 function main(conf) {
-  const arg = conf.arg === 'true';
+  var encoding = conf.encoding;
+  const args = conf.args | 0;
   const len = conf.len | 0;
   const n = conf.n | 0;
   const buf = Buffer.alloc(len, 42);
 
+  if (encoding.length === 0)
+    encoding = undefined;
+
   var i;
-  bench.start();
-  if (arg) {
-    for (i = 0; i < n; i += 1)
-      buf.toString('utf8');
-  } else {
-    for (i = 0; i < n; i += 1)
-      buf.toString();
+  switch (args) {
+    case 1:
+      bench.start();
+      for (i = 0; i < n; i += 1)
+        buf.toString(encoding);
+      bench.end(n);
+      break;
+    case 2:
+      bench.start();
+      for (i = 0; i < n; i += 1)
+        buf.toString(encoding, 0);
+      bench.end(n);
+      break;
+    case 3:
+      bench.start();
+      for (i = 0; i < n; i += 1)
+        buf.toString(encoding, 0, len);
+      bench.end(n);
+      break;
+    default:
+      bench.start();
+      for (i = 0; i < n; i += 1)
+        buf.toString();
+      bench.end(n);
+      break;
   }
-  bench.end(n);
 }

benchmark/buffers/buffer-write-string.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  encoding: [
+    '', 'utf8', 'ascii', 'hex', 'UCS-2', 'utf16le', 'latin1', 'binary'
+  ],
+  args: [ '', 'offset', 'offset+length' ],
+  len: [10, 2048],
+  n: [1e7]
+});
+
+function main(conf) {
+  const len = +conf.len;
+  const n = +conf.n;
+  const encoding = conf.encoding;
+  const args = conf.args;
+
+  const string = 'a'.repeat(len);
+  const buf = Buffer.allocUnsafe(len);
+
+  var i;
+
+  switch (args) {
+    case 'offset':
+      if (encoding) {
+        bench.start();
+        for (i = 0; i < n; ++i) {
+          buf.write(string, 0, encoding);
+        }
+        bench.end(n);
+      } else {
+        bench.start();
+        for (i = 0; i < n; ++i) {
+          buf.write(string, 0);
+        }
+        bench.end(n);
+      }
+      break;
+    case 'offset+length':
+      if (encoding) {
+        bench.start();
+        for (i = 0; i < n; ++i) {
+          buf.write(string, 0, buf.length, encoding);
+        }
+        bench.end(n);
+      } else {
+        bench.start();
+        for (i = 0; i < n; ++i) {
+          buf.write(string, 0, buf.length);
+        }
+        bench.end(n);
+      }
+      break;
+    default:
+      if (encoding) {
+        bench.start();
+        for (i = 0; i < n; ++i) {
+          buf.write(string, encoding);
+        }
+        bench.end(n);
+      } else {
+        bench.start();
+        for (i = 0; i < n; ++i) {
+          buf.write(string);
+        }
+        bench.end(n);
+      }
+  }
+}