Atomic iterator to share monotonically increasing value between multiple threads

Author: maneatingape

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 **518 milliseconds**.
+All 250 solutions from 2024 to 2015 complete sequentially in **517 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 | 118 | 82 | 35 | 15 | 225 | 9 | 8 | 5 | 4 |
+| Benchmark (ms) | 17 | 117 | 82 | 35 | 15 | 225 | 9 | 8 | 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) | 37000 |
+| 5 | [How About a Nice Game of Chess?](https://adventofcode.com/2016/day/5) | [Source](src/year2016/day05.rs) | 35000 |
 | 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 |
@@ -366,7 +366,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) | 95 |
-| 4 | [The Ideal Stocking Stuffer](https://adventofcode.com/2015/day/4) | [Source](src/year2015/day04.rs) | 14000 |
+| 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) | 38 |
 | 6 | [Probably a Fire Hazard](https://adventofcode.com/2015/day/6) | [Source](src/year2015/day06.rs) | 454 |
 | 7 | [Some Assembly Required](https://adventofcode.com/2015/day/7) | [Source](src/year2015/day07.rs) | 27 |

src/util/thread.rs

@@ -2,7 +2,7 @@
 //! [scoped](https://doc.rust-lang.org/stable/std/thread/fn.scope.html)
 //! threads equals to the number of cores on the machine. Unlike normal threads, scoped threads
 //! can borrow data from their environment.
-use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
+use std::sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering::Relaxed};
 use std::thread::*;
 
 /// Usually the number of physical cores.
@@ -170,3 +170,24 @@ fn pack(start: usize, end: usize) -> usize {
 fn unpack(both: usize) -> (usize, usize) {
     (both & 0xffffffff, both >> 32)
 }
+
+/// Shares monotonically increasing value between multiple threads.
+pub struct AtomicIter {
+    running: AtomicBool,
+    index: AtomicU32,
+    step: u32,
+}
+
+impl AtomicIter {
+    pub fn new(start: u32, step: u32) -> Self {
+        AtomicIter { running: AtomicBool::new(true), index: AtomicU32::from(start), step }
+    }
+
+    pub fn next(&self) -> Option<u32> {
+        self.running.load(Relaxed).then(|| self.index.fetch_add(self.step, Relaxed))
+    }
+
+    pub fn stop(&self) {
+        self.running.store(false, Relaxed);
+    }
+}

src/year2015/day04.rs

@@ -19,21 +19,19 @@
 //! [`format!`]: std::format
 use crate::util::md5::*;
 use crate::util::thread::*;
-use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
+use std::sync::atomic::{AtomicU32, Ordering};
 
 pub struct Shared {
     prefix: String,
-    done: AtomicBool,
-    counter: AtomicU32,
+    iter: AtomicIter,
     first: AtomicU32,
     second: AtomicU32,
 }
 
 pub fn parse(input: &str) -> Shared {
     let shared = Shared {
         prefix: input.trim().to_owned(),
-        done: AtomicBool::new(false),
-        counter: AtomicU32::new(1000),
+        iter: AtomicIter::new(1000, 1000),
         first: AtomicU32::new(u32::MAX),
         second: AtomicU32::new(u32::MAX),
     };
@@ -78,16 +76,15 @@ fn check_hash(buffer: &mut [u8], size: usize, n: u32, shared: &Shared) {
 
     if result & 0xffffff00 == 0 {
         shared.second.fetch_min(n, Ordering::Relaxed);
-        shared.done.store(true, Ordering::Relaxed);
+        shared.iter.stop();
     } else if result & 0xfffff000 == 0 {
         shared.first.fetch_min(n, Ordering::Relaxed);
     }
 }
 
 #[cfg(not(feature = "simd"))]
 fn worker(shared: &Shared) {
-    while !shared.done.load(Ordering::Relaxed) {
-        let offset = shared.counter.fetch_add(1000, Ordering::Relaxed);
+    while let Some(offset) = shared.iter.next() {
         let (mut buffer, size) = format_string(&shared.prefix, offset);
 
         for n in 0..1000 {
@@ -130,16 +127,15 @@ mod simd {
         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);
+                shared.iter.stop();
             } 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);
+        while let Some(start) = shared.iter.next() {
             let (prefix, size) = format_string(&shared.prefix, start);
             let mut buffers = [prefix; 32];
 

src/year2016/day05.rs

@@ -7,12 +7,10 @@
 use crate::util::md5::*;
 use crate::util::thread::*;
 use std::sync::Mutex;
-use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
 
 struct Shared {
     prefix: String,
-    done: AtomicBool,
-    counter: AtomicU32,
+    iter: AtomicIter,
     mutex: Mutex<Exclusive>,
 }
 
@@ -24,8 +22,7 @@ struct Exclusive {
 pub fn parse(input: &str) -> Vec<u32> {
     let shared = Shared {
         prefix: input.trim().to_owned(),
-        done: AtomicBool::new(false),
-        counter: AtomicU32::new(1000),
+        iter: AtomicIter::new(1000, 1000),
         mutex: Mutex::new(Exclusive { found: vec![], mask: 0 }),
     };
 
@@ -90,15 +87,14 @@ fn check_hash(buffer: &mut [u8], size: usize, n: u32, shared: &Shared) {
         exclusive.mask |= 1 << (result >> 8);
 
         if exclusive.mask & 0xff == 0xff {
-            shared.done.store(true, Ordering::Relaxed);
+            shared.iter.stop();
         }
     }
 }
 
 #[cfg(not(feature = "simd"))]
 fn worker(shared: &Shared) {
-    while !shared.done.load(Ordering::Relaxed) {
-        let offset = shared.counter.fetch_add(1000, Ordering::Relaxed);
+    while let Some(offset) = shared.iter.next() {
         let (mut buffer, size) = format_string(&shared.prefix, offset);
 
         for n in 0..1000 {
@@ -146,15 +142,14 @@ mod simd {
                 exclusive.mask |= 1 << (result[i] >> 8);
 
                 if exclusive.mask & 0xff == 0xff {
-                    shared.done.store(true, Ordering::Relaxed);
+                    shared.iter.stop();
                 }
             }
         }
     }
 
     pub(super) fn worker(shared: &Shared) {
-        while !shared.done.load(Ordering::Relaxed) {
-            let start = shared.counter.fetch_add(1000, Ordering::Relaxed);
+        while let Some(start) = shared.iter.next() {
             let (prefix, size) = format_string(&shared.prefix, start);
             let mut buffers = [prefix; 32];
 

src/year2016/day14.rs

@@ -6,14 +6,12 @@ use crate::util::md5::*;
 use crate::util::thread::*;
 use std::collections::{BTreeMap, BTreeSet};
 use std::sync::Mutex;
-use std::sync::atomic::{AtomicBool, AtomicI32, Ordering};
 
 /// Atomics can be safely shared between threads.
 struct Shared<'a> {
     input: &'a str,
     part_two: bool,
-    done: AtomicBool,
-    counter: AtomicI32,
+    iter: AtomicIter,
     mutex: Mutex<Exclusive>,
 }
 
@@ -40,15 +38,12 @@ pub fn part2(input: &str) -> i32 {
 
 /// Find the first 64 keys that satisfy the rules.
 fn generate_pad(input: &str, part_two: bool) -> i32 {
+    let step = if cfg!(feature = "simd") { 32 } else { 1 };
+
     let exclusive =
         Exclusive { threes: BTreeMap::new(), fives: BTreeMap::new(), found: BTreeSet::new() };
-    let shared = Shared {
-        input,
-        part_two,
-        done: AtomicBool::new(false),
-        counter: AtomicI32::new(0),
-        mutex: Mutex::new(exclusive),
-    };
+    let shared =
+        Shared { input, part_two, iter: AtomicIter::new(0, step), mutex: Mutex::new(exclusive) };
 
     // Use as many cores as possible to parallelize the search.
     spawn(|| worker(&shared));
@@ -59,9 +54,9 @@ fn generate_pad(input: &str, part_two: bool) -> i32 {
 
 #[cfg(not(feature = "simd"))]
 fn worker(shared: &Shared<'_>) {
-    while !shared.done.load(Ordering::Relaxed) {
+    while let Some(n) = shared.iter.next() {
         // Get the next key to check.
-        let n = shared.counter.fetch_add(1, Ordering::Relaxed);
+        let n = n as i32;
 
         // Calculate the hash.
         let (mut buffer, size) = format_string(shared.input, n);
@@ -88,9 +83,9 @@ fn worker(shared: &Shared<'_>) {
     let mut result = ([0; 32], [0; 32], [0; 32], [0; 32]);
     let mut buffers = [[0; 64]; 32];
 
-    while !shared.done.load(Ordering::Relaxed) {
+    while let Some(start) = shared.iter.next() {
         // Get the next key to check.
-        let start = shared.counter.fetch_add(32, Ordering::Relaxed);
+        let start = start as i32;
 
         // Calculate the hash.
         for i in 0..32 {
@@ -183,7 +178,7 @@ fn check(shared: &Shared<'_>, n: i32, hash: (u32, u32, u32, u32)) {
         exclusive.found.extend(candidates);
 
         if exclusive.found.len() >= 64 {
-            shared.done.store(true, Ordering::Relaxed);
+            shared.iter.stop();
         }
     }
 }

src/year2017/day15.rs

@@ -11,7 +11,6 @@ use crate::util::iter::*;
 use crate::util::math::*;
 use crate::util::parse::*;
 use crate::util::thread::*;
-use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::mpsc::{Receiver, Sender, channel};
 use std::thread;
 
@@ -26,8 +25,7 @@ type Input = (usize, usize);
 pub struct Shared {
     first: usize,
     second: usize,
-    start: AtomicUsize,
-    done: AtomicBool,
+    iter: AtomicIter,
 }
 
 /// Generated numbers from `start` to `start + BLOCK`.
@@ -40,7 +38,7 @@ struct Block {
 
 pub fn parse(input: &str) -> Input {
     let [first, second] = input.iter_unsigned().chunk::<2>().next().unwrap();
-    let shared = Shared { first, second, start: AtomicUsize::new(0), done: AtomicBool::new(false) };
+    let shared = Shared { first, second, iter: AtomicIter::new(0, BLOCK as u32) };
     let (tx, rx) = channel();
 
     thread::scope(|scope| {
@@ -62,9 +60,9 @@ pub fn part2(input: &Input) -> usize {
 }
 
 fn sender(shared: &Shared, tx: &Sender<Block>) {
-    while !shared.done.load(Ordering::Relaxed) {
+    while let Some(start) = shared.iter.next() {
         // Start at any point in the sequence using modular exponentiation.
-        let start = shared.start.fetch_add(BLOCK, Ordering::Relaxed);
+        let start = start as usize;
         let mut first = shared.first * 16807.mod_pow(start, MOD);
         let mut second = shared.second * 48271.mod_pow(start, MOD);
 
@@ -138,7 +136,7 @@ fn receiver(shared: &Shared, rx: &Receiver<Block>) -> Input {
     }
 
     // Signal worker threads to finish.
-    shared.done.store(true, Ordering::Relaxed);
+    shared.iter.stop();
 
     (part_one, part_two)
 }

src/year2018/day15.rs

@@ -79,7 +79,6 @@
 use crate::util::grid::*;
 use crate::util::point::*;
 use crate::util::thread::*;
-use std::sync::atomic::{AtomicBool, AtomicI32, Ordering};
 
 const READING_ORDER: [Point; 4] = [UP, LEFT, RIGHT, DOWN];
 
@@ -103,12 +102,6 @@ struct Unit {
     power: i32,
 }
 
-/// Shared between threads for part two.
-struct Shared {
-    done: AtomicBool,
-    elf_attack_power: AtomicI32,
-}
-
 /// Parse the input into a bitmask for the cave walls
 /// and a list of point coordinates for each Elf and Goblin.
 pub fn parse(input: &str) -> Input {
@@ -143,24 +136,21 @@ pub fn part1(input: &Input) -> i32 {
 /// single Elf is killed. Since each fight is independent we can parallelize the search over
 /// multiple threads.
 pub fn part2(input: &Input) -> i32 {
-    let shared = Shared { done: AtomicBool::new(false), elf_attack_power: AtomicI32::new(4) };
+    let iter = AtomicIter::new(4, 1);
 
     // Use as many cores as possible to parallelize the search.
-    let result = spawn(|| worker(input, &shared));
+    let result = spawn(|| worker(input, &iter));
     // Find lowest possible power.
     result.into_iter().flatten().min_by_key(|&(eap, _)| eap).map(|(_, score)| score).unwrap()
 }
 
-fn worker(input: &Input, shared: &Shared) -> Option<(i32, i32)> {
-    while !shared.done.load(Ordering::Relaxed) {
-        // Get the next attack power, incrementing it atomically for the next fight.
-        let power = shared.elf_attack_power.fetch_add(1, Ordering::Relaxed);
-
+fn worker(input: &Input, iter: &AtomicIter) -> Option<(u32, i32)> {
+    while let Some(power) = iter.next() {
         // If the Elves win then set the score and signal all threads to stop.
         // Use a channel to queue all potential scores as another thread may already have sent a
         // different value.
-        if let Some(score) = fight(input, power, true) {
-            shared.done.store(true, Ordering::Relaxed);
+        if let Some(score) = fight(input, power as i32, true) {
+            iter.stop();
             return Some((power, score));
         }
     }