Push the validateUTF8String into the StringScanner to reduce the work being done if UTF-8 validation is disabled.

Author: samyron

java/src/json/ext/Parser.java

@@ -52,8 +52,8 @@ ByteList decode(ThreadContext context, ByteList src, int start, int end) {
         }
     }
 
-    // Decodes ASCII-only strings with no UTF-8 validation. It is assumed this is only called when
-    // the StringScanner#scan returned a result with the ASCII_BIT bit set.
+    // Decodes strings with no UTF-8 validation. It is assumed the string is either ASCII-only
+    // or UTF-8 avlidation has been disabled.
     ByteList decodeNoValidate(ThreadContext context, ByteList src, int start, int end, ByteBuffer chunks) {
         try {
             init(src, start, end);

java/src/json/ext/StringDecoder.java

@@ -69,7 +69,7 @@ static StringScanner getInstance() {
      *         {@link #ASCII_BIT} is set when the body contains no non-ASCII byte
      *         (it may still hold escapes or control characters)
      */
-    long scan(byte[] data, ByteBuffer chunks, int start, int end) {
+    long scan(byte[] data, ByteBuffer chunks, int start, int end, boolean validateUtf8) {
         int p = start;
         boolean plain = true;
         boolean ascii = true;
@@ -86,9 +86,20 @@ long scan(byte[] data, ByteBuffer chunks, int start, int end) {
                 //                        clears ASCII_BIT
                 //   non-plain, !ASCII -> quote and backslash only; multi-byte
                 //                        UTF-8 is skipped eight bytes at a time
-                long m = plain ? stringScanMask(x)
-                              : ascii ? quoteBackslashHighMask(x)
-                                      : quoteBackslashMask(x);
+                //
+                // When UTF-8 validation is disabled, non-ASCII bytes are copied
+                // verbatim, so they stay on the plain fast path and the high-bit
+                // term drops out of every mask: plain scans for control, quote
+                // and backslash; non-plain scans for quote and backslash only.
+                long m;
+                if (validateUtf8) {
+                    m = plain ? stringScanMask(x)
+                             : ascii ? quoteBackslashHighMask(x)
+                                     : quoteBackslashMask(x);
+                } else {
+                    m = plain ? controlQuoteBackslashMask(x)
+                             : quoteBackslashMask(x);
+                }
                 if (m == 0) {
                     p += 8;
                 } else {
@@ -113,8 +124,10 @@ long scan(byte[] data, ByteBuffer chunks, int start, int end) {
                     continue outer;
                 }
                 if (b >= 0x80) {
-                    plain = false;
                     ascii = false;
+                    if (validateUtf8) {
+                        plain = false;
+                    }
                     p++;
                     continue outer;
                 }
@@ -184,6 +197,21 @@ private static long backslashControlMask(long x) {
         return (control | bslash) & HIGH_BITS;
     }
 
+    /**
+     * Like {@link #stringScanMask} but omits the non-ASCII (high-bit) term:
+     * flags double quotes, backslashes and ASCII control characters (< 0x20)
+     * only. Used as the starting mask when UTF-8 validation is disabled, where
+     * non-ASCII bytes are copied verbatim and so stay on the plain fast path.
+     */
+    private static long controlQuoteBackslashMask(long x) {
+        long control = (x - SPACES) & ~x; // bytes < 0x20 (ASCII)
+        long q       = x ^ DOUBLE_QUOTES;
+        long quote   = (q - ONES) & ~q;
+        long s       = x ^ BACKSLASHES;
+        long bslash  = (s - ONES) & ~s;
+        return (control | quote | bslash) & HIGH_BITS;
+    }
+
     /**
      * Like {@link #stringScanMask} but only flags double quotes and backslashes.
      * Used once a string is known to require the decoder <em>and</em> to already

java/src/json/ext/StringScanner.java

@@ -17,22 +17,32 @@ final class VectorizedStringScanner extends StringScanner {
     private static final ByteVector DQUOTE = ByteVector.broadcast(SP, '"');
 
     @Override
-    long scan(byte[] data, ByteBuffer chunks, int start, int end) {
+    long scan(byte[] data, ByteBuffer chunks, int start, int end, boolean validateUtf8) {
         final int width = SP.length();
         int p = start;
         boolean plain = true;
         boolean ascii = true;
 
         // The same structure as the StringEncoder. The logic is
         // duplicated for maximum inlining.
+        //
+        // When UTF-8 validation is disabled, non-ASCII lanes are copied verbatim
+        // and stay on the plain fast path, so the high-bit term drops out: plain
+        // scans for control, quote and backslash; non-plain for quote and
+        // backslash only.
         outer:
         while (true) {
             while (p + width <= end) {
                 ByteVector chunk = ByteVector.fromArray(SP, data, p);
-                VectorMask<Byte> interesting =
-                    plain ? interestingLanes(chunk)
-                          : ascii ? quoteBackslashOrHighLanes(chunk)
-                                  : quoteOrBackslashLanes(chunk);
+                VectorMask<Byte> interesting;
+                if (validateUtf8) {
+                    interesting = plain ? interestingLanes(chunk)
+                                        : ascii ? quoteBackslashOrHighLanes(chunk)
+                                                : quoteOrBackslashLanes(chunk);
+                } else {
+                    interesting = plain ? controlQuoteBackslashLanes(chunk)
+                                        : quoteOrBackslashLanes(chunk);
+                }
                 if (interesting.anyTrue()) {
                     p += interesting.firstTrue();
                     break;
@@ -50,8 +60,10 @@ long scan(byte[] data, ByteBuffer chunks, int start, int end) {
                     continue outer;
                 }
                 if (b >= 0x80) {
-                    plain = false;
                     ascii = false;
+                    if (validateUtf8) {
+                        plain = false;
+                    }
                     p++;
                     continue outer;
                 }
@@ -85,7 +97,9 @@ int scanEscape(byte[] data, ByteBuffer chunks, int start, int end) {
     }
 
     private static VectorMask<Byte> escapeOrControlLanes(ByteVector chunk) {
-        return chunk.lt(SPACE).or(chunk.eq(BACKSLASH));
+        VectorMask<Byte> negative = chunk.lt(ZERO);
+        VectorMask<Byte> control = chunk.lt(SPACE).andNot(negative);
+        return control.or(chunk.eq(BACKSLASH));
     }
 
     private static VectorMask<Byte> interestingLanes(ByteVector chunk) {
@@ -100,6 +114,17 @@ private static VectorMask<Byte> quoteOrBackslashLanes(ByteVector chunk) {
         return chunk.eq(DQUOTE).or(chunk.eq(BACKSLASH));
     }
 
+    // Like interestingLanes but without the non-ASCII (high-bit) term: flags
+    // ASCII control characters, double quotes and backslashes only. Used as the
+    // plain-path mask when UTF-8 validation is disabled.
+    private static VectorMask<Byte> controlQuoteBackslashLanes(ByteVector chunk) {
+        VectorMask<Byte> negative = chunk.lt(ZERO);
+        VectorMask<Byte> lowOrQuote = chunk.lanewise(VectorOperators.XOR, TWO)
+                                           .lt(THIRTY_THREE)
+                                           .andNot(negative);
+        return lowOrQuote.or(chunk.eq(BACKSLASH));
+    }
+
     private static VectorMask<Byte> quoteBackslashOrHighLanes(ByteVector chunk) {
         return chunk.eq(DQUOTE).or(chunk.eq(BACKSLASH)).or(chunk.lt(ZERO));
     }