perf: skip PADDING 16 bytes at a time in Decoder::skip_while (#4085)

* perf: scan padding in 16-byte chunks

* bench: decode PADDING at every 16-byte alignment

* codec: clarify skip_while chunk comment

* perf: align skip_while chunk loads to 16 bytes

* codec: name the skip_while chunk width

* Shorten skip_while and padding bench comments

---------

Co-authored-by: CodSpeed Bot <no-reply@codspeed.io>

Author: codspeed[bot]

neqo-common/src/codec.rs

@@ -74,11 +74,27 @@ impl<'a> Decoder<'a> {
     /// Skip while the current byte is `predicate`. Returns the number of bytes
     /// skipped.
     pub fn skip_while(&mut self, predicate: u8) -> usize {
-        let until = self
-            .as_ref() // remaining bytes
+        /// One SIMD register (SSE2/NEON), so each chunk is a single wide load and compare.
+        const CHUNK: usize = 16;
+
+        let buf = self.as_ref(); // remaining bytes
+        // Go bytewise until `CHUNK`-aligned, so chunk loads never straddle cache lines.
+        let head = buf.as_ptr().align_offset(CHUNK).min(buf.len());
+        if let Some(i) = buf[..head].iter().position(|v| *v != predicate) {
+            self.skip(i);
+            return i;
+        }
+        let (chunks, _) = buf[head..].as_chunks::<CHUNK>();
+        let start = head
+            + chunks
+                .iter()
+                .position(|c| *c != [predicate; CHUNK])
+                .unwrap_or(chunks.len())
+                * CHUNK;
+        let until = buf[start..]
             .iter()
             .position(|v| *v != predicate)
-            .unwrap_or_else(|| self.remaining());
+            .map_or(buf.len(), |i| start + i);
         self.skip(until);
         until
     }

neqo-transport/benches/frame_decode.rs

@@ -45,10 +45,28 @@ fn frame_decode(c: &mut Criterion, n: usize) {
     });
 }
 
+/// Number of distinct start offsets for a PADDING frame within a 16-byte chunk.
+const PADDING_ALIGNMENTS: usize = 16;
+
+/// Decode an `n`-byte PADDING frame at every alignment, as real PADDING can start anywhere.
+fn padding_decode(c: &mut Criterion, n: usize) {
+    let buf = vec![0; n + PADDING_ALIGNMENTS - 1];
+    c.bench_function(&format!("Frame::decode PADDING {n} bytes"), |b| {
+        b.iter(|| {
+            for offset in 0..PADDING_ALIGNMENTS {
+                let mut dec = Decoder::new(&buf[offset..offset + n]);
+                black_box(Frame::decode(&mut dec).expect("decode frame"));
+            }
+        });
+    });
+}
+
 fn benchmark(c: &mut Criterion) {
     frame_decode(c, 10);
     frame_decode(c, 100);
     frame_decode(c, 1_000);
+    padding_decode(c, 1_500);
+    padding_decode(c, 16_383);
 }
 
 criterion_group! {