stringzillas-cuda 4.2.2__tar.gz → 4.3.0__tar.gz

{stringzillas_cuda-4.2.2/stringzillas_cuda.egg-info → stringzillas_cuda-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stringzillas-cuda
-Version: 4.2.2
+Version: 4.3.0
 Summary: Search, hash, sort, fingerprint, and fuzzy-match strings faster via SWAR, SIMD, and CUDA on Nvidia GPUs
 Home-page: https://github.com/ashvardanian/StringZilla
 Author: Ash Vardanian
@@ -30,7 +30,7 @@ Classifier: Topic :: Text Processing :: Indexing
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: stringzilla==4.2.2
+Requires-Dist: stringzilla==4.3.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -1134,10 +1134,10 @@ Similar to GCC, StringZilla is 32 bytes in size, and similar to Clang it can fit
 Our layout might be preferential, if you want to avoid branches.
 If you use a different compiler, you may want to check its SSO buffer size with a [simple Gist](https://gist.github.com/ashvardanian/c197f15732d9855c4e070797adf17b21).
 
-|                       | `libstdc++` in  GCC 13 | `libc++` in Clang 17 | StringZilla |
-| :-------------------- | ---------------------: | -------------------: | ----------: |
-| `sizeof(std::string)` |                     32 |                   24 |          32 |
-| Small String Capacity |                     15 |               __22__ |      __22__ |
+|                 | `libstdc++` in  GCC 13 | `libc++` in Clang 17 | StringZilla |
+| :-------------- | ---------------------: | -------------------: | ----------: |
+| String `sizeof` |                     32 |                   24 |          32 |
+| Inner Capacity  |                     15 |               __22__ |      __22__ |
 
 This design has been since ported to many high-level programming languages.
 Swift, for example, [can store 15 bytes](https://developer.apple.com/documentation/swift/substring/withutf8(_:)#discussion) in the `String` instance itself.
@@ -1530,6 +1530,13 @@ __`SZ_USE_CUDA`, `SZ_USE_KEPLER`, `SZ_USE_HOPPER`__:
 > One can explicitly disable certain families of PTX instructions for compatibility purposes.
 > Default values are inferred at compile time depending on compiler support (for dynamic dispatch) and the target architecture (for static dispatch).
 
+__`SZ_ENFORCE_SVE_OVER_NEON`__:
+
+> SVE and SVE2 are expected to supersede NEON on ARM architectures.
+> Still, oftentimes the equivalent SVE kernels are slower due to equally small register files and higher complexity of the instructions.
+> By default, when both SVE and NEON are available, SVE is used selectively only for the algorithms that benefit from it.
+> If you want to enforce SVE usage everywhere, define this flag.
+
 __`SZ_DYNAMIC_DISPATCH`__:
 
 > By default, StringZilla is a header-only library.

{stringzillas_cuda-4.2.2 → stringzillas_cuda-4.3.0}/README.md

@@ -1089,10 +1089,10 @@ Similar to GCC, StringZilla is 32 bytes in size, and similar to Clang it can fit
 Our layout might be preferential, if you want to avoid branches.
 If you use a different compiler, you may want to check its SSO buffer size with a [simple Gist](https://gist.github.com/ashvardanian/c197f15732d9855c4e070797adf17b21).
 
-|                       | `libstdc++` in  GCC 13 | `libc++` in Clang 17 | StringZilla |
-| :-------------------- | ---------------------: | -------------------: | ----------: |
-| `sizeof(std::string)` |                     32 |                   24 |          32 |
-| Small String Capacity |                     15 |               __22__ |      __22__ |
+|                 | `libstdc++` in  GCC 13 | `libc++` in Clang 17 | StringZilla |
+| :-------------- | ---------------------: | -------------------: | ----------: |
+| String `sizeof` |                     32 |                   24 |          32 |
+| Inner Capacity  |                     15 |               __22__ |      __22__ |
 
 This design has been since ported to many high-level programming languages.
 Swift, for example, [can store 15 bytes](https://developer.apple.com/documentation/swift/substring/withutf8(_:)#discussion) in the `String` instance itself.
@@ -1485,6 +1485,13 @@ __`SZ_USE_CUDA`, `SZ_USE_KEPLER`, `SZ_USE_HOPPER`__:
 > One can explicitly disable certain families of PTX instructions for compatibility purposes.
 > Default values are inferred at compile time depending on compiler support (for dynamic dispatch) and the target architecture (for static dispatch).
 
+__`SZ_ENFORCE_SVE_OVER_NEON`__:
+
+> SVE and SVE2 are expected to supersede NEON on ARM architectures.
+> Still, oftentimes the equivalent SVE kernels are slower due to equally small register files and higher complexity of the instructions.
+> By default, when both SVE and NEON are available, SVE is used selectively only for the algorithms that benefit from it.
+> If you want to enforce SVE usage everywhere, define this flag.
+
 __`SZ_DYNAMIC_DISPATCH`__:
 
 > By default, StringZilla is a header-only library.

stringzillas_cuda-4.3.0/VERSION

@@ -0,0 +1 @@
+4.3.0

{stringzillas_cuda-4.2.2 → stringzillas_cuda-4.3.0}/c/stringzilla.c

@@ -58,6 +58,13 @@ typedef struct sz_implementations_t {
     sz_find_byteset_t find_byteset;
     sz_find_byteset_t rfind_byteset;
 
+    sz_utf8_count_t utf8_count;
+    sz_utf8_find_nth_t utf8_find_nth;
+    sz_utf8_unpack_chunk_t utf8_unpack_chunk;
+    sz_utf8_find_boundary_t utf8_find_newline;
+    sz_utf8_find_boundary_t utf8_find_whitespace;
+    sz_utf8_case_fold_t utf8_case_fold;
+
     sz_sequence_argsort_t sequence_argsort;
     sz_sequence_intersect_t sequence_intersect;
     sz_pgrams_sort_t pgrams_sort;
@@ -99,6 +106,13 @@ static void sz_dispatch_table_update_implementation_(sz_capability_t caps) {
     impl->find_byteset = sz_find_byteset_serial;
     impl->rfind_byteset = sz_rfind_byteset_serial;
 
+    impl->utf8_count = sz_utf8_count_serial;
+    impl->utf8_find_nth = sz_utf8_find_nth_serial;
+    impl->utf8_unpack_chunk = sz_utf8_unpack_chunk_serial;
+    impl->utf8_find_newline = sz_utf8_find_newline_serial;
+    impl->utf8_find_whitespace = sz_utf8_find_whitespace_serial;
+    impl->utf8_case_fold = sz_utf8_case_fold_serial;
+
     impl->sequence_argsort = sz_sequence_argsort_serial;
     impl->sequence_intersect = sz_sequence_intersect_serial;
     impl->pgrams_sort = sz_pgrams_sort_serial;
@@ -147,6 +161,13 @@ static void sz_dispatch_table_update_implementation_(sz_capability_t caps) {
         impl->rfind = sz_rfind_haswell;
         impl->find_byteset = sz_find_byteset_haswell;
         impl->rfind_byteset = sz_rfind_byteset_haswell;
+
+        impl->utf8_count = sz_utf8_count_haswell;
+        impl->utf8_find_nth = sz_utf8_find_nth_haswell;
+        impl->utf8_unpack_chunk = sz_utf8_unpack_chunk_haswell;
+        impl->utf8_find_newline = sz_utf8_find_newline_haswell;
+        impl->utf8_find_whitespace = sz_utf8_find_whitespace_haswell;
+        impl->utf8_case_fold = sz_utf8_case_fold_haswell;
     }
 #endif
 
@@ -181,6 +202,13 @@ static void sz_dispatch_table_update_implementation_(sz_capability_t caps) {
         impl->find_byteset = sz_find_byteset_ice;
         impl->rfind_byteset = sz_rfind_byteset_ice;
 
+        impl->utf8_count = sz_utf8_count_ice;
+        impl->utf8_find_nth = sz_utf8_find_nth_ice;
+        impl->utf8_unpack_chunk = sz_utf8_unpack_chunk_ice;
+        impl->utf8_find_newline = sz_utf8_find_newline_ice;
+        impl->utf8_find_whitespace = sz_utf8_find_whitespace_ice;
+        impl->utf8_case_fold = sz_utf8_case_fold_ice;
+
         impl->lookup = sz_lookup_ice;
 
         impl->bytesum = sz_bytesum_ice;
@@ -215,6 +243,13 @@ static void sz_dispatch_table_update_implementation_(sz_capability_t caps) {
         impl->rfind_byte = sz_rfind_byte_neon;
         impl->find_byteset = sz_find_byteset_neon;
         impl->rfind_byteset = sz_rfind_byteset_neon;
+
+        impl->utf8_count = sz_utf8_count_neon;
+        impl->utf8_find_nth = sz_utf8_find_nth_neon;
+        impl->utf8_unpack_chunk = sz_utf8_unpack_chunk_neon;
+        impl->utf8_find_newline = sz_utf8_find_newline_neon;
+        impl->utf8_find_whitespace = sz_utf8_find_whitespace_neon;
+        impl->utf8_case_fold = sz_utf8_case_fold_neon;
     }
 #endif
 
@@ -238,16 +273,19 @@ static void sz_dispatch_table_update_implementation_(sz_capability_t caps) {
 
 #if SZ_USE_SVE
     if (caps & sz_cap_sve_k) {
-        impl->equal = sz_equal_sve;
-        impl->order = sz_order_sve;
-
-        impl->copy = sz_copy_sve;
-        impl->move = sz_move_sve;
-        impl->fill = sz_fill_sve;
-        impl->lookup = sz_lookup_sve;
-	
-        impl->find = sz_find_sve;
-        // TODO: impl->rfind = sz_rfind_sve;
+        if (SZ_ENFORCE_SVE_OVER_NEON) {
+            impl->equal = sz_equal_sve;
+            impl->order = sz_order_sve;
+
+            impl->copy = sz_copy_sve;
+            impl->move = sz_move_sve;
+            impl->fill = sz_fill_sve;
+            impl->lookup = sz_lookup_sve;
+
+            impl->find = sz_find_sve;
+            // TODO: impl->rfind = sz_rfind_sve;
+        }
+
         impl->find_byte = sz_find_byte_sve;
         impl->rfind_byte = sz_rfind_byte_sve;
 
@@ -260,7 +298,17 @@ static void sz_dispatch_table_update_implementation_(sz_capability_t caps) {
 #endif
 
 #if SZ_USE_SVE2
-    if (caps & sz_cap_sve2_k) { impl->bytesum = sz_bytesum_sve2; }
+    if (caps & sz_cap_sve2_k) {
+        impl->bytesum = sz_bytesum_sve2;
+
+        impl->utf8_count = sz_utf8_count_sve2;
+        impl->utf8_find_nth = sz_utf8_find_nth_sve2;
+
+        if (SZ_ENFORCE_SVE_OVER_NEON) {
+            impl->utf8_find_newline = sz_utf8_find_newline_sve2;
+            impl->utf8_find_whitespace = sz_utf8_find_whitespace_sve2;
+        }
+    }
 #endif
 
 #if SZ_USE_SVE2_AES
@@ -434,6 +482,31 @@ SZ_DYNAMIC sz_status_t sz_sequence_intersect(sz_sequence_t const *first_array, s
                                                 first_positions, second_positions);
 }
 
+SZ_DYNAMIC sz_size_t sz_utf8_count(sz_cptr_t text, sz_size_t length) {
+    return sz_dispatch_table.utf8_count(text, length);
+}
+
+SZ_DYNAMIC sz_cptr_t sz_utf8_find_nth(sz_cptr_t text, sz_size_t length, sz_size_t n) {
+    return sz_dispatch_table.utf8_find_nth(text, length, n);
+}
+
+SZ_DYNAMIC sz_cptr_t sz_utf8_unpack_chunk(sz_cptr_t text, sz_size_t length, sz_rune_t *runes, sz_size_t runes_capacity,
+                                          sz_size_t *runes_unpacked) {
+    return sz_dispatch_table.utf8_unpack_chunk(text, length, runes, runes_capacity, runes_unpacked);
+}
+
+SZ_DYNAMIC sz_cptr_t sz_utf8_find_newline(sz_cptr_t text, sz_size_t length, sz_size_t *matched_length) {
+    return sz_dispatch_table.utf8_find_newline(text, length, matched_length);
+}
+
+SZ_DYNAMIC sz_cptr_t sz_utf8_find_whitespace(sz_cptr_t text, sz_size_t length, sz_size_t *matched_length) {
+    return sz_dispatch_table.utf8_find_whitespace(text, length, matched_length);
+}
+
+SZ_DYNAMIC sz_size_t sz_utf8_case_fold(sz_cptr_t source, sz_size_t source_length, sz_ptr_t destination) {
+    return sz_dispatch_table.utf8_case_fold(source, source_length, destination);
+}
+
 // Provide overrides for the libc mem* functions
 #if SZ_OVERRIDE_LIBC && !defined(__CYGWIN__)
 

{stringzillas_cuda-4.2.2 → stringzillas_cuda-4.3.0}/include/stringzilla/compare.h

@@ -526,7 +526,7 @@ SZ_DYNAMIC sz_bool_t sz_equal(sz_cptr_t a, sz_cptr_t b, sz_size_t length) {
     return sz_equal_skylake(a, b, length);
 #elif SZ_USE_HASWELL
     return sz_equal_haswell(a, b, length);
-#elif SZ_USE_SVE
+#elif SZ_USE_SVE && SZ_ENFORCE_SVE_OVER_NEON
     return sz_equal_sve(a, b, length);
 #elif SZ_USE_NEON
     return sz_equal_neon(a, b, length);
@@ -540,7 +540,7 @@ SZ_DYNAMIC sz_ordering_t sz_order(sz_cptr_t a, sz_size_t a_length, sz_cptr_t b,
     return sz_order_skylake(a, a_length, b, b_length);
 #elif SZ_USE_HASWELL
     return sz_order_haswell(a, a_length, b, b_length);
-#elif SZ_USE_SVE
+#elif SZ_USE_SVE && SZ_ENFORCE_SVE_OVER_NEON
     return sz_order_sve(a, a_length, b, b_length);
 #elif SZ_USE_NEON
     return sz_order_neon(a, a_length, b, b_length);

{stringzillas_cuda-4.2.2 → stringzillas_cuda-4.3.0}/include/stringzilla/find.h

@@ -205,6 +205,41 @@ SZ_PUBLIC sz_cptr_t sz_find_byteset_neon(sz_cptr_t haystack, sz_size_t length, s
 SZ_PUBLIC sz_cptr_t sz_rfind_byteset_neon(sz_cptr_t haystack, sz_size_t length, sz_byteset_t const *set);
 #endif
 
+/**
+ *  @brief  Finds the first occurence of a UTF-8 whitespace or punctuation character in a string.
+ *
+ *  Delimiters include all of the above, plus common "punctuation" characters, "symbols", and "separators",
+ *  as defined by the "Unicode UAX #29" word segmentation standard and implemented in the ICU.
+ *  - around 30 ASCII characters
+ *  - around 130 2-byte characters
+ *  - around 4.3k 3-byte characters
+ *  - around 4.1k 4-byte characters
+ *
+ *  @param[in] text String to be scanned.
+ *  @param[in] length Number of bytes in the string.
+ *  @param[out] matched_length Number of bytes in the matched newline delimiter.
+ *  @return Pointer to the first matching newline character from @p text.
+ */
+SZ_DYNAMIC sz_cptr_t sz_find_delimiter_utf8(sz_cptr_t text, sz_size_t length, sz_size_t *matched_length);
+
+/** @copydoc sz_find_delimiters_utf8 */
+SZ_PUBLIC sz_cptr_t sz_find_delimiters_utf8_serial(sz_cptr_t text, sz_size_t length, sz_size_t *matched_length);
+
+#if SZ_USE_HASWELL
+/** @copydoc sz_find_delimiters_utf8 */
+SZ_PUBLIC sz_cptr_t sz_find_delimiters_utf8_haswell(sz_cptr_t text, sz_size_t length, sz_size_t *matched_length);
+#endif
+
+#if SZ_USE_ICE
+/** @copydoc sz_find_delimiters_utf8 */
+SZ_PUBLIC sz_cptr_t sz_find_delimiters_utf8_ice(sz_cptr_t text, sz_size_t length, sz_size_t *matched_length);
+#endif
+
+#if SZ_USE_NEON
+/** @copydoc sz_find_delimiters_utf8 */
+SZ_PUBLIC sz_cptr_t sz_find_delimiters_utf8_neon(sz_cptr_t text, sz_size_t length, sz_size_t *matched_length);
+#endif
+
 #pragma endregion // Core API
 
 #pragma region Helper Shortcuts
@@ -905,7 +940,7 @@ SZ_PUBLIC sz_cptr_t sz_find_westmere(sz_cptr_t h, sz_size_t h_length, sz_cptr_t
     sz_locate_needle_anomalies_(n, n_length, &offset_first, &offset_mid, &offset_last);
 
     // Broadcast those characters into XMM registers.
-    int matches;
+    sz_u32_vec_t matches_vec;
     sz_u128_vec_t h_first_vec, h_mid_vec, h_last_vec, n_first_vec, n_mid_vec, n_last_vec;
     n_first_vec.xmm = _mm_set1_epi8(n[offset_first]);
     n_mid_vec.xmm = _mm_set1_epi8(n[offset_mid]);
@@ -916,14 +951,14 @@ SZ_PUBLIC sz_cptr_t sz_find_westmere(sz_cptr_t h, sz_size_t h_length, sz_cptr_t
         h_first_vec.xmm = _mm_lddqu_si128((__m128i const *)(h + offset_first));
         h_mid_vec.xmm = _mm_lddqu_si128((__m128i const *)(h + offset_mid));
         h_last_vec.xmm = _mm_lddqu_si128((__m128i const *)(h + offset_last));
-        matches = //
+        matches_vec.i32 = //
             _mm_movemask_epi8(_mm_cmpeq_epi8(h_first_vec.xmm, n_first_vec.xmm)) &
             _mm_movemask_epi8(_mm_cmpeq_epi8(h_mid_vec.xmm, n_mid_vec.xmm)) &
             _mm_movemask_epi8(_mm_cmpeq_epi8(h_last_vec.xmm, n_last_vec.xmm));
-        while (matches) {
-            int potential_offset = sz_u32_ctz(matches);
+        while (matches_vec.u32) {
+            int potential_offset = sz_u32_ctz(matches_vec.u32);
             if (sz_equal_westmere(h + potential_offset, n, n_length)) return h + potential_offset;
-            matches &= matches - 1;
+            matches_vec.u32 &= matches_vec.u32 - 1;
         }
     }
 
@@ -940,7 +975,7 @@ SZ_PUBLIC sz_cptr_t sz_rfind_westmere(sz_cptr_t h, sz_size_t h_length, sz_cptr_t
     sz_locate_needle_anomalies_(n, n_length, &offset_first, &offset_mid, &offset_last);
 
     // Broadcast those characters into XMM registers.
-    int matches;
+    sz_u32_vec_t matches_vec;
     sz_u128_vec_t h_first_vec, h_mid_vec, h_last_vec, n_first_vec, n_mid_vec, n_last_vec;
     n_first_vec.xmm = _mm_set1_epi8(n[offset_first]);
     n_mid_vec.xmm = _mm_set1_epi8(n[offset_mid]);
@@ -953,15 +988,15 @@ SZ_PUBLIC sz_cptr_t sz_rfind_westmere(sz_cptr_t h, sz_size_t h_length, sz_cptr_t
         h_first_vec.xmm = _mm_lddqu_si128((__m128i const *)(h_reversed + offset_first));
         h_mid_vec.xmm = _mm_lddqu_si128((__m128i const *)(h_reversed + offset_mid));
         h_last_vec.xmm = _mm_lddqu_si128((__m128i const *)(h_reversed + offset_last));
-        matches = //
+        matches_vec.i32 = //
             _mm_movemask_epi8(_mm_cmpeq_epi8(h_first_vec.xmm, n_first_vec.xmm)) &
             _mm_movemask_epi8(_mm_cmpeq_epi8(h_mid_vec.xmm, n_mid_vec.xmm)) &
             _mm_movemask_epi8(_mm_cmpeq_epi8(h_last_vec.xmm, n_last_vec.xmm));
-        while (matches) {
-            int potential_offset = sz_u32_clz(matches) - 16;
+        while (matches_vec.u32) {
+            int potential_offset = sz_u32_clz(matches_vec.u32) - 16;
             if (sz_equal_westmere(h + h_length - n_length - potential_offset, n, n_length))
                 return h + h_length - n_length - potential_offset;
-            matches &= ~(1 << (15 - potential_offset));
+            matches_vec.u32 &= ~(1u << (15 - potential_offset));
         }
     }
 
@@ -1029,7 +1064,7 @@ SZ_PUBLIC sz_cptr_t sz_find_haswell(sz_cptr_t h, sz_size_t h_length, sz_cptr_t n
     sz_locate_needle_anomalies_(n, n_length, &offset_first, &offset_mid, &offset_last);
 
     // Broadcast those characters into YMM registers.
-    int matches;
+    sz_u32_vec_t matches_vec;
     sz_u256_vec_t h_first_vec, h_mid_vec, h_last_vec, n_first_vec, n_mid_vec, n_last_vec;
     n_first_vec.ymm = _mm256_set1_epi8(n[offset_first]);
     n_mid_vec.ymm = _mm256_set1_epi8(n[offset_mid]);
@@ -1040,14 +1075,14 @@ SZ_PUBLIC sz_cptr_t sz_find_haswell(sz_cptr_t h, sz_size_t h_length, sz_cptr_t n
         h_first_vec.ymm = _mm256_lddqu_si256((__m256i const *)(h + offset_first));
         h_mid_vec.ymm = _mm256_lddqu_si256((__m256i const *)(h + offset_mid));
         h_last_vec.ymm = _mm256_lddqu_si256((__m256i const *)(h + offset_last));
-        matches = //
+        matches_vec.i32 = //
             _mm256_movemask_epi8(_mm256_cmpeq_epi8(h_first_vec.ymm, n_first_vec.ymm)) &
             _mm256_movemask_epi8(_mm256_cmpeq_epi8(h_mid_vec.ymm, n_mid_vec.ymm)) &
             _mm256_movemask_epi8(_mm256_cmpeq_epi8(h_last_vec.ymm, n_last_vec.ymm));
-        while (matches) {
-            int potential_offset = sz_u32_ctz(matches);
+        while (matches_vec.u32) {
+            int potential_offset = sz_u32_ctz(matches_vec.u32);
             if (sz_equal_haswell(h + potential_offset, n, n_length)) return h + potential_offset;
-            matches &= matches - 1;
+            matches_vec.u32 &= matches_vec.u32 - 1;
         }
     }
 
@@ -1065,7 +1100,7 @@ SZ_PUBLIC sz_cptr_t sz_rfind_haswell(sz_cptr_t h, sz_size_t h_length, sz_cptr_t
     sz_locate_needle_anomalies_(n, n_length, &offset_first, &offset_mid, &offset_last);
 
     // Broadcast those characters into YMM registers.
-    int matches;
+    sz_u32_vec_t matches_vec;
     sz_u256_vec_t h_first_vec, h_mid_vec, h_last_vec, n_first_vec, n_mid_vec, n_last_vec;
     n_first_vec.ymm = _mm256_set1_epi8(n[offset_first]);
     n_mid_vec.ymm = _mm256_set1_epi8(n[offset_mid]);
@@ -1078,15 +1113,15 @@ SZ_PUBLIC sz_cptr_t sz_rfind_haswell(sz_cptr_t h, sz_size_t h_length, sz_cptr_t
         h_first_vec.ymm = _mm256_lddqu_si256((__m256i const *)(h_reversed + offset_first));
         h_mid_vec.ymm = _mm256_lddqu_si256((__m256i const *)(h_reversed + offset_mid));
         h_last_vec.ymm = _mm256_lddqu_si256((__m256i const *)(h_reversed + offset_last));
-        matches = //
+        matches_vec.i32 = //
             _mm256_movemask_epi8(_mm256_cmpeq_epi8(h_first_vec.ymm, n_first_vec.ymm)) &
             _mm256_movemask_epi8(_mm256_cmpeq_epi8(h_mid_vec.ymm, n_mid_vec.ymm)) &
             _mm256_movemask_epi8(_mm256_cmpeq_epi8(h_last_vec.ymm, n_last_vec.ymm));
-        while (matches) {
-            int potential_offset = sz_u32_clz(matches);
+        while (matches_vec.u32) {
+            int potential_offset = sz_u32_clz(matches_vec.u32);
             if (sz_equal_haswell(h + h_length - n_length - potential_offset, n, n_length))
                 return h + h_length - n_length - potential_offset;
-            matches &= ~(1 << (31 - potential_offset));
+            matches_vec.u32 &= ~(1u << (31 - potential_offset));
         }
     }
 
@@ -1388,9 +1423,8 @@ SZ_PUBLIC sz_cptr_t sz_rfind_skylake(sz_cptr_t h, sz_size_t h_length, sz_cptr_t
             int potential_offset = sz_u64_clz(matches);
             if (n_length <= 3 || sz_equal_skylake(h + h_length - n_length - potential_offset, n, n_length))
                 return h + h_length - n_length - potential_offset;
-            sz_assert_((matches & ((sz_u64_t)1 << (63 - potential_offset))) != 0 &&
-                       "The bit must be set before we squash it");
-            matches &= ~((sz_u64_t)1 << (63 - potential_offset));
+            sz_assert_((matches & (1ull << (63 - potential_offset))) != 0 && "The bit must be set before we squash it");
+            matches &= ~(1ull << (63 - potential_offset));
         }
     }
 
@@ -1409,9 +1443,8 @@ SZ_PUBLIC sz_cptr_t sz_rfind_skylake(sz_cptr_t h, sz_size_t h_length, sz_cptr_t
             int potential_offset = sz_u64_clz(matches);
             if (n_length <= 3 || sz_equal_skylake(h + 64 - potential_offset - 1, n, n_length))
                 return h + 64 - potential_offset - 1;
-            sz_assert_((matches & ((sz_u64_t)1 << (63 - potential_offset))) != 0 &&
-                       "The bit must be set before we squash it");
-            matches &= ~((sz_u64_t)1 << (63 - potential_offset));
+            sz_assert_((matches & (1ull << (63 - potential_offset))) != 0 && "The bit must be set before we squash it");
+            matches &= ~(1ull << (63 - potential_offset));
         }
     }
 
@@ -1584,7 +1617,7 @@ SZ_PUBLIC sz_cptr_t sz_rfind_byteset_ice(sz_cptr_t text, sz_size_t length, sz_by
 #pragma GCC target("+simd")
 #endif
 
-SZ_INTERNAL sz_u64_t sz_vreinterpretq_u8_u4_(uint8x16_t vec) {
+SZ_INTERNAL sz_u64_t sz_find_vreinterpretq_u8_u4_(uint8x16_t vec) {
     // Use `vshrn` to produce a bitmask, similar to `movemask` in SSE.
     // https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/porting-x86-vector-bitmask-optimizations-to-arm-neon
     return vget_lane_u64(vreinterpret_u64_u8(vshrn_n_u16(vreinterpretq_u16_u8(vec), 4)), 0) & 0x8888888888888888ull;
@@ -1601,7 +1634,7 @@ SZ_PUBLIC sz_cptr_t sz_find_byte_neon(sz_cptr_t h, sz_size_t h_length, sz_cptr_t
         // In Arm NEON we don't have a `movemask` to combine it with `ctz` and get the offset of the match.
         // But assuming the `vmaxvq` is cheap, we can use it to find the first match, by blending (bitwise selecting)
         // the vector with a relative offsets array.
-        matches = sz_vreinterpretq_u8_u4_(matches_vec.u8x16);
+        matches = sz_find_vreinterpretq_u8_u4_(matches_vec.u8x16);
         if (matches) return h + sz_u64_ctz(matches) / 4;
 
         h += 16, h_length -= 16;
@@ -1618,7 +1651,7 @@ SZ_PUBLIC sz_cptr_t sz_rfind_byte_neon(sz_cptr_t h, sz_size_t h_length, sz_cptr_
     while (h_length >= 16) {
         h_vec.u8x16 = vld1q_u8((sz_u8_t const *)h + h_length - 16);
         matches_vec.u8x16 = vceqq_u8(h_vec.u8x16, n_vec.u8x16);
-        matches = sz_vreinterpretq_u8_u4_(matches_vec.u8x16);
+        matches = sz_find_vreinterpretq_u8_u4_(matches_vec.u8x16);
         if (matches) return h + h_length - 1 - sz_u64_clz(matches) / 4;
         h_length -= 16;
     }
@@ -1643,7 +1676,7 @@ SZ_PUBLIC sz_u64_t sz_find_byteset_neon_register_( //
     uint8x16_t matches_vec = vorrq_u8(matches_top_vec, matches_bottom_vec);
     // Istead of pure `vandq_u8`, we can immediately broadcast a match presence across each 8-bit word.
     matches_vec = vtstq_u8(matches_vec, byte_mask_vec);
-    return sz_vreinterpretq_u8_u4_(matches_vec);
+    return sz_find_vreinterpretq_u8_u4_(matches_vec);
 }
 
 SZ_PUBLIC sz_cptr_t sz_find_neon(sz_cptr_t h, sz_size_t h_length, sz_cptr_t n, sz_size_t n_length) {
@@ -1668,7 +1701,7 @@ SZ_PUBLIC sz_cptr_t sz_find_neon(sz_cptr_t h, sz_size_t h_length, sz_cptr_t n, s
             h_last_vec.u8x16 = vld1q_u8((sz_u8_t const *)(h + 1));
             matches_vec.u8x16 =
                 vandq_u8(vceqq_u8(h_first_vec.u8x16, n_first_vec.u8x16), vceqq_u8(h_last_vec.u8x16, n_last_vec.u8x16));
-            matches = sz_vreinterpretq_u8_u4_(matches_vec.u8x16);
+            matches = sz_find_vreinterpretq_u8_u4_(matches_vec.u8x16);
             if (matches) return h + sz_u64_ctz(matches) / 4;
         }
     }
@@ -1690,7 +1723,7 @@ SZ_PUBLIC sz_cptr_t sz_find_neon(sz_cptr_t h, sz_size_t h_length, sz_cptr_t n, s
                     vceqq_u8(h_first_vec.u8x16, n_first_vec.u8x16), //
                     vceqq_u8(h_mid_vec.u8x16, n_mid_vec.u8x16)),
                 vceqq_u8(h_last_vec.u8x16, n_last_vec.u8x16));
-            matches = sz_vreinterpretq_u8_u4_(matches_vec.u8x16);
+            matches = sz_find_vreinterpretq_u8_u4_(matches_vec.u8x16);
             if (matches) return h + sz_u64_ctz(matches) / 4;
         }
     }
@@ -1714,7 +1747,7 @@ SZ_PUBLIC sz_cptr_t sz_find_neon(sz_cptr_t h, sz_size_t h_length, sz_cptr_t n, s
                     vceqq_u8(h_first_vec.u8x16, n_first_vec.u8x16), //
                     vceqq_u8(h_mid_vec.u8x16, n_mid_vec.u8x16)),
                 vceqq_u8(h_last_vec.u8x16, n_last_vec.u8x16));
-            matches = sz_vreinterpretq_u8_u4_(matches_vec.u8x16);
+            matches = sz_find_vreinterpretq_u8_u4_(matches_vec.u8x16);
             while (matches) {
                 int potential_offset = sz_u64_ctz(matches) / 4;
                 if (sz_equal_neon(h + potential_offset, n, n_length)) return h + potential_offset;
@@ -1754,7 +1787,7 @@ SZ_PUBLIC sz_cptr_t sz_rfind_neon(sz_cptr_t h, sz_size_t h_length, sz_cptr_t n,
                 vceqq_u8(h_first_vec.u8x16, n_first_vec.u8x16), //
                 vceqq_u8(h_mid_vec.u8x16, n_mid_vec.u8x16)),
             vceqq_u8(h_last_vec.u8x16, n_last_vec.u8x16));
-        matches = sz_vreinterpretq_u8_u4_(matches_vec.u8x16);
+        matches = sz_find_vreinterpretq_u8_u4_(matches_vec.u8x16);
         while (matches) {
             int potential_offset = sz_u64_clz(matches) / 4;
             if (sz_equal_neon(h + h_length - n_length - potential_offset, n, n_length))
@@ -1966,7 +1999,7 @@ SZ_DYNAMIC sz_cptr_t sz_find_byte(sz_cptr_t haystack, sz_size_t h_length, sz_cpt
     return sz_find_byte_haswell(haystack, h_length, needle);
 #elif SZ_USE_WESTMERE
     return sz_find_byte_westmere(haystack, h_length, needle);
-#elif SZ_USE_SVE
+#elif SZ_USE_SVE // ? actually faster than NEON on most machines
     return sz_find_byte_sve(haystack, h_length, needle);
 #elif SZ_USE_NEON
     return sz_find_byte_neon(haystack, h_length, needle);
@@ -1982,7 +2015,7 @@ SZ_DYNAMIC sz_cptr_t sz_rfind_byte(sz_cptr_t haystack, sz_size_t h_length, sz_cp
     return sz_rfind_byte_haswell(haystack, h_length, needle);
 #elif SZ_USE_WESTMERE
     return sz_rfind_byte_westmere(haystack, h_length, needle);
-#elif SZ_USE_SVE
+#elif SZ_USE_SVE // ? actually faster than NEON on most machines
     return sz_rfind_byte_sve(haystack, h_length, needle);
 #elif SZ_USE_NEON
     return sz_rfind_byte_neon(haystack, h_length, needle);
@@ -1998,7 +2031,7 @@ SZ_DYNAMIC sz_cptr_t sz_find(sz_cptr_t haystack, sz_size_t h_length, sz_cptr_t n
     return sz_find_haswell(haystack, h_length, needle, n_length);
 #elif SZ_USE_WESTMERE
     return sz_find_westmere(haystack, h_length, needle, n_length);
-#elif SZ_USE_SVE
+#elif SZ_USE_SVE && SZ_ENFORCE_SVE_OVER_NEON
     return sz_find_sve(haystack, h_length, needle, n_length);
 #elif SZ_USE_NEON
     return sz_find_neon(haystack, h_length, needle, n_length);