Implement much faster SIMD MD5 alternative

Author: maneatingape

Cargo.toml

@@ -199,7 +199,7 @@ ptr_as_ptr = "warn"
 ptr_cast_constness = "warn"
 pub_underscore_fields = "warn"
 pub_use = "warn"
-pub_with_shorthand = "warn"
+pub_with_shorthand = "allow"
 pub_without_shorthand = "warn"
 question_mark_used = "allow"
 range_minus_one = "warn"

README.md

@@ -306,7 +306,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) | 9 |
 | 3 | [Squares With Three Sides](https://adventofcode.com/2016/day/3) | [Source](src/year2016/day03.rs) | 26 |
 | 4 | [Security Through Obscurity](https://adventofcode.com/2016/day/4) | [Source](src/year2016/day04.rs) | 75 |
-| 5 | [How About a Nice Game of Chess?](https://adventofcode.com/2016/day/5) | [Source](src/year2016/day05.rs) | 212000 |
+| 5 | [How About a Nice Game of Chess?](https://adventofcode.com/2016/day/5) | [Source](src/year2016/day05.rs) | 37000 |
 | 6 | [Signals and Noise](https://adventofcode.com/2016/day/6) | [Source](src/year2016/day06.rs) | 5 |
 | 7 | [Internet Protocol Version 7](https://adventofcode.com/2016/day/7) | [Source](src/year2016/day07.rs) | 354 |
 | 8 | [Two-Factor Authentication](https://adventofcode.com/2016/day/8) | [Source](src/year2016/day08.rs) | 10 |
@@ -315,7 +315,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) | 785 |
 | 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) | 4 |
-| 14 | [One-Time Pad](https://adventofcode.com/2016/day/14) | [Source](src/year2016/day14.rs) | 434000 |
+| 14 | [One-Time Pad](https://adventofcode.com/2016/day/14) | [Source](src/year2016/day14.rs) | 79000 |
 | 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) | 14254 |
@@ -337,7 +337,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 1 | [Not Quite Lisp](https://adventofcode.com/2015/day/1) | [Source](src/year2015/day01.rs) | 2 |
 | 2 | [I Was Told There Would Be No Math](https://adventofcode.com/2015/day/2) | [Source](src/year2015/day02.rs) | 8 |
 | 3 | [Perfectly Spherical Houses in a Vacuum](https://adventofcode.com/2015/day/3) | [Source](src/year2015/day03.rs) | 100 |
-| 4 | [The Ideal Stocking Stuffer](https://adventofcode.com/2015/day/4) | [Source](src/year2015/day04.rs) | 76000 |
+| 4 | [The Ideal Stocking Stuffer](https://adventofcode.com/2015/day/4) | [Source](src/year2015/day04.rs) | 13000 |
 | 5 | [Doesn't He Have Intern-Elves For This?](https://adventofcode.com/2015/day/5) | [Source](src/year2015/day05.rs) | 39 |
 | 6 | [Probably a Fire Hazard](https://adventofcode.com/2015/day/6) | [Source](src/year2015/day06.rs) | 5780 |
 | 7 | [Some Assembly Required](https://adventofcode.com/2015/day/7) | [Source](src/year2015/day07.rs) | 27 |

src/year2015/day04.rs

@@ -47,7 +47,10 @@ pub fn parse(input: &str) -> Shared {
     // Use as many cores as possible to parallelize the remaining search.
     thread::scope(|scope| {
         for _ in 0..thread::available_parallelism().unwrap().get() {
+            #[cfg(not(feature = "simd"))]
             scope.spawn(|| worker(&shared));
+            #[cfg(feature = "simd")]
+            scope.spawn(|| simd::worker(&shared));
         }
     });
 
@@ -83,6 +86,7 @@ fn check_hash(buffer: &mut [u8], size: usize, n: u32, shared: &Shared) {
     }
 }
 
+#[cfg(not(feature = "simd"))]
 fn worker(shared: &Shared) {
     while !shared.done.load(Ordering::Relaxed) {
         let offset = shared.counter.fetch_add(1000, Ordering::Relaxed);
@@ -98,3 +102,54 @@ fn worker(shared: &Shared) {
         }
     }
 }
+
+#[cfg(feature = "simd")]
+mod simd {
+    use super::*;
+    use crate::util::md5::simd::hash;
+    use std::simd::{LaneCount, SupportedLaneCount};
+
+    #[allow(clippy::needless_range_loop)]
+    fn check_hash_simd<const N: usize>(
+        buffers: &mut [[u8; 64]],
+        size: usize,
+        start: u32,
+        offset: u32,
+        shared: &Shared,
+    ) where
+        LaneCount<N>: SupportedLaneCount,
+    {
+        // Format macro is very slow, so update digits directly
+        for i in 0..N {
+            let n = offset + i as u32;
+            buffers[i][size - 3] = b'0' + (n / 100) as u8;
+            buffers[i][size - 2] = b'0' + ((n / 10) % 10) as u8;
+            buffers[i][size - 1] = b'0' + (n % 10) as u8;
+        }
+
+        let (result, ..) = hash::<N>(buffers, size);
+
+        for i in 0..N {
+            if result[i] & 0xffffff00 == 0 {
+                shared.second.fetch_min(start + offset + i as u32, Ordering::Relaxed);
+                shared.done.store(true, Ordering::Relaxed);
+            } else if result[i] & 0xfffff000 == 0 {
+                shared.first.fetch_min(start + offset + i as u32, Ordering::Relaxed);
+            }
+        }
+    }
+
+    pub(super) fn worker(shared: &Shared) {
+        while !shared.done.load(Ordering::Relaxed) {
+            let start = shared.counter.fetch_add(1000, Ordering::Relaxed);
+            let (prefix, size) = format_string(&shared.prefix, start);
+            let mut buffers = [prefix; 32];
+
+            for offset in (0..992).step_by(32) {
+                check_hash_simd::<32>(&mut buffers, size, start, offset, shared);
+            }
+
+            check_hash_simd::<8>(&mut buffers, size, start, 992, shared);
+        }
+    }
+}

src/year2016/day05.rs

@@ -37,7 +37,10 @@ pub fn parse(input: &str) -> Vec<u32> {
     // Use as many cores as possible to parallelize the remaining search.
     thread::scope(|scope| {
         for _ in 0..thread::available_parallelism().unwrap().get() {
+            #[cfg(not(feature = "simd"))]
             scope.spawn(|| worker(&shared, &mutex));
+            #[cfg(feature = "simd")]
+            scope.spawn(|| simd::worker(&shared, &mutex));
         }
     });
 
@@ -93,6 +96,7 @@ fn check_hash(buffer: &mut [u8], size: usize, n: u32, shared: &Shared, mutex: &M
     }
 }
 
+#[cfg(not(feature = "simd"))]
 fn worker(shared: &Shared, mutex: &Mutex<Exclusive>) {
     while !shared.done.load(Ordering::Relaxed) {
         let offset = shared.counter.fetch_add(1000, Ordering::Relaxed);
@@ -108,3 +112,59 @@ fn worker(shared: &Shared, mutex: &Mutex<Exclusive>) {
         }
     }
 }
+
+#[cfg(feature = "simd")]
+mod simd {
+    use super::*;
+    use crate::util::md5::simd::hash;
+    use std::simd::{LaneCount, SupportedLaneCount};
+
+    #[allow(clippy::needless_range_loop)]
+    fn check_hash_simd<const N: usize>(
+        buffers: &mut [[u8; 64]],
+        size: usize,
+        start: u32,
+        offset: u32,
+        shared: &Shared,
+        mutex: &Mutex<Exclusive>,
+    ) where
+        LaneCount<N>: SupportedLaneCount,
+    {
+        // Format macro is very slow, so update digits directly
+        for i in 0..N {
+            let n = offset + i as u32;
+            buffers[i][size - 3] = b'0' + (n / 100) as u8;
+            buffers[i][size - 2] = b'0' + ((n / 10) % 10) as u8;
+            buffers[i][size - 1] = b'0' + (n % 10) as u8;
+        }
+
+        let (result, ..) = hash::<N>(buffers, size);
+
+        for i in 0..N {
+            if result[i] & 0xfffff000 == 0 {
+                let mut exclusive = mutex.lock().unwrap();
+
+                exclusive.found.push((start + offset + i as u32, result[i]));
+                exclusive.mask |= 1 << (result[i] >> 8);
+
+                if exclusive.mask & 0xff == 0xff {
+                    shared.done.store(true, Ordering::Relaxed);
+                }
+            }
+        }
+    }
+
+    pub(super) fn worker(shared: &Shared, mutex: &Mutex<Exclusive>) {
+        while !shared.done.load(Ordering::Relaxed) {
+            let start = shared.counter.fetch_add(1000, Ordering::Relaxed);
+            let (prefix, size) = format_string(&shared.prefix, start);
+            let mut buffers = [prefix; 32];
+
+            for offset in (0..992).step_by(32) {
+                check_hash_simd::<32>(&mut buffers, size, start, offset, shared, mutex);
+            }
+
+            check_hash_simd::<8>(&mut buffers, size, start, 992, shared, mutex);
+        }
+    }
+}