Improve chunked array parsing significantly

Author: Ruben Bridgewater

benchmark/index.js

@@ -36,7 +36,6 @@ var stringBuffer = new Buffer('+testing a simple string\r\n')
 var integerBuffer = new Buffer(':1237884\r\n')
 var bigIntegerBuffer = new Buffer(':184467440737095516171234567890\r\n') // 2^64 + 1
 var errorBuffer = new Buffer('-Error ohnoesitbroke\r\n')
-var arrayBuffer = new Buffer('*1\r\n*1\r\n$1\r\na\r\n')
 var endBuffer = new Buffer('\r\n')
 var lorem = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, ' +
   'sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. ' +
@@ -49,15 +48,29 @@ for (var i = 0; i < 64; i++) {
   chunks[i] = new Buffer(shuffle(bigStringArray).join(' ') + '.') // Math.pow(2, 16) chars long
 }
 
-var bigArraySize = 100
-var bigArray = '*' + bigArraySize + '\r\n'
+var arraySize = 100
+var array = '*' + arraySize + '\r\n'
+var size = 0
+for (i = 0; i < arraySize; i++) {
+  array += '$'
+  size = (Math.random() * 10 | 0) + 1
+  array += size + '\r\n' + lorem.slice(0, size) + '\r\n'
+}
+
+var arrayBuffer = new Buffer(array)
+
+var bigArraySize = 1000
+var bigArrayChunks = [new Buffer('*' + bigArraySize)]
 for (i = 0; i < bigArraySize; i++) {
-  bigArray += '$'
-  var size = (Math.random() * 10 | 0) + 1
-  bigArray += size + '\r\n' + lorem.slice(0, size) + '\r\n'
+  size = (Math.random() * 10000 | 0)
+  if (i % 2) {
+    bigArrayChunks.push(new Buffer('\r\n$' + size + '\r\n' + Array(size + 1).join('a')))
+  } else {
+    bigArrayChunks.push(new Buffer('\r\n+' + Array(size + 1).join('b')))
+  }
 }
+bigArrayChunks.push(new Buffer('\r\n'))
 
-var bigArrayBuffer = new Buffer(bigArray)
 var chunkedStringPart1 = new Buffer('+foobar')
 var chunkedStringPart2 = new Buffer('bazEND\r\n')
 
@@ -257,22 +270,24 @@ suite.add('NEW BUF: * array', function () {
   parserBuffer.execute(arrayBuffer)
 })
 
-// BIG ARRAYS
-
-suite.add('\nOLD CODE: * bigArray', function () {
-  parserOld.execute(bigArrayBuffer)
-})
+// BIG ARRAYS (running the old parser is to slow)
 
 suite.add('HIREDIS: * bigArray', function () {
-  parserHiRedis.execute(bigArrayBuffer)
+  for (var i = 0; i < bigArrayChunks.length; i++) {
+    parserHiRedis.execute(bigArrayChunks[i])
+  }
 })
 
 suite.add('NEW CODE: * bigArray', function () {
-  parser.execute(bigArrayBuffer)
+  for (var i = 0; i < bigArrayChunks.length; i++) {
+    parser.execute(bigArrayChunks[i])
+  }
 })
 
 suite.add('NEW BUF: * bigArray', function () {
-  parserBuffer.execute(bigArrayBuffer)
+  for (var i = 0; i < bigArrayChunks.length; i++) {
+    parserBuffer.execute(bigArrayChunks[i])
+  }
 })
 
 // ERRORS

changelog.md

@@ -1,4 +1,19 @@
-## v.2.2.0 - 18 Nov, 2016
+## v.2.3.0 - xx Nov, 2016
+
+Features
+
+-  Parsing time for big arrays (e.g. 4mb+) is now linear and works well for arbitrary array sizes
+
+This case is a magnitude faster than before
+
+OLD STR: * big array x 1.09 ops/sec ±2.15% (7 runs sampled)
+OLD BUF: * big array x 1.23 ops/sec ±2.67% (8 runs sampled)
+
+NEW STR: * big array x 273 ops/sec ±2.09% (85 runs sampled)
+NEW BUF: * big array x 259 ops/sec ±1.32% (85 runs sampled)
+(~10mb array with 1000 entries)
+
+## v.2.2.0 - 31 Oct, 2016
 
 Features
 

