Use ARM NEON instructions to accelerate unescaping strings.

Author: samyron

ext/json/ext/parser/parser.c

@@ -636,10 +636,56 @@ static inline VALUE json_string_fastpath(JSON_ParserState *state, const char *st
     return build_string(string, stringEnd, intern, symbolize);
 }
 
+typedef struct _json_unescape_cursor {
+    const char *p;
+    const char *pe;
+    char *buffer;
+} JSON_UnescapeCursor;
+
+static ALWAYS_INLINE() int json_copy_and_find_next_backslash(JSON_UnescapeCursor *cursor, const char *stringEnd)
+{
+    if (cursor->pe >= stringEnd) {
+        return 0;
+    }
+
+    const char *p = cursor->p;
+
+#ifdef HAVE_SIMD_NEON
+    while (p+sizeof(uint8x16_t) <= stringEnd) {
+        uint8x16_t chunk = vld1q_u8((const unsigned char *)p);
+        vst1q_u8((unsigned char *)cursor->buffer, chunk);
+        uint8x16_t has_backslash = vceqq_u8(chunk, vdupq_n_u8('\\'));
+        uint64_t mask = neon_match_mask(has_backslash);
+        if (mask) {
+            uint32_t index = trailing_zeros64(mask) >> 2;
+            cursor->buffer += index;
+            cursor->p = p + index;
+            cursor->pe = p + index;
+            return 1;
+        }
+        p += sizeof(uint8x16_t);
+        cursor->buffer += sizeof(uint8x16_t);
+        cursor->p = p;
+        cursor->pe = p;
+    }
+#endif
+
+    cursor->pe = memchr(p, '\\', stringEnd - p);
+    if (cursor->pe) {
+        if (cursor->pe > p) {
+          MEMCPY(cursor->buffer, p, char, cursor->pe - p);
+          cursor->buffer += cursor->pe - p;
+          cursor->p = cursor->pe;
+        }
+        return 1;
+    }
+    return 0;
+}
+
 static VALUE json_string_unescape(JSON_ParserState *state, const char *string, const char *stringEnd, bool is_name, bool intern, bool symbolize)
 {
     size_t bufferSize = stringEnd - string;
-    const char *p = string, *pe = string, *unescape, *bufferStart;
+    const char *unescape, *bufferStart;
     char *buffer;
     int unescape_len;
     char buf[4];
@@ -649,14 +695,15 @@ static VALUE json_string_unescape(JSON_ParserState *state, const char *string, c
     buffer = RSTRING_PTR(result);
     bufferStart = buffer;
 
-    while (pe < stringEnd && (pe = memchr(pe, '\\', stringEnd - pe))) {
+    JSON_UnescapeCursor cursor;
+    cursor.p = string;
+    cursor.pe = string;
+    cursor.buffer = buffer;
+
+    while (json_copy_and_find_next_backslash(&cursor, stringEnd)) {
         unescape = (char *) "?";
         unescape_len = 1;
-        if (pe > p) {
-          MEMCPY(buffer, p, char, pe - p);
-          buffer += pe - p;
-        }
-        switch (*++pe) {
+        switch (*++cursor.pe) {
             case 'n':
                 unescape = (char *) "\n";
                 break;
@@ -679,11 +726,11 @@ static VALUE json_string_unescape(JSON_ParserState *state, const char *string, c
                 unescape = (char *) "\f";
                 break;
             case 'u':
-                if (pe > stringEnd - 5) {
-                    raise_parse_error_at("incomplete unicode character escape sequence at %s", state, p);
+                if (cursor.pe > stringEnd - 5) {
+                    raise_parse_error_at("incomplete unicode character escape sequence at %s", state, cursor.p);
                 } else {
-                    uint32_t ch = unescape_unicode(state, (unsigned char *) ++pe);
-                    pe += 3;
+                    uint32_t ch = unescape_unicode(state, (unsigned char *) ++cursor.pe);
+                    cursor.pe += 3;
                     /* To handle values above U+FFFF, we take a sequence of
                      * \uXXXX escapes in the U+D800..U+DBFF then
                      * U+DC00..U+DFFF ranges, take the low 10 bits from each
@@ -695,22 +742,22 @@ static VALUE json_string_unescape(JSON_ParserState *state, const char *string, c
                      * Area".
                      */
                     if ((ch & 0xFC00) == 0xD800) {
-                        pe++;
-                        if (pe > stringEnd - 6) {
-                            raise_parse_error_at("incomplete surrogate pair at %s", state, p);
+                        cursor.pe++;
+                        if (cursor.pe > stringEnd - 6) {
+                            raise_parse_error_at("incomplete surrogate pair at %s", state, cursor.p);
                         }
-                        if (pe[0] == '\\' && pe[1] == 'u') {
-                            uint32_t sur = unescape_unicode(state, (unsigned char *) pe + 2);
+                        if (cursor.pe[0] == '\\' && cursor.pe[1] == 'u') {
+                            uint32_t sur = unescape_unicode(state, (unsigned char *) cursor.pe + 2);
 
                             if ((sur & 0xFC00) != 0xDC00) {
-                                raise_parse_error_at("invalid surrogate pair at %s", state, p);
+                                raise_parse_error_at("invalid surrogate pair at %s", state, cursor.p);
                             }
 
                             ch = (((ch & 0x3F) << 10) | ((((ch >> 6) & 0xF) + 1) << 16)
                                     | (sur & 0x3FF));
-                            pe += 5;
+                            cursor.pe += 5;
                         } else {
-                            raise_parse_error_at("incomplete surrogate pair at %s", state, p);
+                            raise_parse_error_at("incomplete surrogate pair at %s", state, cursor.p);
                             break;
                         }
                     }
@@ -719,19 +766,19 @@ static VALUE json_string_unescape(JSON_ParserState *state, const char *string, c
                 }
                 break;
             default:
-                p = pe;
+                cursor.p = cursor.pe;
                 continue;
         }
-        MEMCPY(buffer, unescape, char, unescape_len);
-        buffer += unescape_len;
-        p = ++pe;
+        MEMCPY(cursor.buffer, unescape, char, unescape_len);
+        cursor.buffer += unescape_len;
+        cursor.p = ++cursor.pe;
     }
 
-    if (stringEnd > p) {
-      MEMCPY(buffer, p, char, stringEnd - p);
-      buffer += stringEnd - p;
+    if (stringEnd > cursor.p) {
+      MEMCPY(cursor.buffer, cursor.p, char, stringEnd - cursor.p);
+      cursor.buffer += stringEnd - cursor.p;
     }
-    rb_str_set_len(result, buffer - bufferStart);
+    rb_str_set_len(result, cursor.buffer - bufferStart);
 
     if (symbolize) {
         result = rb_str_intern(result);