Improve multiple chunks being concated by using a bufferPool

It is going to increase in size if required

Author: Ruben Bridgewater

benchmark/index.js

@@ -58,6 +58,8 @@ for (i = 0; i < bigArraySize; i++) {
 }
 
 var bigArrayBuffer = new Buffer(bigArray)
+var chunkedStringPart1 = new Buffer('+foobar')
+var chunkedStringPart2 = new Buffer('bazEND\r\n')
 
 var parserOld = new ParserOLD({
   returnReply: checkReply,
@@ -105,6 +107,23 @@ suite.add('NEW CODE: multiple chunks in a bulk string', function () {
   parser.execute(endBuffer)
 })
 
+// CHUNKED STRINGS
+
+suite.add('\nOLD CODE: multiple chunks in a string', function () {
+  parserOld.execute(chunkedStringPart1)
+  parserOld.execute(chunkedStringPart2)
+})
+
+suite.add('HIREDIS: multiple chunks in a string', function () {
+  parserHiRedis.execute(chunkedStringPart1)
+  parserHiRedis.execute(chunkedStringPart2)
+})
+
+suite.add('NEW CODE: multiple chunks in a string', function () {
+  parser.execute(chunkedStringPart1)
+  parser.execute(chunkedStringPart2)
+})
+
 // BIG BULK STRING
 
 suite.add('\nOLD CODE: 4mb bulk string', function () {

lib/parser.js

@@ -1,6 +1,8 @@
 'use strict'
 
 var ReplyError = require('./replyError')
+// TODO: Consider shrinking the bufferPool if it's not used a lot by using interval check
+var bufferPool = new Buffer(64 * 1024)
 
 /**
  * Used for lengths and numbers only, faster perf on arrays / bulks
@@ -261,6 +263,19 @@ function JavascriptRedisParser (options) {
   this.bufferCache = []
 }
 
+function concat (parser, length) {
+  var list = parser.bufferCache
+  var pos = 0
+  if (bufferPool.length < length) {
+    bufferPool = new Buffer(length)
+  }
+  for (var i = 0; i < list.length; i++) {
+    list[i].copy(bufferPool, pos)
+    pos += list[i].length
+  }
+  return bufferPool.slice(parser.offset, length)
+}
+
 /**
  * Parse the redis buffer
  * @param buffer
@@ -273,16 +288,17 @@ JavascriptRedisParser.prototype.execute = function (buffer) {
     var oldLength = this.buffer.length
     var remainingLength = oldLength - this.offset
     var newLength = remainingLength + buffer.length
-    var newBuffer = new Buffer(newLength)
+    // ~ 5% speed increase over using new Buffer(length) all the time
+    if (bufferPool.length < newLength) { // We can't rely on the chunk size
+      bufferPool = new Buffer(newLength)
+    }
+    var newBuffer = bufferPool
     this.buffer.copy(newBuffer, 0, this.offset, oldLength)
     buffer.copy(newBuffer, remainingLength, 0, buffer.length)
-    this.buffer = newBuffer
+    this.buffer = newBuffer.slice(0, newLength)
   } else if (this.totalChunkSize + buffer.length >= this.bigStrSize) {
     this.bufferCache.push(buffer)
-    if (this.offset !== 0) {
-      this.bufferCache[0] = this.bufferCache[0].slice(this.offset)
-    }
-    this.buffer = Buffer.concat(this.bufferCache, this.totalChunkSize + buffer.length - this.offset)
+    this.buffer = concat(this, this.totalChunkSize + buffer.length)
     this.bigStrSize = 0
     this.totalChunkSize = 0
     this.bufferCache = []

test/parsers.spec.js

@@ -449,6 +449,74 @@ describe('parsers', function () {
         parser.execute(new Buffer(':' + number + '\r\n'))
         assert.strictEqual(replyCount, 2)
       })
+
+      it('handle big data', function () {
+        if (Parser.name === 'HiredisReplyParser') {
+          return this.skip()
+        }
+        var lorem = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, ' +
+          'sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. ' +
+          'Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ' +
+          'ut aliquip ex ea commodo consequat. Duis aute irure dolor in' // 256 chars
+        var bigStringArray = (new Array(Math.pow(2, 16) / lorem.length).join(lorem + ' ')).split(' ') // Math.pow(2, 16) chars long
+        var startBigBuffer = new Buffer('$' + (4 * 1024 * 1024) + '\r\n')
+        var chunks = new Array(64)
+        for (var i = 0; i < 64; i++) {
+          chunks[i] = new Buffer(bigStringArray.join(' ') + '.') // Math.pow(2, 16) chars long
+        }
+        var replyCount = 0
+        function checkReply (reply) {
+          assert.strictEqual(reply.length, 4 * 1024 * 1024)
+          replyCount++
+        }
+        var parser = new Parser({
+          returnReply: checkReply,
+          returnError: returnError,
+          returnFatalError: returnFatalError
+        })
+        parser.execute(startBigBuffer)
+        for (i = 0; i < 64; i++) {
+          assert.strictEqual(parser.bufferCache.length, i + 1)
+          parser.execute(chunks[i])
+        }
+        assert.strictEqual(replyCount, 0)
+        parser.execute(new Buffer('\r\n'))
+        assert.strictEqual(replyCount, 1)
+      })
+
+      it('handle big data 2', function () {
+        if (Parser.name === 'HiredisReplyParser') {
+          return this.skip()
+        }
+        var lorem = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, ' +
+          'sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. ' +
+          'Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ' +
+          'ut aliquip ex ea commodo consequat. Duis aute irure dolor in' // 256 chars
+        var bigStringArray = (new Array(Math.pow(2, 16) / lorem.length).join(lorem + ' ')).split(' ') // Math.pow(2, 16) chars long
+        var startBigBuffer = new Buffer('\r\n$' + (4 * 1024 * 1024) + '\r\n')
+        var chunks = new Array(64)
+        for (var i = 0; i < 64; i++) {
+          chunks[i] = new Buffer(bigStringArray.join(' ') + '.') // Math.pow(2, 16) chars long
+        }
+        var replyCount = 0
+        function checkReply (reply) {
+          replyCount++
+        }
+        var parser = new Parser({
+          returnReply: checkReply,
+          returnError: returnError,
+          returnFatalError: returnFatalError
+        })
+        parser.execute(new Buffer('+test'))
+        parser.execute(startBigBuffer)
+        for (i = 0; i < 64; i++) {
+          assert.strictEqual(parser.bufferCache.length, i + 1)
+          parser.execute(chunks[i])
+        }
+        assert.strictEqual(replyCount, 1)
+        parser.execute(new Buffer('\r\n'))
+        assert.strictEqual(replyCount, 2)
+      })
     })
   })
 })