Improve: Pick SVE over NEON by measured register width

`SZ_ENFORCE_SVE_OVER_NEON` pretended to be a global policy switch but only
half the kernel families honored it (compare, memory, find, UTF-8 tokens -
not hash or intersect), its "enforce everywhere" README promise was false,
and as a compile-time constant it answered a question that is inherently
per-machine: whether the scalable kernels beat NEON depends on the SVE
register width, which Arm implementations choose freely.

Replace the flag with the width question asked directly, once per dispatch
context:

- Runtime dispatch measures the running CPU with `svcntb` through the new
  `sz_sve_wider_than_neon_` helper in `dispatch.h`, next to the dispatch
  table it serves. At the common 128-bit vector length the length-sensitive
  families keep their faster NEON kernels; wider implementations get the
  scalable ones automatically.
- Compile-time dispatch consults `SZ_SVE_WIDER_THAN_NEON_` in `types.h`,
  driven by `__ARM_FEATURE_SVE_BITS` when the width is pinned via
  `-msve-vector-bits=N`; unpinned builds assume the common 128-bit case and
  keep NEON, matching the flag's old default behavior bit for bit.

The crypto-heavy families are untouched and prefer SVE2 at any width. On
128-bit implementations like Graviton 4 the four families now stay on NEON,
matching measurements; on wider ones like Graviton 3 (256-bit) or A64FX
(512-bit) the scalable kernels are finally selected automatically - a
combination the old default could never reach. To force a specific backend
regardless, the `SZ_USE_SVE`/`SZ_USE_SVE2`/`SZ_USE_NEON` toggles remain.

Verified with all Arm tiers enabled across all sixteen C translation units
under Clang 20 at a plain `armv8-a` baseline, GCC 12 on Linux-Arm with
`-Werror=implicit-function-declaration`, and both Cargo dispatch modes.

Author: ashvardanian

c/stringzilla/compare.c

