Faster SIMD approach

maneatingape · maneatingape · commit 7949c60d1b1c · 2025-10-25T17:44:36.000+01:00
diff --git a/README.md b/README.md
@@ -1,7 +1,7 @@
 # Advent of Code [![checks-badge]][checks-link] [![docs-badge]][docs-link]
 
 Blazing fast Rust solutions for every [Advent of Code] puzzle from 2015 to 2024, taking
-**498 milliseconds** to solve all 500 stars. Each solution is carefully optimized for performance
+**497 milliseconds** to solve all 500 stars. Each solution is carefully optimized for performance
 while ensuring the code remains concise, readable, and idiomatic.
 
 ## Features
@@ -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) | 15 | 109 | 82 | 35 | 14 | 220 | 8 | 6 | 5 | 4 |
+| Benchmark (ms) | 15 | 109 | 82 | 35 | 14 | 220 | 8 | 5 | 5 | 4 |
 
 ## 2024
 
@@ -161,7 +161,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 20 | [Grove Positioning System](https://adventofcode.com/2022/day/20) | [Source](src/year2022/day20.rs) | 2685 |
 | 21 | [Monkey Math](https://adventofcode.com/2022/day/21) | [Source](src/year2022/day21.rs) | 64 |
 | 22 | [Monkey Map](https://adventofcode.com/2022/day/22) | [Source](src/year2022/day22.rs) | 61 |
-| 23 | [Unstable Diffusion](https://adventofcode.com/2022/day/23) | [Source](src/year2022/day23.rs) | 1521 |
+| 23 | [Unstable Diffusion](https://adventofcode.com/2022/day/23) | [Source](src/year2022/day23.rs) | 1061 |
 | 24 | [Blizzard Basin](https://adventofcode.com/2022/day/24) | [Source](src/year2022/day24.rs) | 62 |
 | 25 | [Full of Hot Air](https://adventofcode.com/2022/day/25) | [Source](src/year2022/day25.rs) | 3 |
 
diff --git a/src/year2022/day23.rs b/src/year2022/day23.rs
@@ -2,100 +2,17 @@
 //!
 //! We represent elves as bits in a integer then use bitwise operations to efficiently figure
 //! out the movement for multiple elves at once.
-use self::Direction::*;
-use std::ops::{BitAnd, BitAndAssign, BitOr, Not};
+use Direction::*;
+
+#[cfg(not(feature = "simd"))]
+use scalar::U256;
+#[cfg(feature = "simd")]
+use simd::U256;
 
 /// The initial grid is 70 x 70. Elves stop moving when no other elf is adjacent so the grid
 /// will expand at most 70 in any direction, giving 70 + 70 + 70 = 210 total.
 const HEIGHT: usize = 210;
 
-/// Duct tape two `u128`s together.
-#[derive(Clone, Copy, Default)]
-pub struct U256 {
-    left: u128,
-    right: u128,
-}
-
-impl U256 {
-    fn bit_set(&mut self, offset: usize) {
-        if offset < 128 {
-            self.left |= 1 << (127 - offset);
-        } else {
-            self.right |= 1 << (255 - offset);
-        }
-    }
-
-    fn count_ones(&self) -> u32 {
-        self.left.count_ones() + self.right.count_ones()
-    }
-
-    fn non_zero(&self) -> bool {
-        self.left != 0 || self.right != 0
-    }
-
-    /// Used to find the bounding rectangle for part one.
-    fn min_set(&self) -> Option<u32> {
-        if self.left != 0 {
-            Some(self.left.leading_zeros())
-        } else if self.right != 0 {
-            Some(128 + self.right.leading_zeros())
-        } else {
-            None
-        }
-    }
-
-    /// Used to find the bounding rectangle for part one.
-    fn max_set(&self) -> Option<u32> {
-        if self.right != 0 {
-            Some(255 - self.right.trailing_zeros())
-        } else if self.left != 0 {
-            Some(127 - self.left.trailing_zeros())
-        } else {
-            None
-        }
-    }
-
-    fn left_shift(&self) -> U256 {
-        U256 { left: (self.left << 1) | (self.right >> 127), right: (self.right << 1) }
-    }
-
-    fn right_shift(&self) -> U256 {
-        U256 { left: (self.left >> 1), right: (self.left << 127) | (self.right >> 1) }
-    }
-}
-
-/// Syntactic sugar to provide the regular `&`, `|` and `!` bitwise operator notation.
-impl BitAnd for U256 {
-    type Output = U256;
-
-    fn bitand(self, rhs: U256) -> U256 {
-        U256 { left: self.left & rhs.left, right: self.right & rhs.right }
-    }
-}
-
-impl BitOr for U256 {
-    type Output = U256;
-
-    fn bitor(self, rhs: U256) -> U256 {
-        U256 { left: self.left | rhs.left, right: self.right | rhs.right }
-    }
-}
-
-impl Not for U256 {
-    type Output = U256;
-
-    fn not(self) -> U256 {
-        U256 { left: !self.left, right: !self.right }
-    }
-}
-
-impl BitAndAssign for U256 {
-    fn bitand_assign(&mut self, rhs: U256) {
-        self.left &= rhs.left;
-        self.right &= rhs.right;
-    }
-}
-
 enum Direction {
     North,
     South,
@@ -123,30 +40,39 @@ pub fn parse(input: &str) -> Input {
     for (y, row) in raw.iter().enumerate() {
         for (x, col) in row.iter().enumerate() {
             if *col == b'#' {
-                grid[offset + y].bit_set(offset + x);
+                grid[offset + y].set_bit(offset + x);
             }
         }
     }
 
     Input { grid, north: default, south: default, west: default, east: default }
 }
 
-pub fn part1(input: &Input) -> u32 {
+pub fn part1(input: &Input) -> usize {
     let mut input = *input;
     let mut order = [North, South, West, East];
 
     for _ in 0..10 {
         step(&mut input, &mut order);
     }
 
-    // Find the bounding rectangle.
+    // Find the total number of elves and the bounding rectangle.
     let grid = input.grid;
-    let elves: u32 = grid.iter().map(U256::count_ones).sum();
-    let min_x = grid.iter().filter_map(U256::min_set).min().unwrap();
-    let max_x = grid.iter().filter_map(U256::max_set).max().unwrap();
-    let min_y = grid.iter().position(U256::non_zero).unwrap() as u32;
-    let max_y = grid.iter().rposition(U256::non_zero).unwrap() as u32;
+    let elves = grid.iter().flat_map(U256::as_array).map(u8::count_ones).sum::<u32>() as usize;
 
+    // Vertical bounds.
+    let min_y = grid.iter().position(U256::non_zero).unwrap();
+    let max_y = grid.iter().rposition(U256::non_zero).unwrap();
+
+    // Horizontal bounds.
+    let array = grid.iter().fold(U256::default(), |acc, &n| acc.or(n)).as_array();
+    let left = array.iter().position(|&e| e != 0).unwrap();
+    let right = array.iter().rposition(|&e| e != 0).unwrap();
+
+    let min_x = 8 * left + array[left].leading_zeros() as usize;
+    let max_x = 8 * right + (7 - array[right].trailing_zeros()) as usize;
+
+    // Empty ground tiles.
     (max_x - min_x + 1) * (max_y - min_y + 1) - elves
 }
 
@@ -175,51 +101,51 @@ fn step(input: &mut Input, order: &mut [Direction]) -> bool {
     let mut prev;
     // Find horizontal neighbors in each row. To make movement calculations easier
     // we invert so that a bit is 1 is movement is *possible*.
-    let mut cur = !(grid[0].right_shift() | grid[0] | grid[0].left_shift());
-    let mut next = !(grid[1].right_shift() | grid[1] | grid[1].left_shift());
+    let mut cur = grid[0].shr().or(grid[0]).or(grid[0].shl()).not();
+    let mut next = grid[1].shr().or(grid[1]).or(grid[1].shl()).not();
 
     for i in start..end {
         // Calculating neighbors is relatively expensive so re-use results between rows.
         prev = cur;
         cur = next;
-        next = !(grid[i + 1].right_shift() | grid[i + 1] | grid[i + 1].left_shift());
+        next = grid[i + 1].shr().or(grid[i + 1]).or(grid[i + 1].shl()).not();
 
         let mut up = prev;
         let mut down = next;
         // Find neighours in vertical columns.
-        let vertical = !(grid[i - 1] | grid[i] | grid[i + 1]);
-        let mut left = vertical.right_shift();
-        let mut right = vertical.left_shift();
+        let vertical = grid[i - 1].or(grid[i]).or(grid[i + 1]).not();
+        let mut left = vertical.shr();
+        let mut right = vertical.shl();
         // Elves need at least 1 neighbor to propose moving.
-        let mut remaining = grid[i] & !(up & down & left & right);
+        let mut remaining = grid[i].and(up.and(down).and(left).and(right).not());
 
         // Consider each direction one at a time, removing any elves who propose it.
         for direction in &*order {
             match direction {
                 North => {
-                    up &= remaining;
-                    remaining &= !up;
+                    up = up.and(remaining);
+                    remaining = remaining.and(up.not());
                 }
                 South => {
-                    down &= remaining;
-                    remaining &= !down;
+                    down = down.and(remaining);
+                    remaining = remaining.and(down.not());
                 }
                 West => {
-                    left &= remaining;
-                    remaining &= !left;
+                    left = left.and(remaining);
+                    remaining = remaining.and(left.not());
                 }
                 East => {
-                    right &= remaining;
-                    remaining &= !right;
+                    right = right.and(remaining);
+                    remaining = remaining.and(right.not());
                 }
             }
         }
 
         // Copy final proposals to an array for each direction.
         north[i - 1] = up;
         south[i + 1] = down;
-        west[i] = left.left_shift();
-        east[i] = right.right_shift();
+        west[i] = left.shl();
+        east[i] = right.shr();
     }
 
     // Elves that propose moving to the same spot cancel each other out and no-one moves.
@@ -230,23 +156,115 @@ fn step(input: &mut Input, order: &mut [Direction]) -> bool {
         let down = south[i];
         let left = west[i];
         let right = east[i];
-        north[i] &= !down;
-        south[i] &= !up;
-        west[i] &= !right;
-        east[i] &= !left;
+        north[i] = north[i].and(down.not());
+        south[i] = south[i].and(up.not());
+        west[i] = west[i].and(right.not());
+        east[i] = east[i].and(left.not());
     }
 
     for i in start..end {
         // Stationary elves.
         let same =
-            grid[i] & !(north[i - 1] | south[i + 1] | west[i].right_shift() | east[i].left_shift());
+            grid[i].and(north[i - 1].or(south[i + 1]).or(west[i].shr()).or(east[i].shl()).not());
         // Moving elves.
-        let change = north[i] | south[i] | west[i] | east[i];
-        grid[i] = same | change;
+        let change = north[i].or(south[i]).or(west[i]).or(east[i]);
+        grid[i] = same.or(change);
         moved |= change.non_zero();
     }
 
     // Rotate the order of movement proposals for the next turn.
     order.rotate_left(1);
     moved
 }
+
+#[cfg(not(feature = "simd"))]
+mod scalar {
+    /// Duct tape two `u128`s together.
+    #[derive(Clone, Copy, Default)]
+    pub(super) struct U256 {
+        left: u128,
+        right: u128,
+    }
+
+    impl U256 {
+        pub(super) fn set_bit(&mut self, offset: usize) {
+            if offset < 128 {
+                self.left |= 1 << (127 - offset);
+            } else {
+                self.right |= 1 << (255 - offset);
+            }
+        }
+
+        pub(super) fn as_array(&self) -> [u8; 32] {
+            [self.left.to_be_bytes(), self.right.to_be_bytes()].concat().try_into().unwrap()
+        }
+
+        pub(super) fn non_zero(&self) -> bool {
+            self.left != 0 || self.right != 0
+        }
+
+        pub(super) fn shl(self) -> U256 {
+            U256 { left: (self.left << 1) | (self.right >> 127), right: (self.right << 1) }
+        }
+
+        pub(super) fn shr(self) -> U256 {
+            U256 { left: (self.left >> 1), right: (self.left << 127) | (self.right >> 1) }
+        }
+
+        pub(super) fn and(self, rhs: U256) -> U256 {
+            U256 { left: self.left & rhs.left, right: self.right & rhs.right }
+        }
+
+        pub(super) fn or(self, rhs: U256) -> U256 {
+            U256 { left: self.left | rhs.left, right: self.right | rhs.right }
+        }
+
+        pub(super) fn not(self) -> U256 {
+            U256 { left: !self.left, right: !self.right }
+        }
+    }
+}
+
+#[cfg(feature = "simd")]
+mod simd {
+    use std::simd::*;
+
+    #[derive(Clone, Copy, Default)]
+    pub(super) struct U256 {
+        v: Simd<u8, 32>,
+    }
+
+    impl U256 {
+        pub(super) fn set_bit(&mut self, offset: usize) {
+            self.v[offset / 8] |= 1 << (7 - offset % 8);
+        }
+
+        pub(super) fn as_array(&self) -> [u8; 32] {
+            self.v.to_array()
+        }
+
+        pub(super) fn non_zero(&self) -> bool {
+            self.v != Simd::splat(0)
+        }
+
+        pub(super) fn shl(self) -> U256 {
+            U256 { v: (self.v << 1) | (self.v.shift_elements_left::<1>(0) >> 7) }
+        }
+
+        pub(super) fn shr(self) -> U256 {
+            U256 { v: (self.v >> 1) | (self.v.shift_elements_right::<1>(0) << 7) }
+        }
+
+        pub(super) fn and(self, rhs: U256) -> U256 {
+            U256 { v: self.v & rhs.v }
+        }
+
+        pub(super) fn or(self, rhs: U256) -> U256 {
+            U256 { v: self.v | rhs.v }
+        }
+
+        pub(super) fn not(self) -> U256 {
+            U256 { v: !self.v }
+        }
+    }
+}
