Major performance improvement

`Reader.prototype.addChunk` was calling `Buffer.concat` constantly, which
increased garbage collection and just all-around killed performance. The
exact implications of this is documented in
brianc/node-postgres#1286, which has a test case
for showing how performance is affected.

Rather than concatenating buffers to the new buffer size constantly, this
change uses a growth strategy that doubles the size of the buffer each
time and tracks the functional length in a separate `chunkLength` variable.
This significantly reduces the amount of allocation and provides a 25x
performance in my test cases, the larger the amount of data the query
is returning, the greater improvement of performance.

Since this uses a doubling buffer, it was important to avoid growing
forever, so I also added a reclaimation strategy which reduces the size
of the buffer wever time more than half of the data has been read.

Author: mramato

index.js

@@ -8,32 +8,48 @@ var Reader = module.exports = function(options) {
   options = options || {}
   this.offset = 0
   this.lastChunk = false
-  this.chunk = null
+  this.chunk = Buffer.alloc(4);
+  this.chunkLength = 0;
   this.headerSize = options.headerSize || 0
   this.lengthPadding = options.lengthPadding || 0
   this.header = null
   assert(this.headerSize < 2, 'pre-length header of more than 1 byte length not currently supported')
 }
 
 Reader.prototype.addChunk = function(chunk) {
-  this.offset = 0
-  this.chunk = chunk
-  if(this.lastChunk) {
-    this.chunk = Buffer.concat([this.lastChunk, this.chunk])
-    this.lastChunk = false
+  var newChunkLength = chunk.length;
+  var newLength = this.chunkLength + newChunkLength;
+
+  if (newLength > this.chunk.length) {
+    var newBufferLength = this.chunk.length * 2;
+    while (newLength >= newBufferLength) {
+      newBufferLength *= 2;
+    }
+    var newBuffer = new Buffer(newBufferLength);
+    this.chunk.copy(newBuffer);
+    this.chunk = newBuffer;
+  }
+  chunk.copy(this.chunk, this.chunkLength);
+  this.chunkLength = newLength;
+
+  // If more than half of the data has been read, shrink
+  // the buffer and reset the offset to reclaim the memory
+  var halfLength = this.chunk.length / 2;
+  if (this.offset > halfLength) {
+    var newBuffer = new Buffer(halfLength);
+    this.chunk.copy(newBuffer, 0, this.offset);
+    this.chunk = newBuffer;
+    this.chunkLength -= this.offset;
+    this.offset = 0;
   }
 }
 
 Reader.prototype._save = function() {
-  //save any unread chunks for next read
-  if(this.offset < this.chunk.length) {
-    this.lastChunk = this.chunk.slice(this.offset)
-  }
   return false
 }
 
 Reader.prototype.read = function() {
-  if(this.chunk.length < (this.headerSize + 4 + this.offset)) {
+  if(this.chunkLength < (this.headerSize + 4 + this.offset)) {
     return this._save()
   }
 
@@ -45,7 +61,7 @@ Reader.prototype.read = function() {
   var length = this.chunk.readUInt32BE(this.offset + this.headerSize) + this.lengthPadding
 
   //next item spans more chunks than we have
-  var remaining = this.chunk.length - (this.offset + 4 + this.headerSize)
+  var remaining = this.chunkLength - (this.offset + 4 + this.headerSize)
   if(length > remaining) {
     return this._save()
   }