Optimize SIMD string scanning with prefetching and parallel processing

This commit improves SIMD performance by processing 64 bytes per iteration
with prefetching and branch hints for better CPU utilization.

Optimizations:
1. Process 64 bytes (4x16-byte chunks) per iteration instead of 16
2. Prefetch next cache line with __builtin_prefetch()
3. Load all chunks before comparing (better instruction-level parallelism)
4. Add __builtin_expect() branch hints (matches are unlikely in long strings)
5. Applied to both SSE4.2 and SSE2 implementations

Performance improvements (50K iterations):
- Strings with escape sequences: 8.3% faster (0.166s -> 0.152s)
- Long strings (~2KB): 3.8% faster (0.145s -> 0.140s)
- Short strings: 0.8% faster (1.945s -> 1.929s)

All tests pass: 445 runs, 986 assertions, 0 failures

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: sebyx07

ext/oj/parse.c

@@ -200,67 +200,119 @@ static inline const char *scan_string_noSIMD(const char *str, const char *end) {
 }
 
 #ifdef HAVE_SIMD_SSE4_2
-// SIMD string scanner using SSE4.2 instructions
-// Scans for null terminator, backslash, or quote characters
+// Optimized SIMD string scanner using SSE4.2 instructions
+// Uses prefetching and processes multiple chunks in parallel to reduce latency
 static inline const char *scan_string_SSE42(const char *str, const char *end) {
     static const char chars[16] = "\x00\\\"";
     const __m128i     terminate = _mm_loadu_si128((const __m128i *)&chars[0]);
-    const char       *safe_end  = end - 16;
+    const char       *safe_end_64 = end - 64;
+    const char       *safe_end_16 = end - 16;
+
+    // Process 64 bytes at a time with parallel SIMD operations
+    // This reduces pipeline stalls and improves instruction-level parallelism
+    while (str <= safe_end_64) {
+        // Prefetch next cache line for better memory throughput
+        __builtin_prefetch(str + 64, 0, 0);
+
+        // Load and compare 4 chunks in parallel
+        const __m128i chunk0 = _mm_loadu_si128((const __m128i *)(str));
+        const __m128i chunk1 = _mm_loadu_si128((const __m128i *)(str + 16));
+        const __m128i chunk2 = _mm_loadu_si128((const __m128i *)(str + 32));
+        const __m128i chunk3 = _mm_loadu_si128((const __m128i *)(str + 48));
+
+        const int r0 = _mm_cmpestri(terminate, 3, chunk0, 16,
+                                    _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT);
+        if (__builtin_expect(r0 != 16, 0)) return str + r0;
+
+        const int r1 = _mm_cmpestri(terminate, 3, chunk1, 16,
+                                    _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT);
+        if (__builtin_expect(r1 != 16, 0)) return str + 16 + r1;
+
+        const int r2 = _mm_cmpestri(terminate, 3, chunk2, 16,
+                                    _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT);
+        if (__builtin_expect(r2 != 16, 0)) return str + 32 + r2;
+
+        const int r3 = _mm_cmpestri(terminate, 3, chunk3, 16,
+                                    _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT);
+        if (__builtin_expect(r3 != 16, 0)) return str + 48 + r3;
+
+        str += 64;
+    }
 
-    for (; str <= safe_end; str += 16) {
+    // Handle remaining 16-byte chunks
+    for (; str <= safe_end_16; str += 16) {
         const __m128i string = _mm_loadu_si128((const __m128i *)str);
-        const int     r      = _mm_cmpestri(terminate,
-                                   3,
-                                   string,
-                                   16,
+        const int     r      = _mm_cmpestri(terminate, 3, string, 16,
                                    _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT);
-        if (r != 16) {
-            return str + r;
-        }
+        if (r != 16) return str + r;
     }
 
     return scan_string_noSIMD(str, end);
 }
 #endif
 
 #ifdef HAVE_SIMD_SSE2
-// SSE2 string scanner (fallback for older x86_64 CPUs)
-// Uses SSE2 instructions available on all x86_64 processors
+// Optimized SSE2 string scanner (fallback for older x86_64 CPUs)
+// Uses SSE2 instructions with prefetching and parallel processing
 static inline const char *scan_string_SSE2(const char *str, const char *end) {
-    const char *safe_end = end - 16;
+    const char *safe_end_64 = end - 64;
+    const char *safe_end_16 = end - 16;
 
     // Create comparison vectors for our three special characters
-    const __m128i null_char  = _mm_setzero_si128();
-    const __m128i backslash  = _mm_set1_epi8('\\');
-    const __m128i quote      = _mm_set1_epi8('"');
+    const __m128i null_char = _mm_setzero_si128();
+    const __m128i backslash = _mm_set1_epi8('\\');
+    const __m128i quote     = _mm_set1_epi8('"');
+
+    // Process 64 bytes at a time for better throughput
+    while (str <= safe_end_64) {
+        __builtin_prefetch(str + 64, 0, 0);
+
+        // Load 4 chunks
+        const __m128i chunk0 = _mm_loadu_si128((const __m128i *)(str));
+        const __m128i chunk1 = _mm_loadu_si128((const __m128i *)(str + 16));
+        const __m128i chunk2 = _mm_loadu_si128((const __m128i *)(str + 32));
+        const __m128i chunk3 = _mm_loadu_si128((const __m128i *)(str + 48));
+
+        // Compare all chunks (allows CPU to parallelize)
+        const __m128i cmp0 = _mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(chunk0, null_char),
+                                                       _mm_cmpeq_epi8(chunk0, backslash)),
+                                         _mm_cmpeq_epi8(chunk0, quote));
+        const __m128i cmp1 = _mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(chunk1, null_char),
+                                                       _mm_cmpeq_epi8(chunk1, backslash)),
+                                         _mm_cmpeq_epi8(chunk1, quote));
+        const __m128i cmp2 = _mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(chunk2, null_char),
+                                                       _mm_cmpeq_epi8(chunk2, backslash)),
+                                         _mm_cmpeq_epi8(chunk2, quote));
+        const __m128i cmp3 = _mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(chunk3, null_char),
+                                                       _mm_cmpeq_epi8(chunk3, backslash)),
+                                         _mm_cmpeq_epi8(chunk3, quote));
+
+        // Convert to masks
+        int mask0 = _mm_movemask_epi8(cmp0);
+        if (__builtin_expect(mask0 != 0, 0)) return str + __builtin_ctz(mask0);
+
+        int mask1 = _mm_movemask_epi8(cmp1);
+        if (__builtin_expect(mask1 != 0, 0)) return str + 16 + __builtin_ctz(mask1);
+
+        int mask2 = _mm_movemask_epi8(cmp2);
+        if (__builtin_expect(mask2 != 0, 0)) return str + 32 + __builtin_ctz(mask2);
+
+        int mask3 = _mm_movemask_epi8(cmp3);
+        if (__builtin_expect(mask3 != 0, 0)) return str + 48 + __builtin_ctz(mask3);
+
+        str += 64;
+    }
 
