Speed up MD5 hashing by skipping gather operation where possible

maneatingape · maneatingape · commit 10e99965eca7 · 2025-10-13T22:50:17.000+01:00
diff --git a/README.md b/README.md
@@ -58,7 +58,7 @@ Improvements to solutions are always appreciated. Please see the
 ## Performance
 
 Benchmarks are measured using the built-in `cargo bench` tool run on an [Apple M2 Max][apple-link].
-All 250 solutions from 2024 to 2015 complete sequentially in **510 milliseconds**.
+All 250 solutions from 2024 to 2015 complete sequentially in **504 milliseconds**.
 Interestingly 86% of the total time is spent on just 9 solutions.
 Performance is reasonable even on older hardware, for example a 2011 MacBook Pro with an
 [Intel i7-2720QM][intel-link] processor takes 3.5 seconds to run the same 250 solutions.
@@ -67,7 +67,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 
 | Year | [2015](#2015) | [2016](#2016) | [2017](#2017) | [2018](#2018) | [2019](#2019) | [2020](#2020) | [2021](#2021) | [2022](#2022) | [2023](#2023) | [2024](#2024) |
 | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
-| Benchmark (ms) | 17 | 117 | 82 | 35 | 15 | 220 | 8 | 7 | 5 | 4 |
+| Benchmark (ms) | 17 | 111 | 82 | 35 | 15 | 220 | 8 | 7 | 5 | 4 |
 
 ## 2024
 
@@ -335,7 +335,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 2 | [Bathroom Security](https://adventofcode.com/2016/day/2) | [Source](src/year2016/day02.rs) | 29 |
 | 3 | [Squares With Three Sides](https://adventofcode.com/2016/day/3) | [Source](src/year2016/day03.rs) | 24 |
 | 4 | [Security Through Obscurity](https://adventofcode.com/2016/day/4) | [Source](src/year2016/day04.rs) | 79 |
-| 5 | [How About a Nice Game of Chess?](https://adventofcode.com/2016/day/5) | [Source](src/year2016/day05.rs) | 35000 |
+| 5 | [How About a Nice Game of Chess?](https://adventofcode.com/2016/day/5) | [Source](src/year2016/day05.rs) | 34000 |
 | 6 | [Signals and Noise](https://adventofcode.com/2016/day/6) | [Source](src/year2016/day06.rs) | 3 |
 | 7 | [Internet Protocol Version 7](https://adventofcode.com/2016/day/7) | [Source](src/year2016/day07.rs) | 364 |
 | 8 | [Two-Factor Authentication](https://adventofcode.com/2016/day/8) | [Source](src/year2016/day08.rs) | 9 |
@@ -344,7 +344,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 11 | [Radioisotope Thermoelectric Generators](https://adventofcode.com/2016/day/11) | [Source](src/year2016/day11.rs) | 719 |
 | 12 | [Leonardo's Monorail](https://adventofcode.com/2016/day/12) | [Source](src/year2016/day12.rs) | 1 |
 | 13 | [A Maze of Twisty Little Cubicles](https://adventofcode.com/2016/day/13) | [Source](src/year2016/day13.rs) | 3 |
-| 14 | [One-Time Pad](https://adventofcode.com/2016/day/14) | [Source](src/year2016/day14.rs) | 77000 |
+| 14 | [One-Time Pad](https://adventofcode.com/2016/day/14) | [Source](src/year2016/day14.rs) | 72000 |
 | 15 | [Timing is Everything](https://adventofcode.com/2016/day/15) | [Source](src/year2016/day15.rs) | 1 |
 | 16 | [Dragon Checksum](https://adventofcode.com/2016/day/16) | [Source](src/year2016/day16.rs) | 1 |
 | 17 | [Two Steps Forward](https://adventofcode.com/2016/day/17) | [Source](src/year2016/day17.rs) | 3858 |
diff --git a/src/util/md5.rs b/src/util/md5.rs
@@ -11,12 +11,12 @@
 //! [`#[inline]`](https://doc.rust-lang.org/reference/attributes/codegen.html#the-inline-attribute).
 //!
 //! An optional SIMD variant that computes multiple hashes in parallel is also implemented.
-
 pub fn buffer_size(n: usize) -> usize {
     (n + 9).next_multiple_of(64)
 }
 
-pub fn hash(mut buffer: &mut [u8], size: usize) -> (u32, u32, u32, u32) {
+#[inline]
+pub fn hash(buffer: &mut [u8], size: usize) -> [u32; 4] {
     let end = buffer.len() - 8;
     let bits = size * 8;
 
@@ -29,11 +29,8 @@ pub fn hash(mut buffer: &mut [u8], size: usize) -> (u32, u32, u32, u32) {
     let mut c0: u32 = 0x98badcfe;
     let mut d0: u32 = 0x10325476;
 
-    while !buffer.is_empty() {
-        let (prefix, suffix) = buffer.split_at_mut(64);
-        buffer = suffix;
-
-        for (i, chunk) in prefix.chunks_exact(4).enumerate() {
+    for block in buffer.chunks_exact(64) {
+        for (i, chunk) in block.chunks_exact(4).enumerate() {
             m[i] = u32::from_le_bytes(chunk.try_into().unwrap());
         }
 
@@ -116,7 +113,7 @@ pub fn hash(mut buffer: &mut [u8], size: usize) -> (u32, u32, u32, u32) {
         d0 = d0.wrapping_add(d);
     }
 
-    (a0.to_be(), b0.to_be(), c0.to_be(), d0.to_be())
+    [a0.to_be(), b0.to_be(), c0.to_be(), d0.to_be()]
 }
 
 #[inline]
@@ -150,69 +147,62 @@ fn common(f: u32, a: u32, b: u32, m: u32, s: u32, k: u32) -> u32 {
 
 #[cfg(feature = "simd")]
 pub mod simd {
-    use std::array;
+    use std::array::from_fn;
     use std::simd::num::SimdUint as _;
     use std::simd::{LaneCount, Simd, SupportedLaneCount};
 
     #[inline]
     #[expect(clippy::too_many_lines)]
-    pub fn hash<const N: usize>(
-        buffers: &mut [[u8; 64]],
-        size: usize,
-    ) -> ([u32; N], [u32; N], [u32; N], [u32; N])
+    pub fn hash_fixed<const N: usize>(buffers: &mut [[u8; 64]; N], size: usize) -> [[u32; N]; 4]
     where
         LaneCount<N>: SupportedLaneCount,
     {
         // Assume all buffers are the same size.
-        let end = 64 - 8;
-        let bits = size * 8;
-
         for buffer in buffers.iter_mut() {
             buffer[size] = 0x80;
-            buffer[end..].copy_from_slice(&bits.to_le_bytes());
         }
 
-        let mut a0: Simd<u32, N> = Simd::splat(0x67452301);
-        let mut b0: Simd<u32, N> = Simd::splat(0xefcdab89);
-        let mut c0: Simd<u32, N> = Simd::splat(0x98badcfe);
-        let mut d0: Simd<u32, N> = Simd::splat(0x10325476);
+        let mut a0 = Simd::splat(0x67452301);
+        let mut b0 = Simd::splat(0xefcdab89);
+        let mut c0 = Simd::splat(0x98badcfe);
+        let mut d0 = Simd::splat(0x10325476);
 
         let mut a = a0;
         let mut b = b0;
         let mut c = c0;
         let mut d = d0;
 
-        let m0 = message(buffers, 0);
+        let m0 = message(buffers, 0, size);
         a = round1(a, b, c, d, m0, 7, 0xd76aa478);
-        let m1 = message(buffers, 1);
+        let m1 = message(buffers, 4, size);
         d = round1(d, a, b, c, m1, 12, 0xe8c7b756);
-        let m2 = message(buffers, 2);
+        let m2 = message(buffers, 8, size);
         c = round1(c, d, a, b, m2, 17, 0x242070db);
-        let m3 = message(buffers, 3);
+        let m3 = message(buffers, 12, size);
         b = round1(b, c, d, a, m3, 22, 0xc1bdceee);
-        let m4 = message(buffers, 4);
+        let m4 = message(buffers, 16, size);
         a = round1(a, b, c, d, m4, 7, 0xf57c0faf);
-        let m5 = message(buffers, 5);
+        let m5 = message(buffers, 20, size);
         d = round1(d, a, b, c, m5, 12, 0x4787c62a);
-        let m6 = message(buffers, 6);
+        let m6 = message(buffers, 24, size);
         c = round1(c, d, a, b, m6, 17, 0xa8304613);
-        let m7 = message(buffers, 7);
+        let m7 = message(buffers, 28, size);
         b = round1(b, c, d, a, m7, 22, 0xfd469501);
-        let m8 = message(buffers, 8);
+        let m8 = message(buffers, 32, size);
         a = round1(a, b, c, d, m8, 7, 0x698098d8);
-        let m9 = message(buffers, 9);
+        let m9 = message(buffers, 36, size);
         d = round1(d, a, b, c, m9, 12, 0x8b44f7af);
-        let m10 = message(buffers, 10);
+        let m10 = message(buffers, 40, size);
         c = round1(c, d, a, b, m10, 17, 0xffff5bb1);
-        let m11 = message(buffers, 11);
+        let m11 = message(buffers, 44, size);
         b = round1(b, c, d, a, m11, 22, 0x895cd7be);
-        let m12 = message(buffers, 12);
+        let m12 = message(buffers, 48, size);
         a = round1(a, b, c, d, m12, 7, 0x6b901122);
-        let m13 = message(buffers, 13);
+        let m13 = message(buffers, 52, size);
         d = round1(d, a, b, c, m13, 12, 0xfd987193);
-        let m14 = message(buffers, 14);
+        let m14 = Simd::splat(size as u32 * 8);
         c = round1(c, d, a, b, m14, 17, 0xa679438e);
-        let m15 = message(buffers, 15);
+        let m15 = Simd::splat(0);
         b = round1(b, c, d, a, m15, 22, 0x49b40821);
 
         a = round2(a, b, c, d, m1, 5, 0xf61e2562);
@@ -271,25 +261,27 @@ pub mod simd {
         c0 += c;
         d0 += d;
 
-        (
+        [
             a0.swap_bytes().to_array(),
             b0.swap_bytes().to_array(),
             c0.swap_bytes().to_array(),
             d0.swap_bytes().to_array(),
-        )
+        ]
     }
 
     #[inline]
-    fn message<const N: usize>(buffers: &mut [[u8; 64]], i: usize) -> Simd<u32, N>
+    fn message<const N: usize>(buffers: &[[u8; 64]; N], i: usize, size: usize) -> Simd<u32, N>
     where
         LaneCount<N>: SupportedLaneCount,
     {
-        let start = 4 * i;
-        let end = start + 4;
-        Simd::from_array(array::from_fn(|lane| {
-            let slice = &buffers[lane][start..end];
-            u32::from_le_bytes(slice.try_into().unwrap())
-        }))
+        if i > size {
+            Simd::splat(0)
+        } else {
+            Simd::from_array(from_fn(|lane| {
+                let slice = &buffers[lane][i..i + 4];
+                u32::from_le_bytes(slice.try_into().unwrap())
+            }))
+        }
     }
 
     #[inline]
diff --git a/src/year2015/day04.rs b/src/year2015/day04.rs
@@ -72,7 +72,7 @@ fn format_string(prefix: &str, n: u32) -> ([u8; 64], usize) {
 }
 
 fn check_hash(buffer: &mut [u8], size: usize, n: u32, shared: &Shared) {
-    let (result, ..) = hash(buffer, size);
+    let [result, ..] = hash(buffer, size);
 
     if result & 0xffffff00 == 0 {
         shared.second.fetch_min(n, Ordering::Relaxed);
@@ -101,12 +101,12 @@ fn worker(shared: &Shared) {
 #[cfg(feature = "simd")]
 mod simd {
     use super::*;
-    use crate::util::md5::simd::hash;
+    use crate::util::md5::simd::hash_fixed;
     use std::simd::{LaneCount, SupportedLaneCount};
 
     #[expect(clippy::needless_range_loop)]
     fn check_hash_simd<const N: usize>(
-        buffers: &mut [[u8; 64]],
+        buffers: &mut [[u8; 64]; N],
         size: usize,
         start: u32,
         offset: u32,
@@ -122,7 +122,7 @@ mod simd {
             buffers[i][size - 1] = b'0' + (n % 10) as u8;
         }
 
-        let (result, ..) = hash::<N>(buffers, size);
+        let [result, ..] = hash_fixed(buffers, size);
 
         for i in 0..N {
             if result[i] & 0xffffff00 == 0 {
@@ -137,13 +137,14 @@ mod simd {
     pub(super) fn worker(shared: &Shared) {
         while let Some(start) = shared.iter.next() {
             let (prefix, size) = format_string(&shared.prefix, start);
-            let mut buffers = [prefix; 32];
+            let buffers = &mut [prefix; 32];
 
             for offset in (0..992).step_by(32) {
-                check_hash_simd::<32>(&mut buffers, size, start, offset, shared);
+                check_hash_simd(buffers, size, start, offset, shared);
             }
 
-            check_hash_simd::<8>(&mut buffers, size, start, 992, shared);
+            let buffers = &mut [prefix; 8];
+            check_hash_simd(buffers, size, start, 992, shared);
         }
     }
 }
diff --git a/src/year2016/day05.rs b/src/year2016/day05.rs
@@ -78,7 +78,7 @@ fn format_string(prefix: &str, n: u32) -> ([u8; 64], usize) {
 }
 
 fn check_hash(buffer: &mut [u8], size: usize, n: u32, shared: &Shared) {
-    let (result, ..) = hash(buffer, size);
+    let [result, ..] = hash(buffer, size);
 
     if result & 0xfffff000 == 0 {
         let mut exclusive = shared.mutex.lock().unwrap();
@@ -111,12 +111,12 @@ fn worker(shared: &Shared) {
 #[cfg(feature = "simd")]
 mod simd {
     use super::*;
-    use crate::util::md5::simd::hash;
+    use crate::util::md5::simd::hash_fixed;
     use std::simd::{LaneCount, SupportedLaneCount};
 
     #[expect(clippy::needless_range_loop)]
     fn check_hash_simd<const N: usize>(
-        buffers: &mut [[u8; 64]],
+        buffers: &mut [[u8; 64]; N],
         size: usize,
         start: u32,
         offset: u32,
@@ -132,7 +132,7 @@ mod simd {
             buffers[i][size - 1] = b'0' + (n % 10) as u8;
         }
 
-        let (result, ..) = hash::<N>(buffers, size);
+        let [result, ..] = hash_fixed(buffers, size);
 
         for i in 0..N {
             if result[i] & 0xfffff000 == 0 {
@@ -151,13 +151,14 @@ mod simd {
     pub(super) fn worker(shared: &Shared) {
         while let Some(start) = shared.iter.next() {
             let (prefix, size) = format_string(&shared.prefix, start);
-            let mut buffers = [prefix; 32];
+            let buffers = &mut [prefix; 32];
 
             for offset in (0..992).step_by(32) {
-                check_hash_simd::<32>(&mut buffers, size, start, offset, shared);
+                check_hash_simd(buffers, size, start, offset, shared);
             }
 
-            check_hash_simd::<8>(&mut buffers, size, start, 992, shared);
+            let buffers = &mut [prefix; 8];
+            check_hash_simd(buffers, size, start, 992, shared);
         }
     }
 }
diff --git a/src/year2016/day14.rs b/src/year2016/day14.rs
@@ -64,10 +64,10 @@ fn worker(shared: &Shared<'_>) {
 
         if shared.part_two {
             for _ in 0..2016 {
-                buffer[0..8].copy_from_slice(&to_ascii(result.0));
-                buffer[8..16].copy_from_slice(&to_ascii(result.1));
-                buffer[16..24].copy_from_slice(&to_ascii(result.2));
-                buffer[24..32].copy_from_slice(&to_ascii(result.3));
+                buffer[0..8].copy_from_slice(&to_ascii(result[0]));
+                buffer[8..16].copy_from_slice(&to_ascii(result[1]));
+                buffer[16..24].copy_from_slice(&to_ascii(result[2]));
+                buffer[24..32].copy_from_slice(&to_ascii(result[3]));
                 result = hash(&mut buffer, 32);
             }
         }
@@ -80,7 +80,7 @@ fn worker(shared: &Shared<'_>) {
 #[cfg(feature = "simd")]
 #[expect(clippy::needless_range_loop)]
 fn worker(shared: &Shared<'_>) {
-    let mut result = ([0; 32], [0; 32], [0; 32], [0; 32]);
+    let mut result = [[0; 32]; 4];
     let mut buffers = [[0; 64]; 32];
 
     while let Some(start) = shared.iter.next() {
@@ -90,36 +90,36 @@ fn worker(shared: &Shared<'_>) {
         // Calculate the hash.
         for i in 0..32 {
             let (mut buffer, size) = format_string(shared.input, start + i as i32);
-            let (a, b, c, d) = hash(&mut buffer, size);
+            let [a, b, c, d] = hash(&mut buffer, size);
 
-            result.0[i] = a;
-            result.1[i] = b;
-            result.2[i] = c;
-            result.3[i] = d;
+            result[0][i] = a;
+            result[1][i] = b;
+            result[2][i] = c;
+            result[3][i] = d;
         }
 
         if shared.part_two {
             for _ in 0..2016 {
                 for i in 0..32 {
-                    buffers[i][0..8].copy_from_slice(&to_ascii(result.0[i]));
-                    buffers[i][8..16].copy_from_slice(&to_ascii(result.1[i]));
-                    buffers[i][16..24].copy_from_slice(&to_ascii(result.2[i]));
-                    buffers[i][24..32].copy_from_slice(&to_ascii(result.3[i]));
+                    buffers[i][0..8].copy_from_slice(&to_ascii(result[0][i]));
+                    buffers[i][8..16].copy_from_slice(&to_ascii(result[1][i]));
+                    buffers[i][16..24].copy_from_slice(&to_ascii(result[2][i]));
+                    buffers[i][24..32].copy_from_slice(&to_ascii(result[3][i]));
                 }
-                result = simd::hash::<32>(&mut buffers, 32);
+                result = simd::hash_fixed(&mut buffers, 32);
             }
         }
 
         for i in 0..32 {
-            let hash = (result.0[i], result.1[i], result.2[i], result.3[i]);
+            let hash = [result[0][i], result[1][i], result[2][i], result[3][i]];
             check(shared, start + i as i32, hash);
         }
     }
 }
 
 /// Check for sequences of 3 or 5 consecutive matching digits.
-fn check(shared: &Shared<'_>, n: i32, hash: (u32, u32, u32, u32)) {
-    let (a, b, c, d) = hash;
+fn check(shared: &Shared<'_>, n: i32, hash: [u32; 4]) {
+    let [a, b, c, d] = hash;
 
     let mut prev = u32::MAX;
     let mut same = 1;
diff --git a/src/year2016/day17.rs b/src/year2016/day17.rs
@@ -127,7 +127,7 @@ fn explore(shared: &Shared, local: &mut State) {
             local.max = local.max.max(adjusted);
         } else {
             // Explore other paths.
-            let (result, ..) = hash(&mut path, size);
+            let [result, ..] = hash(&mut path, size);
 
             if y > 0 && ((result >> 28) & 0xf) > 0xa {
                 local.todo.push((x, y - 1, size + 1, extend(&path, size, b'U')));
