pystrhex: Add SIMD optimization for large separator groups

Extend the portable SIMD hexlify to handle separator cases where
bytes_per_sep >= 16. Uses in-place shuffle: SIMD hexlify to output
buffer, then work backwards to insert separators via memmove.

For 4096 bytes with sep=32: ~3.3µs (vs ~7.3µs for sep=1 scalar).
Useful for hex dump style output like bytes.hex('\n', 32).

Also adds benchmark for newline separator every 32 bytes.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: gpshead

Python/pystrhex.c

@@ -184,6 +184,50 @@ static PyObject *_Py_strhex_impl(const char* argbuf, const Py_ssize_t arglen,
         Py_ssize_t chunk;
         unsigned int k;
 
+#if PY_HEXLIFY_CAN_COMPILE_SIMD
+        /* SIMD path for large separator groups (>= 16 bytes per group).
+           SIMD hexlify to output buffer, then shuffle in-place to insert
+           separators. Working backwards avoids overlap issues since we're
+           expanding (destination index >= source index). */
+        if (abs_bytes_per_sep >= 16 && arglen >= 16) {
+            /* SIMD hexlify all bytes to start of output buffer */
+            _Py_hexlify_simd((const unsigned char *)argbuf, retbuf, arglen);
+
+            /* Shuffle in-place, working backwards */
+            Py_ssize_t hex_chunk_size = 2 * (Py_ssize_t)abs_bytes_per_sep;
+            Py_ssize_t remainder_bytes = arglen - chunks * (Py_ssize_t)abs_bytes_per_sep;
+            Py_ssize_t remainder_hex_len = 2 * remainder_bytes;
+            Py_ssize_t hex_pos = 2 * arglen;   /* End of hex data */
+            Py_ssize_t out_pos = resultlen;    /* End of output */
+
+            if (bytes_per_sep_group < 0) {
+                /* Forward: remainder at end, separators after each chunk */
+                if (remainder_hex_len > 0) {
+                    hex_pos -= remainder_hex_len;
+                    out_pos -= remainder_hex_len;
+                    memmove(retbuf + out_pos, retbuf + hex_pos, remainder_hex_len);
+                }
+                for (Py_ssize_t c = chunks - 1; c >= 0; c--) {
+                    retbuf[--out_pos] = sep_char;
+                    hex_pos -= hex_chunk_size;
+                    out_pos -= hex_chunk_size;
+                    memmove(retbuf + out_pos, retbuf + hex_pos, hex_chunk_size);
+                }
+            }
+            else {
+                /* Backward: remainder at start, separators before each chunk */
+                for (Py_ssize_t c = chunks - 1; c >= 0; c--) {
+                    hex_pos -= hex_chunk_size;
+                    out_pos -= hex_chunk_size;
+                    memmove(retbuf + out_pos, retbuf + hex_pos, hex_chunk_size);
+                    retbuf[--out_pos] = sep_char;
+                }
+                /* Remainder at start stays in place (hex_pos == out_pos == remainder_hex_len) */
+            }
+            goto done_hexlify;
+        }
+#endif /* PY_HEXLIFY_CAN_COMPILE_SIMD */
+
         if (bytes_per_sep_group < 0) {
             i = j = 0;
             for (chunk = 0; chunk < chunks; chunk++) {
@@ -221,6 +265,10 @@ static PyObject *_Py_strhex_impl(const char* argbuf, const Py_ssize_t arglen,
         }
     }
 
+#if PY_HEXLIFY_CAN_COMPILE_SIMD
+done_hexlify:
+#endif
+
 #ifdef Py_DEBUG
     if (!return_bytes) {
         assert(_PyUnicode_CheckConsistency(retval, 1));

Tools/scripts/pystrhex_benchmark.py

@@ -79,6 +79,21 @@ def bench_bytes_hex_sep_group():
         print(f"  {ns:7.1f} ns    {format_size(size)}")
 
 
+def bench_bytes_hex_newline_32():
+    """Benchmark bytes.hex() with newline separator every 32 bytes.
+
+    This simulates hex dump output with 32 bytes (64 hex chars) per line.
+    """
+    print("\nbytes.hex('\\n', 32) with newline (every 32 bytes):")
+    # Only test sizes >= 32 where this grouping is meaningful
+    for size in SIZES:
+        if size < 32:
+            continue
+        data = DATA[size]
+        ns = run_benchmark(lambda d=data: d.hex('\n', 32))
+        print(f"  {ns:7.1f} ns    {format_size(size)}")
+
+
 def bench_bytearray_hex():
     """Benchmark bytearray.hex() for comparison."""
     print("\nbytearray.hex() by size:")
@@ -179,6 +194,7 @@ def bench_hash_hexdigest_only():
     bench_bytes_hex()
     bench_bytes_hex_sep()
     bench_bytes_hex_sep_group()
+    bench_bytes_hex_newline_32()
     bench_bytearray_hex()
     bench_memoryview_hex()
     bench_binascii_hexlify()