Merge pull request #3 from scuml/optimizations

Optimizations

Author: scuml

Sources/SwiftRedis/RedisResp.swift

@@ -115,6 +115,7 @@ class RedisResp {
         var response: RedisResponse
 
         var (matched, offset) = try compare(&buffer, at: from, with: RedisResp.plus)
+        
         if  matched {
             (response, offset) = try parseSimpleString(&buffer, offset: offset)
         } else {
@@ -143,13 +144,24 @@ class RedisResp {
         return (response, offset)
     }
 
+    /* 
+    Arrays usually need to parse bulk strings.  And the longer the array, the more optimization is needed.  So to save processing
+    time, check the $ first.  (https://redis.io/topics/protocol)
+    */
+    private func parseByPrefixArrayOptimization(_ buffer: inout Data, from: Int) throws -> (RedisResponse, Int) {
+        let (matched, offset) = try compare(&buffer, at: from, with: RedisResp.dollar)
+        if  matched {
+            return try parseBulkString(&buffer, offset: offset)
+        }
+        return try parseByPrefix(&buffer, from: offset)
+    }
     private func parseArray(_ buffer: inout Data, offset: Int) throws -> (RedisResponse, Int) {
         var (arrayLength, newOffset) = try parseIntegerValue(&buffer, offset: offset)
         var responses = [RedisResponse]()
         var response: RedisResponse
         if  arrayLength >= 0 {
             for _ in 0 ..< Int(arrayLength) {
-                (response, newOffset) = try parseByPrefix(&buffer, from: newOffset)
+                (response, newOffset) = try parseByPrefixArrayOptimization(&buffer, from: newOffset)
                 responses.append(response)
             }
             return (RedisResponse.Array(responses), newOffset)
@@ -169,18 +181,16 @@ class RedisResp {
                     throw RedisRespError(code: .EOF)
                 }
             }
-            let data = buffer.subdata(in: newOffset..<newOffset+strLen)
-            let redisString = RedisString(data)
+            let redisString = RedisString(buffer[newOffset..<newOffset+strLen])
             return (RedisResponse.StringValue(redisString), totalLength)
         } else {
             return (RedisResponse.Nil, newOffset)
         }
     }
 
     private func parseError(_ buffer:  inout Data, offset: Int) throws -> (RedisResponse, Int) {
-        let eos = try find(&buffer, from: offset, data: RedisResp.crLf)
-        let data = buffer.subdata(in: offset..<eos)
-        let optStr = String(data: data as Data, encoding: String.Encoding.utf8)
+        let eos = try findCrlf(&buffer, from: offset)
+        let optStr = String(data: buffer[offset..<eos], encoding: String.Encoding.utf8)
         let length = eos+RedisResp.crLf.count
         guard  let str = optStr  else {
             throw RedisRespError(code: .notUTF8)
@@ -194,9 +204,8 @@ class RedisResp {
     }
 
     private func parseSimpleString(_ buffer: inout Data, offset: Int) throws -> (RedisResponse, Int) {
-        let eos = try find(&buffer, from: offset, data: RedisResp.crLf)
-        let data = buffer.subdata(in: offset..<eos)
-        let optStr = String(data: data, encoding: String.Encoding.utf8)
+        let eos = try findCrlf(&buffer, from: offset)
+        let optStr = String(data: buffer[offset..<eos], encoding: String.Encoding.utf8)
         let length = eos+RedisResp.crLf.count
         guard  let str = optStr  else {
             throw RedisRespError(code: .notUTF8)
@@ -207,30 +216,28 @@ class RedisResp {
     // Mark: Parser helper functions
 
     private func compare(_ buffer: inout Data, at offset: Int, with: Data) throws -> (Bool, Int) {
-        while  offset+with.count >= buffer.count {
+        // use offset+1 instead of offset+with.count as with.count is always == 1
+        while offset+1 >= buffer.count {
             let length = try socket?.read(into: &buffer)
             if  length == 0 {
                 throw RedisRespError(code: .EOF)
             }
         }
 
-        let range = buffer.range(of: with, options: [], in: offset..<offset+with.count)
-        if range != nil {
-            return (true, offset+with.count)
+        if (buffer[offset..<offset+1] == with){
+            return (true, offset+1)
         } else {
             return (false, offset)
         }
     }
 
     private func find(_ buffer: inout Data, from: Int, data: Data) throws -> Int {
         var offset = from
-        var notFound = true
-
-        while notFound {
+        while true {            
             let range = buffer.range(of: data, options: [], in: offset..<buffer.count)
             if range != nil {
-                offset = (range?.lowerBound)!
-                notFound = false
+                return range!.lowerBound
+                
             } else {
                 let length = try socket?.read(into: &buffer)
                 if  length == 0 {
@@ -240,11 +247,27 @@ class RedisResp {
         }
         return offset
     }
+    private func findCrlf(_ buffer: inout Data, from: Int) throws -> Int {
+        /* 5X faster than using find() above.  range() is expensive */
+        var i = from
+        while true {
+            while i <= buffer.count {
+                if buffer[i] == 13 && buffer[i+1] == 10{
+                    return i
+                }
+                i+=1
+            }
+            let length = try socket?.read(into: &buffer)
+            if  length == 0 {
+                throw RedisRespError(code: .EOF)
+            }
+        }
+        return from
+    }
 
     private func parseIntegerValue(_ buffer: inout Data, offset: Int) throws -> (Int64, Int) {
-        let eos = try find(&buffer, from: offset, data: RedisResp.crLf)
-        let data = buffer.subdata(in: offset..<eos)
-        let optStr = String(data: data as Data, encoding: String.Encoding.utf8)
+        let eos = try findCrlf(&buffer, from: offset)
+        let optStr = String(data: buffer[offset..<eos], encoding: String.Encoding.utf8)
         let length = eos+RedisResp.crLf.count
         guard  let str = optStr  else {
             throw RedisRespError(code: .notUTF8)