pystrhex: Remove SIMD path for separator groups

The SIMD-accelerated separator insertion code (for bytes_per_sep >= 8)
adds maintenance complexity with less clear benefit. Remove it along
with the test_hex_simd_separator test per reviewer feedback.

The no-separator SIMD path remains, which is the primary performance
win for bytes.hex(), bytearray.hex(), and binascii.hexlify().

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

Author: gpshead

Lib/test/test_bytes.py

@@ -615,56 +615,6 @@ def test_hex_nibble_boundaries(self):
         simd_boundary = self.type2test(boundary_bytes * 2)
         self.assertEqual(simd_boundary.hex(), '090a90999aa0a9aa00ff' * 2)
 
-    def test_hex_simd_separator(self):
-        # Test SIMD path for separator insertion (sep >= 8 bytes, len >= 16).
-        # SIMD hexlifies then shuffles in-place to insert separators.
-
-        # 32 bytes exercises SIMD; test various separator group sizes
-        data = self.type2test(bytes(range(32)))
-
-        # bytes_per_sep=8: 4 groups of 8 bytes, 3 separators
-        self.assertEqual(
-            data.hex('-', 8),
-            '0001020304050607-08090a0b0c0d0e0f-'
-            '1011121314151617-18191a1b1c1d1e1f'
-        )
-        # bytes_per_sep=9: groups of 9 from start, 5 byte remainder at end
-        self.assertEqual(
-            data.hex('.', 9),
-            '0001020304.05060708090a0b0c0d.'
-            '0e0f10111213141516.1718191a1b1c1d1e1f'
-        )
-        # bytes_per_sep=16: 2 groups of 16 bytes
-        self.assertEqual(
-            data.hex(' ', 16),
-            '000102030405060708090a0b0c0d0e0f '
-            '101112131415161718191a1b1c1d1e1f'
-        )
-        # Negative bytes_per_sep: groups from end, remainder at start
-        self.assertEqual(
-            data.hex('|', -8),
-            '0001020304050607|08090a0b0c0d0e0f|'
-            '1011121314151617|18191a1b1c1d1e1f'
-        )
-        self.assertEqual(
-            data.hex('_', -9),
-            '000102030405060708_090a0b0c0d0e0f1011_'
-            '12131415161718191a_1b1c1d1e1f'
-        )
-
-        # 20 bytes: SIMD (16) + 4 byte scalar remainder
-        data20 = self.type2test(bytes(range(20)))
-        # Positive: groups from start, remainder at end
-        self.assertEqual(
-            data20.hex('#', 8),
-            '00010203#0405060708090a0b#0c0d0e0f10111213'
-        )
-        # Negative: groups from end, remainder at start
-        self.assertEqual(
-            data20.hex('@', -8),
-            '0001020304050607@08090a0b0c0d0e0f@10111213'
-        )
-
     def test_join(self):
         self.assertEqual(self.type2test(b"").join([]), b"")
         self.assertEqual(self.type2test(b"").join([b""]), b"")

Python/pystrhex.c

@@ -219,50 +219,6 @@ 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 separator groups >= 8 bytes.
-           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 >= 8 && 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++) {
@@ -300,10 +256,6 @@ 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));