lib/parser.js

@@ -205,18 +205,45 @@ function parseArray (parser) {
   if (length === -1) {
     return null
   }
-
   var responses = new Array(length)
-  var bufferLength = parser.buffer.length - 3
-  for (var i = 0; i < length; i++) {
+  return parseArrayElements(parser, responses, 0)
+}
+
+/**
+ * Parse chunked redis array response
+ * @param parser
+ * @returns {*}
+ */
+function parseArrayChunks (parser) {
+  return parseArrayElements(parser, parser.arrayCache, parser.arrayPos)
+}
+
+/**
+ * Parse redis array response elements
+ * @param parser
+ * @param responses
+ * @param i
+ * @returns {*}
+ */
+function parseArrayElements (parser, responses, i) {
+  var bufferLength = parser.buffer.length
+  while (i < responses.length) {
+    var offset = parser.offset
     if (parser.offset >= bufferLength) {
+      parser.arrayCache = responses
+      parser.arrayPos = i
+      parser.offset = offset
       return
     }
     var response = parseType(parser, parser.buffer[parser.offset++])
     if (response === undefined) {
+      parser.arrayCache = responses
+      parser.arrayPos = i
+      parser.offset = offset
       return
     }
     responses[i] = response
+    i++
   }
 
   return responses
@@ -297,6 +324,8 @@ function JavascriptRedisParser (options) {
   this.bigOffset = 0
   this.totalChunkSize = 0
   this.bufferCache = []
+  this.arrayCache = null
+  this.arrayPos = 0
 }
 
 /**
@@ -399,6 +428,7 @@ function concatBuffer (parser, length) {
  * @returns {undefined}
  */
 JavascriptRedisParser.prototype.execute = function execute (buffer) {
+  var arr
   if (this.buffer === null) {
     this.buffer = buffer
     this.offset = 0
@@ -410,18 +440,34 @@ JavascriptRedisParser.prototype.execute = function execute (buffer) {
     buffer.copy(newBuffer, remainingLength, 0, buffer.length)
     this.buffer = newBuffer
     this.offset = 0
+    if (this.arrayCache) {
+      arr = parseArrayChunks(this)
+      if (!arr) {
+        return
+      }
+      this.returnReply(arr)
+      this.arrayCache = null
+    }
   } else if (this.totalChunkSize + buffer.length >= this.bigStrSize) {
     this.bufferCache.push(buffer)
-    // The returned type might be Array * (42) and in that case we can't improve the parsing currently
-    if (this.optionReturnBuffers === false && this.buffer[this.offset] === 36) {
+    if (this.optionReturnBuffers === false && !this.arrayCache) {
       this.returnReply(concatBulkString(this))
       this.buffer = buffer
-    } else { // This applies for arrays too
+    } else {
       this.buffer = concatBuffer(this, this.totalChunkSize + buffer.length)
       this.offset = 0
+      if (this.arrayCache) {
+        arr = parseArrayChunks(this)
+        if (!arr) {
+          this.bigStrSize = 0
+          this.bufferCache = []
+          return
+        }
+        this.returnReply(arr)
+        this.arrayCache = null
+      }
     }
     this.bigStrSize = 0
-    this.totalChunkSize = 0
     this.bufferCache = []
   } else {
     this.bufferCache.push(buffer)
@@ -434,7 +480,9 @@ JavascriptRedisParser.prototype.execute = function execute (buffer) {
     var type = this.buffer[this.offset++]
     var response = parseType(this, type)
     if (response === undefined) {
-      this.offset = offset
+      if (!this.arrayCache) {
+        this.offset = offset
+      }
       return
     }