Use a simple buffer list to improve performance

fixes #566
fixes #1590

Author: dougwilson

Changes.md

@@ -13,6 +13,7 @@ you spot any mistakes.
 * Fix edge cases when determing Query result packets #1547
 * Fix memory leak when using long-running domains #1619 #1620
 * Update `bignumber.js` to 3.1.2
+* Use a simple buffer list to improve performance #566 #1590
 
 ## v2.12.0 (2016-11-02)
 

lib/protocol/BufferList.js

@@ -0,0 +1,25 @@
+
+module.exports = BufferList;
+function BufferList() {
+  this.bufs = [];
+  this.size = 0;
+}
+
+BufferList.prototype.shift = function shift() {
+  var buf = this.bufs.shift();
+
+  if (buf) {
+    this.size -= buf.length;
+  }
+
+  return buf;
+};
+
+BufferList.prototype.push = function push(buf) {
+  if (!buf || !buf.length) {
+    return;
+  }
+
+  this.bufs.push(buf);
+  this.size += buf.length;
+};

lib/protocol/Parser.js

@@ -2,15 +2,16 @@ var MAX_PACKET_LENGTH = Math.pow(2, 24) - 1;
 var MUL_32BIT         = Math.pow(2, 32);
 var PacketHeader      = require('./PacketHeader');
 var BigNumber         = require('bignumber.js');
+var BufferList        = require('./BufferList');
 
 module.exports = Parser;
 function Parser(options) {
   options = options || {};
 
   this._supportBigNumbers = options.config && options.config.supportBigNumbers;
   this._buffer            = new Buffer(0);
-  this._nextBuffers       = [];
-  this._longPacketBuffers = [];
+  this._nextBuffers       = new BufferList();
+  this._longPacketBuffers = new BufferList();
   this._offset            = 0;
   this._packetEnd         = null;
   this._packetHeader      = null;
@@ -374,53 +375,56 @@ Parser.prototype.resetPacketNumber = function() {
   this._nextPacketNumber = 0;
 };
 
-Parser.prototype.packetLength = function() {
-  return this._longPacketBuffers.reduce(function(length, buffer) {
-    return length + buffer.length;
-  }, this._packetHeader.length);
+Parser.prototype.packetLength = function packetLength() {
+  if (!this._packetHeader) {
+    return null;
+  }
+
+  return this._packetHeader.length + this._longPacketBuffers.size;
 };
 
 Parser.prototype._combineNextBuffers = function _combineNextBuffers(bytes) {
   if ((this._buffer.length - this._offset) >= bytes) {
     return true;
   }
 
-  if (!this._nextBuffers.length) {
+  if (!this._nextBuffers.size) {
     return false;
   }
 
-  while (this._nextBuffers.length && (this._buffer.length - this._offset) < bytes) {
+  while (this._nextBuffers.size && (this._buffer.length - this._offset) < bytes) {
     this.append(this._nextBuffers.shift());
   }
 
   return (this._buffer.length - this._offset) >= bytes;
 };
 
 Parser.prototype._combineLongPacketBuffers = function _combineLongPacketBuffers() {
-  if (!this._longPacketBuffers.length) {
+  if (!this._longPacketBuffers.size) {
     return;
   }
 
+  // Calculate bytes
+  var remainingBytes      = this._buffer.length - this._offset;
   var trailingPacketBytes = this._buffer.length - this._packetEnd;
 
-  var length = this._longPacketBuffers.reduce(function(length, buffer) {
-    return length + buffer.length;
-  }, (this._buffer.length - this._offset));
-
-  var combinedBuffer = new Buffer(length);
+  // Create buffer
+  var buf    = null;
+  var buffer = new Buffer(remainingBytes + this._longPacketBuffers.size);
+  var offset = 0;
 
-  var offset = this._longPacketBuffers.reduce(function(offset, buffer) {
-    buffer.copy(combinedBuffer, offset);
-    return offset + buffer.length;
-  }, 0);
+  // Copy long buffers
+  while ((buf = this._longPacketBuffers.shift())) {
+    offset += buf.copy(buffer, offset);
+  }
 
-  this._buffer.copy(combinedBuffer, offset, this._offset);
+  // Copy remaining bytes
+  this._buffer.copy(buffer, offset, this._offset);
 
-  this._buffer            = combinedBuffer;
-  this._longPacketBuffers = [];
-  this._offset            = 0;
-  this._packetEnd         = this._buffer.length - trailingPacketBytes;
-  this._packetOffset      = 0;
+  this._buffer       = buffer;
+  this._offset       = 0;
+  this._packetEnd    = this._buffer.length - trailingPacketBytes;
+  this._packetOffset = 0;
 };
 
 Parser.prototype._advanceToNextPacket = function() {