Merge pull request #17 from treeform/strspeed

Increase string deserialization speed by using size look ahead.

Author: treeform

README.md

@@ -29,20 +29,20 @@ Another speed up comes from parsing and readings its own numbers directly from m
 ### Serialize speed
 ```
 name ............................... min time      avg time    std dv  times
-treeform/jsony ..................... 1.531 ms      2.779 ms    ±0.091   x100
+treeform/jsony ..................... 1.317 ms      1.365 ms    ±0.054   x100
 status-im/nim-json-serialization ... 2.043 ms      3.448 ms    ±0.746   x100
 planetis-m/eminim .................. 5.951 ms      9.305 ms    ±3.210   x100
-disruptek/jason ................... 10.312 ms     13.471 ms    ±3.107   x100
-nim std/json ...................... 12.551 ms     19.419 ms    ±4.039   x100
+disruptek/jason .................... 6.858 ms      7.043 ms    ±0.125   x100
+nim std/json ....................... 8.222 ms      8.510 ms    ±0.123   x100
 ```
 
 ### Deserialize speed
 ```
 name ............................... min time      avg time    std dv  times
-treeform/jsony ..................... 6.724 ms     12.047 ms    ±3.694   x100
+treeform/jsony ..................... 4.134 ms      4.196 ms    ±0.052   x100
 status-im/nim-json-serialization ... 7.119 ms     14.276 ms    ±2.033   x100
-nim std/json ...................... 24.141 ms     38.741 ms    ±5.417   x100
-planetis-m/eminim ................. 10.974 ms     18.355 ms    ±3.994   x100
+planetis-m/eminim .................. 7.761 ms      8.001 ms    ±0.277   x100
+nim std/json ...................... 14.326 ms     14.473 ms    ±0.113   x100
 ```
 
 Note: If you find a faster nim json parser or serializer let me know!

src/jsony.nim

@@ -127,13 +127,7 @@ proc parseHook*(s: string, i: var int, v: var SomeFloat) =
   i += chars
   v = f
 
-proc parseHook*(s: string, i: var int, v: var string) =
-  ## Parse string.
-  eatSpace(s, i)
-  if i + 3 < s.len and s[i+0] == 'n' and s[i+1] == 'u' and s[i+2] == 'l' and s[i+3] == 'l':
-    i += 4
-    return
-  eatChar(s, i, '"')
+proc parseStringSlow(s: string, i: var int, v: var string) =
   while i < s.len:
     let c = s[i]
     case c
@@ -161,6 +155,85 @@ proc parseHook*(s: string, i: var int, v: var string) =
     inc i
   eatChar(s, i, '"')
 
+proc parseStringFast(s: string, i: var int, v: var string) =
+  # It appears to be faster to scan the string once, then allocate exact chars,
+  # and then scan the string again populating it.
+  var
+    j = i
+    ll = 0
+  while j < s.len:
+    let c = s[j]
+    case c
+    of '"':
+      break
+    of '\\':
+      inc j
+      let c = s[j]
+      case c
+      of 'u':
+        inc j
+        let u = parseHexInt(s[j ..< j + 4])
+        j += 3
+        ll += Rune(u).toUTF8().len
+      else:
+        inc ll
+    else:
+      inc ll
+    inc j
+
+  if ll > 0:
+    v = newString(ll)
+    var
+      at = 0
+      ss = cast[ptr UncheckedArray[char]](v[0].addr)
+    template add(ss: ptr UncheckedArray[char], c: char) =
+      ss[at] = c
+      inc at
+    while i < s.len:
+      let c = s[i]
+      case c
+      of '"':
+        break
+      of '\\':
+        inc i
+        let c = s[i]
+        case c
+        of '"', '\\', '/': ss.add(c)
+        of 'b': ss.add '\b'
+        of 'f': ss.add '\f'
+        of 'n': ss.add '\n'
+        of 'r': ss.add '\r'
+        of 't': ss.add '\t'
+        of 'u':
+          inc i
+          let u = parseHexInt(s[i ..< i + 4])
+          i += 3
+          for c in Rune(u).toUTF8():
+            ss.add(c)
+        else:
+          ss.add(c)
+      else:
+        ss.add(c)
+      inc i
+
+  eatChar(s, i, '"')
+
+proc parseHook*(s: string, i: var int, v: var string) =
+  ## Parse string.
+  eatSpace(s, i)
+  if i + 3 < s.len and s[i+0] == 'n' and s[i+1] == 'u' and s[i+2] == 'l' and s[i+3] == 'l':
+    i += 4
+    return
+  eatChar(s, i, '"')
+
+  when nimvm:
+    parseStringSlow(s, i, v)
+  else:
+    when defined(js):
+      parseStringSlow(s, i, v)
+    else:
+      parseStringFast(s, i, v)
+
 proc parseHook*(s: string, i: var int, v: var char) =
   var str: string
   s.parseHook(i, str)