buffer: directly use ArrayBuffer as the pool

addaleax · addaleax · commit 2c9a86f01e55 · 2016-09-02T12:38:12.000+02:00
Make the buffer pool an `ArrayBuffer` which is used directly, speeding up allocation noticeably in some cases. The only drawback happens when creating pool-based `Buffer` instances from strings whose byte lengths got overestimated by `Buffer.byteLength`, e.g. for base64-encoded strings containing whitespace, where two `Buffer` instances are being created. This may also be useful when providing Buffer classes in the future. Benchmark results for `benchmark/buffers/buffer-creation.js`: ``` improvement significant p.value len=1024 type="buffer()" 47.11 % *** 5.202555e-12 len=1024 type="fast-alloc" -3.41 % 3.823226e-01 len=1024 type="fast-alloc-fill" 1.11 % 7.985624e-01 len=1024 type="fast-allocUnsafe" 24.37 % *** 4.264084e-05 len=1024 type="slow" 4.81 % 2.634609e-01 len=1024 type="slow-allocUnsafe" 1.28 % 7.864850e-01 len=10 type="buffer()" 59.42 % *** 9.953552e-13 len=10 type="fast-alloc" -6.43 % 1.450524e-01 len=10 type="fast-alloc-fill" -2.96 % 4.873766e-01 len=10 type="fast-allocUnsafe" 33.89 % *** 6.517268e-07 len=10 type="slow" -1.48 % 7.357711e-01 len=10 type="slow-allocUnsafe" 0.04 % 9.939576e-01 len=2048 type="buffer()" 36.34 % *** 3.201045e-10 len=2048 type="fast-alloc" -4.67 % 2.172900e-01 len=2048 type="fast-alloc-fill" -0.15 % 9.732945e-01 len=2048 type="fast-allocUnsafe" 20.13 % *** 2.372115e-04 len=2048 type="slow" 4.35 % 2.831340e-01 len=2048 type="slow-allocUnsafe" 1.13 % 8.055388e-01 len=4096 type="buffer()" 4.90 % 2.495340e-01 len=4096 type="fast-alloc" -2.11 % 5.417520e-01 len=4096 type="fast-alloc-fill" -0.29 % 9.460378e-01 len=4096 type="fast-allocUnsafe" 3.11 % 5.001959e-01 len=4096 type="slow" 0.95 % 8.145888e-01 len=4096 type="slow-allocUnsafe" 3.74 % 4.227627e-01 len=8192 type="buffer()" 5.08 % 2.263029e-01 len=8192 type="fast-alloc" -1.16 % 7.300235e-01 len=8192 type="fast-alloc-fill" 0.40 % 9.179919e-01 len=8192 type="fast-allocUnsafe" 5.16 % 2.591544e-01 len=8192 type="slow" 2.57 % 5.212449e-01 len=8192 type="slow-allocUnsafe" -3.19 % 4.699138e-01 ``` PR-URL: #8302 Reviewed-By: Trevor Norris <trev.norris@gmail.com> Reviewed-By: James M Snell <jasnell@gmail.com>
diff --git a/lib/buffer.js b/lib/buffer.js
@@ -30,17 +30,21 @@ binding.setupBufferJS(Buffer.prototype, bindingObj);
 const zeroFill = bindingObj.zeroFill || [0];
 
 function createUnsafeBuffer(size) {
+  return new FastBuffer(createUnsafeArrayBuffer(size));
+}
+
+function createUnsafeArrayBuffer(size) {
   zeroFill[0] = 0;
   try {
-    return new FastBuffer(size);
+    return new ArrayBuffer(size);
   } finally {
     zeroFill[0] = 1;
   }
 }
 
 function createPool() {
   poolSize = Buffer.poolSize;
-  allocPool = createUnsafeBuffer(poolSize);
+  allocPool = createUnsafeArrayBuffer(poolSize);
   poolOffset = 0;
 }
 createPool();
@@ -183,7 +187,7 @@ function allocate(size) {
   if (size < (Buffer.poolSize >>> 1)) {
     if (size > (poolSize - poolOffset))
       createPool();
-    var b = allocPool.slice(poolOffset, poolOffset + size);
+    var b = new FastBuffer(allocPool, poolOffset, size);
     poolOffset += size;
     alignPool();
     return b;
@@ -210,8 +214,12 @@ function fromString(string, encoding) {
 
   if (length > (poolSize - poolOffset))
     createPool();
-  var actual = allocPool.write(string, poolOffset, encoding);
-  var b = allocPool.slice(poolOffset, poolOffset + actual);
+  var b = new FastBuffer(allocPool, poolOffset, length);
+  var actual = b.write(string, encoding);
+  if (actual !== length) {
+    // byteLength() may overestimate. That&rsquo;s a rare case, though.
+    b = new FastBuffer(allocPool, poolOffset, actual);
+  }
   poolOffset += actual;
   alignPool();
   return b;