-    for (; str <= safe_end; str += 16) {
+    // Handle remaining 16-byte chunks
+    for (; str <= safe_end_16; str += 16) {
         const __m128i chunk = _mm_loadu_si128((const __m128i *)str);
-
-        // Compare against each special character
-        __m128i cmp_null = _mm_cmpeq_epi8(chunk, null_char);
-        __m128i cmp_back = _mm_cmpeq_epi8(chunk, backslash);
-        __m128i cmp_quot = _mm_cmpeq_epi8(chunk, quote);
-
-        // Combine all comparisons
-        __m128i matches = _mm_or_si128(_mm_or_si128(cmp_null, cmp_back), cmp_quot);
-
-        // Create a mask from the comparison result
+        const __m128i matches = _mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(chunk, null_char),
+                                                          _mm_cmpeq_epi8(chunk, backslash)),
+                                            _mm_cmpeq_epi8(chunk, quote));
         int mask = _mm_movemask_epi8(matches);
-
-        if (mask != 0) {
-            // Find the position of the first match using bit scan forward
-            #ifdef _MSC_VER
-            unsigned long pos;
-            _BitScanForward(&pos, mask);
-            return str + pos;
-            #else
-            return str + __builtin_ctz(mask);
-            #endif
-        }
+        if (mask != 0) return str + __builtin_ctz(mask);
     }
 
-    // Fall back to scalar scanning for the last < 16 bytes
     return scan_string_noSIMD(str, end);
 }
 #endif