@@ -41,7 +41,9 @@ SZ_DISPATCH_INTERNAL void sz_dispatch_compare_update_(sz_capability_t caps) {
 
 #if SZ_USE_SVE
     if (caps & sz_cap_sve_k) {
-        if (SZ_ENFORCE_SVE_OVER_NEON) {
+        // Wider-than-NEON registers are where the scalable comparison kernels win; at the common
+        // 128-bit vector length the NEON kernels stay faster, so keep them.
+        if (sz_sve_wider_than_neon_()) {
             impl->equal = sz_equal_sve;
             impl->order = sz_order_sve;
         }

c/stringzilla/dispatch.h

@@ -108,4 +108,24 @@ SZ_DISPATCH_INTERNAL void sz_dispatch_utf8_uncased_fold_update_(sz_capability_t
 SZ_DISPATCH_INTERNAL void sz_dispatch_utf8_norm_update_(sz_capability_t caps);
 SZ_DISPATCH_INTERNAL void sz_dispatch_utf8_uncased_update_(sz_capability_t caps);
 
+#if SZ_IS_64BIT_ARM_ && (SZ_USE_SVE || SZ_USE_SVE2) && !defined(_MSC_VER)
+#if defined(__clang__)
+#pragma clang attribute push(__attribute__((target("+sve"))), apply_to = function)
+#elif defined(__GNUC__)
+#pragma GCC push_options
+#pragma GCC target("+sve")
+#endif
+/**
+ *  @brief Whether the running CPU's SVE registers are wider than NEON's 128 bits - the point where the
+ *         scalable kernels start outrunning NEON in the length-sensitive families (the runtime
+ *         counterpart of the compile-time `SZ_SVE_WIDER_THAN_NEON_` in `types.h`).
+ */
+SZ_MAYBE_UNUSED SZ_C_INLINE sz_bool_t sz_sve_wider_than_neon_(void) { return svcntb() > 16 ? sz_true_k : sz_false_k; }
+#if defined(__clang__)
+#pragma clang attribute pop
+#elif defined(__GNUC__)
+#pragma GCC pop_options
+#endif
+#endif // SZ_IS_64BIT_ARM_ && (SZ_USE_SVE || SZ_USE_SVE2) && !defined(_MSC_VER)
+
 #endif // STRINGZILLA_DISPATCH_H_

c/stringzilla/find.c

@@ -78,7 +78,9 @@ SZ_DISPATCH_INTERNAL void sz_dispatch_find_update_(sz_capability_t caps) {
 
 #if SZ_USE_SVE
     if (caps & sz_cap_sve_k) {
-        if (SZ_ENFORCE_SVE_OVER_NEON) {
+        // Wider-than-NEON registers are where the scalable substring kernels win; at the common
+        // 128-bit vector length the NEON kernels stay faster, so keep them.
+        if (sz_sve_wider_than_neon_()) {
             impl->find = sz_find_sve;
             // TODO: impl->rfind = sz_rfind_sve;
         }

c/stringzilla/memory.c

@@ -59,7 +59,9 @@ SZ_DISPATCH_INTERNAL void sz_dispatch_memory_update_(sz_capability_t caps) {
 
 #if SZ_USE_SVE
     if (caps & sz_cap_sve_k) {
-        if (SZ_ENFORCE_SVE_OVER_NEON) {
+        // Wider-than-NEON registers are where the scalable memory kernels win; at the common
+        // 128-bit vector length the NEON kernels stay faster, so keep them.
+        if (sz_sve_wider_than_neon_()) {
             impl->copy = sz_copy_sve;
             impl->move = sz_move_sve;
             impl->fill = sz_fill_sve;

c/stringzilla/utf8_tokens.c

@@ -40,7 +40,9 @@ SZ_DISPATCH_INTERNAL void sz_dispatch_utf8_tokens_update_(sz_capability_t caps)
 
 #if SZ_USE_SVE2
     if (caps & sz_cap_sve2_k) {
-        if (SZ_ENFORCE_SVE_OVER_NEON) {
+        // Wider-than-NEON registers are where the scalable token-scanning kernels win; at the common
+        // 128-bit vector length the NEON kernels stay faster, so keep them.
+        if (sz_sve_wider_than_neon_()) {
             impl->utf8_newlines = sz_utf8_newlines_sve2;
             impl->utf8_whitespaces = sz_utf8_whitespaces_sve2;
         }

include/stringzilla/README.md

@@ -781,6 +781,10 @@ The runtime probe inspects CPUID on x86, the AArch64 ID registers on ARM with a
 Detection always reports the full hardware truth, independent of which tiers a build compiled in; `sz_capabilities()` intersects it with the compile-time mask.
 WebAssembly is the exception with no runtime probe at all — a module carrying unsupported SIMD opcodes fails validation at instantiation, so its capabilities are fixed at compile time (`SZ_CAPABILITIES_RUNTIME_DETECTABLE_` reports whether the current platform can introspect).
 
+On Arm, having SVE in the capability mask doesn't mean SVE kernels always win: at the common 128-bit vector length the scalable kernels for length-sensitive operations — comparisons, memory transforms, substring search, UTF-8 token scanning — are often slower than their NEON twins, while crypto-heavy operations like hashing prefer SVE2 at any width.
+Dispatch therefore picks by register width: the load-time table measures it on the running CPU (`svcntb`), and compile-time dispatch consults `__ARM_FEATURE_SVE_BITS` when pinned via `-msve-vector-bits=N`, otherwise assuming the 128-bit case and keeping NEON.
+To force a specific backend regardless, use the `SZ_USE_SVE`/`SZ_USE_SVE2`/`SZ_USE_NEON` toggles.
+
 The same machinery drives the build systems through the checked-in `probes/` programs: CMake and Cargo try-compile `probes/<arch>_<tier>.c` — tiny standalone programs reusing the real kernels' `target` pragmas, intrinsics, and platform guards — to learn which tiers the toolchain can __compile__, and execute `probes/run_capabilities.c` to learn which tiers the build machine can __run__.
 Runtime-dispatched libraries enable everything compilable, trusting the load-time table to mask the rest; compile-time builds bake the intersection of the two sets.
 
@@ -1011,13 +1015,6 @@ __`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.

include/stringzilla/compare.h

@@ -197,7 +197,7 @@ SZ_API_RUNTIME 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 && SZ_ENFORCE_SVE_OVER_NEON
+#elif SZ_USE_SVE && SZ_SVE_WIDER_THAN_NEON_
     return sz_equal_sve(a, b, length);
 #elif SZ_USE_NEON
     return sz_equal_neon(a, b, length);
@@ -221,7 +221,7 @@ SZ_API_RUNTIME sz_ordering_t sz_order(sz_cptr_t a, sz_size_t a_length, sz_cptr_t
     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 && SZ_ENFORCE_SVE_OVER_NEON
+#elif SZ_USE_SVE && SZ_SVE_WIDER_THAN_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);

include/stringzilla/find.h

@@ -513,7 +513,7 @@ SZ_API_RUNTIME sz_cptr_t sz_find(sz_cptr_t haystack, sz_size_t haystack_length,
     return sz_find_haswell(haystack, haystack_length, needle, needle_length);
 #elif SZ_USE_WESTMERE
     return sz_find_westmere(haystack, haystack_length, needle, needle_length);
-#elif SZ_USE_SVE && SZ_ENFORCE_SVE_OVER_NEON
+#elif SZ_USE_SVE && SZ_SVE_WIDER_THAN_NEON_
     return sz_find_sve(haystack, haystack_length, needle, needle_length);
 #elif SZ_USE_NEON
     return sz_find_neon(haystack, haystack_length, needle, needle_length);

include/stringzilla/memory.h

@@ -417,7 +417,7 @@ SZ_API_RUNTIME void sz_copy(sz_ptr_t target, sz_cptr_t source, sz_size_t length)
     sz_copy_skylake(target, source, length);
 #elif SZ_USE_HASWELL
     sz_copy_haswell(target, source, length);
-#elif SZ_USE_SVE && SZ_ENFORCE_SVE_OVER_NEON
+#elif SZ_USE_SVE && SZ_SVE_WIDER_THAN_NEON_
     sz_copy_sve(target, source, length);
 #elif SZ_USE_NEON
     sz_copy_neon(target, source, length);
@@ -441,7 +441,7 @@ SZ_API_RUNTIME void sz_move(sz_ptr_t target, sz_cptr_t source, sz_size_t length)
     sz_move_skylake(target, source, length);
 #elif SZ_USE_HASWELL
     sz_move_haswell(target, source, length);
-#elif SZ_USE_SVE && SZ_ENFORCE_SVE_OVER_NEON
+#elif SZ_USE_SVE && SZ_SVE_WIDER_THAN_NEON_
     sz_move_sve(target, source, length);
 #elif SZ_USE_NEON
     sz_move_neon(target, source, length);
@@ -465,7 +465,7 @@ SZ_API_RUNTIME void sz_fill(sz_ptr_t target, sz_size_t length, sz_u8_t value) {
     sz_fill_skylake(target, length, value);
 #elif SZ_USE_HASWELL
     sz_fill_haswell(target, length, value);
-#elif SZ_USE_SVE && SZ_ENFORCE_SVE_OVER_NEON
+#elif SZ_USE_SVE && SZ_SVE_WIDER_THAN_NEON_
     sz_fill_sve(target, length, value);
 #elif SZ_USE_NEON
     sz_fill_neon(target, length, value);
@@ -489,7 +489,7 @@ SZ_API_RUNTIME void sz_lookup(sz_ptr_t target, sz_size_t length, sz_cptr_t sourc
     sz_lookup_icelake(target, length, source, lut);
 #elif SZ_USE_HASWELL
     sz_lookup_haswell(target, length, source, lut);
-#elif SZ_USE_SVE && SZ_ENFORCE_SVE_OVER_NEON
+#elif SZ_USE_SVE && SZ_SVE_WIDER_THAN_NEON_
     sz_lookup_sve(target, length, source, lut);
 #elif SZ_USE_NEON
     sz_lookup_neon(target, length, source, lut);

include/stringzilla/types.h

@@ -399,9 +399,18 @@
 #endif
 #endif
 
-/**  SVE isn't a silver bullet. Oftentimes its still slower and with this flag you can disable it. */
-#if !defined(SZ_ENFORCE_SVE_OVER_NEON)
-#define SZ_ENFORCE_SVE_OVER_NEON (0)
+/**
+ *  SVE isn't a silver bullet: in the length-sensitive kernel families (compare, memory, find, UTF-8
+ *  tokens) the scalable kernels only outrun NEON when the registers are wider than NEON's 128 bits,
+ *  while the crypto-heavy families (like hashing) win on SVE2 at any width. At compile time the width
+ *  is only known when pinned via `-msve-vector-bits=N` (`__ARM_FEATURE_SVE_BITS`); unpinned builds
+ *  assume the common 128-bit case and keep NEON. Runtime dispatch measures the actual width with
+ *  `sz_sve_wider_than_neon_` instead of trusting this compile-time assumption.
+ */
+#if defined(__ARM_FEATURE_SVE_BITS) && (__ARM_FEATURE_SVE_BITS > 128)
+#define SZ_SVE_WIDER_THAN_NEON_ (1)
+#else
+#define SZ_SVE_WIDER_THAN_NEON_ (0)
 #endif
 
 /**