perf(gap): hoist UUID-list bounds check via safe_end

Pre-compute ``safe_end = start + ((end - start) & ~(N-1))`` ahead of each
16/32/128-bit Service UUID list loop and trim the ``range`` instead of
re-evaluating ``i + N <= end`` inside the loop body. The stride is a
power of two for all three paths, so the bit-AND drops any malformed
trailing remainder — same skip semantics, fewer per-iter ops.

Pure-Python microbench (200k iters, min of 5):

- 16-bit list (7 UUIDs):  4.24us -> 3.42us  (-19%)
- 32-bit list (3 UUIDs):  3.57us -> 3.06us  (-14%)
- 128-bit list (2 UUIDs): 2.27us -> 2.40us  (small setup cost dominates
  at N=2 in pure Python; cythonized integer ops are C-level so the
  setup is essentially free there)

Pxd: type ``safe_end`` as ``cython.uint`` alongside ``start``/``end``/``i``.

Author: bluetoothbot

src/bluetooth_data_tools/gap.pxd

@@ -53,6 +53,7 @@ cpdef parse_advertisement_data(object data)
     offset=cython.uint,
     start=cython.uint,
     end=cython.uint,
+    safe_end=cython.uint,
     i=cython.uint,
     tx_power_byte="unsigned char",
     uuid32_int=cython.uint,

src/bluetooth_data_tools/gap.py

@@ -252,32 +252,36 @@ def _uncached_parse_advertisement_bytes(
                 service_uuids = []
             # Parse multiple 16-bit UUIDs (each is 2 little-endian bytes).
             # Decode inline to an int and look up by int key to skip the
-            # per-iteration bytes-slice allocation.
-            for i in range(start, end, 2):
-                if i + 2 <= end:
-                    service_uuids.append(
-                        _cached_uint16_int_as_uuid(gap_data[i] | (gap_data[i + 1] << 8))
-                    )
+            # per-iteration bytes-slice allocation. The stride is a power of
+            # two so the bit-AND drops any trailing remainder for malformed
+            # input, lifting the per-iter ``i + 2 <= end`` bounds check out
+            # of the loop body.
+            safe_end = start + ((end - start) & ~1)
+            for i in range(start, safe_end, 2):
+                service_uuids.append(
+                    _cached_uint16_int_as_uuid(gap_data[i] | (gap_data[i + 1] << 8))
+                )
         elif gap_type_num in {
             TYPE_32BIT_SERVICE_UUID_COMPLETE,
             TYPE_32BIT_SERVICE_UUID_MORE_AVAILABLE,
         }:
             if service_uuids is _EMPTY_SERVICE_UUIDS:
                 service_uuids = []
             # Parse multiple 32-bit UUIDs (each is 4 little-endian bytes).
-            for i in range(start, end, 4):
-                if i + 4 <= end:
-                    # Assemble via uint local: in Cython the shift-by-24 of an
-                    # unsigned char promotes to signed int and would yield a
-                    # negative value when bit 31 is set; assigning to a
-                    # cython.uint local recovers the unsigned 32-bit value.
-                    uuid32_int = (
-                        gap_data[i]
-                        | (gap_data[i + 1] << 8)
-                        | (gap_data[i + 2] << 16)
-                        | (gap_data[i + 3] << 24)
-                    )
-                    service_uuids.append(_cached_uint32_int_as_uuid(uuid32_int))
+            # safe_end trims any malformed remainder ahead of the loop.
+            safe_end = start + ((end - start) & ~3)
+            for i in range(start, safe_end, 4):
+                # Assemble via uint local: in Cython the shift-by-24 of an
+                # unsigned char promotes to signed int and would yield a
+                # negative value when bit 31 is set; assigning to a
+                # cython.uint local recovers the unsigned 32-bit value.
+                uuid32_int = (
+                    gap_data[i]
+                    | (gap_data[i + 1] << 8)
+                    | (gap_data[i + 2] << 16)
+                    | (gap_data[i + 3] << 24)
+                )
+                service_uuids.append(_cached_uint32_int_as_uuid(uuid32_int))
         elif gap_type_num in {
             TYPE_128BIT_SERVICE_UUID_MORE_AVAILABLE,
             TYPE_128BIT_SERVICE_UUID_COMPLETE,
@@ -287,11 +291,11 @@ def _uncached_parse_advertisement_bytes(
             # Parse multiple 128-bit UUIDs (each is 16 bytes). The AD length
             # may not be a clean multiple of 16 for malformed input — skip
             # any trailing remainder rather than emitting a truncated UUID.
-            for i in range(start, end, 16):
-                if i + 16 <= end:
-                    service_uuids.append(
-                        _cached_uint128_bytes_as_uuid(gap_data[i : i + 16])
-                    )
+            safe_end = start + ((end - start) & ~15)
+            for i in range(start, safe_end, 16):
+                service_uuids.append(
+                    _cached_uint128_bytes_as_uuid(gap_data[i : i + 16])
+                )
         elif gap_type_num == TYPE_SERVICE_DATA:
             splice_pos = start + 2
             if splice_pos > end: