Simplify threading by collecting values from joined threads

Author: maneatingape

README.md

@@ -80,7 +80,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 3 | [Mull It Over](https://adventofcode.com/2024/day/3) | [Source](src/year2024/day03.rs) | 8 |
 | 4 | [Ceres Search](https://adventofcode.com/2024/day/4) | [Source](src/year2024/day04.rs) | 77 |
 | 5 | [Print Queue](https://adventofcode.com/2024/day/5) | [Source](src/year2024/day05.rs) | 18 |
-| 6 | [Guard Gallivant](https://adventofcode.com/2024/day/6) | [Source](src/year2024/day06.rs) | 331 |
+| 6 | [Guard Gallivant](https://adventofcode.com/2024/day/6) | [Source](src/year2024/day06.rs) | 439 |
 | 7 | [Bridge Repair](https://adventofcode.com/2024/day/7) | [Source](src/year2024/day07.rs) | 136 |
 | 8 | [Resonant Collinearity](https://adventofcode.com/2024/day/8) | [Source](src/year2024/day08.rs) | 8 |
 | 9 | [Disk Fragmenter](https://adventofcode.com/2024/day/9) | [Source](src/year2024/day09.rs) | 106 |
@@ -94,9 +94,9 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 17 | [Chronospatial Computer](https://adventofcode.com/2024/day/17) | [Source](src/year2024/day17.rs) | 2 |
 | 18 | [RAM Run](https://adventofcode.com/2024/day/18) | [Source](src/year2024/day18.rs) | 42 |
 | 19 | [Linen Layout](https://adventofcode.com/2024/day/19) | [Source](src/year2024/day19.rs) | 110 |
-| 20 | [Race Condition](https://adventofcode.com/2024/day/20) | [Source](src/year2024/day20.rs) | 1038 |
+| 20 | [Race Condition](https://adventofcode.com/2024/day/20) | [Source](src/year2024/day20.rs) | 1113 |
 | 21 | [Keypad Conundrum](https://adventofcode.com/2024/day/21) | [Source](src/year2024/day21.rs) | 19 |
-| 22 | [Monkey Market](https://adventofcode.com/2024/day/22) | [Source](src/year2024/day22.rs) | 727 |
+| 22 | [Monkey Market](https://adventofcode.com/2024/day/22) | [Source](src/year2024/day22.rs) | 688 |
 | 23 | [LAN Party](https://adventofcode.com/2024/day/23) | [Source](src/year2024/day23.rs) | 43 |
 | 24 | [Crossed Wires](https://adventofcode.com/2024/day/24) | [Source](src/year2024/day24.rs) | 23 |
 | 25 | [Code Chronicle](https://adventofcode.com/2024/day/25) | [Source](src/year2024/day25.rs) | 8 |
@@ -118,7 +118,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 9 | [Mirage Maintenance](https://adventofcode.com/2023/day/9) | [Source](src/year2023/day09.rs) | 18 |
 | 10 | [Pipe Maze](https://adventofcode.com/2023/day/10) | [Source](src/year2023/day10.rs) | 35 |
 | 11 | [Cosmic Expansion](https://adventofcode.com/2023/day/11) | [Source](src/year2023/day11.rs) | 12 |
-| 12 | [Hot Springs](https://adventofcode.com/2023/day/12) | [Source](src/year2023/day12.rs) | 387 |
+| 12 | [Hot Springs](https://adventofcode.com/2023/day/12) | [Source](src/year2023/day12.rs) | 455 |
 | 13 | [Point of Incidence](https://adventofcode.com/2023/day/13) | [Source](src/year2023/day13.rs) | 66 |
 | 14 | [Parabolic Reflector Dish](https://adventofcode.com/2023/day/14) | [Source](src/year2023/day14.rs) | 632 |
 | 15 | [Lens Library](https://adventofcode.com/2023/day/15) | [Source](src/year2023/day15.rs) | 84 |
@@ -188,7 +188,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 15 | [Chiton](https://adventofcode.com/2021/day/15) | [Source](src/year2021/day15.rs) | 2403 |
 | 16 | [Packet Decoder](https://adventofcode.com/2021/day/16) | [Source](src/year2021/day16.rs) | 6 |
 | 17 | [Trick Shot](https://adventofcode.com/2021/day/17) | [Source](src/year2021/day17.rs) | 7 |
-| 18 | [Snailfish](https://adventofcode.com/2021/day/18) | [Source](src/year2021/day18.rs) | 404 |
+| 18 | [Snailfish](https://adventofcode.com/2021/day/18) | [Source](src/year2021/day18.rs) | 476 |
 | 19 | [Beacon Scanner](https://adventofcode.com/2021/day/19) | [Source](src/year2021/day19.rs) | 615 |
 | 20 | [Trench Map](https://adventofcode.com/2021/day/20) | [Source](src/year2021/day20.rs) | 2066 |
 | 21 | [Dirac Dice](https://adventofcode.com/2021/day/21) | [Source](src/year2021/day21.rs) | 278 |
@@ -277,7 +277,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 8 | [Memory Maneuver](https://adventofcode.com/2018/day/8) | [Source](src/year2018/day08.rs) | 24 |
 | 9 | [Marble Mania](https://adventofcode.com/2018/day/9) | [Source](src/year2018/day09.rs) | 909 |
 | 10 | [The Stars Align](https://adventofcode.com/2018/day/10) | [Source](src/year2018/day10.rs) | 11 |
-| 11 | [Chronal Charge](https://adventofcode.com/2018/day/11) | [Source](src/year2018/day11.rs) | 1156 |
+| 11 | [Chronal Charge](https://adventofcode.com/2018/day/11) | [Source](src/year2018/day11.rs) | 1193 |
 | 12 | [Subterranean Sustainability](https://adventofcode.com/2018/day/12) | [Source](src/year2018/day12.rs) | 77 |
 | 13 | [Mine Cart Madness](https://adventofcode.com/2018/day/13) | [Source](src/year2018/day13.rs) | 349 |
 | 14 | [Chocolate Charts](https://adventofcode.com/2018/day/14) | [Source](src/year2018/day14.rs) | 24000 |
@@ -368,7 +368,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 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 |
 | 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) | 386 |
+| 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 |
 | 8 | [Matchsticks](https://adventofcode.com/2015/day/8) | [Source](src/year2015/day08.rs) | 5 |
 | 9 | [All in a Single Night](https://adventofcode.com/2015/day/9) | [Source](src/year2015/day09.rs) | 34 |

src/util/thread.rs

@@ -6,20 +6,26 @@ use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
 use std::thread::*;
 
 /// Usually the number of physical cores.
-fn threads() -> usize {
+pub fn threads() -> usize {
     available_parallelism().unwrap().get()
 }
 
 /// Spawn `n` scoped threads, where `n` is the available parallelism.
-pub fn spawn<F>(f: F)
+pub fn spawn<F, R>(f: F) -> Vec<R>
 where
-    F: Fn() + Copy + Send,
+    F: Fn() -> R + Copy + Send,
+    R: Send,
 {
     scope(|scope| {
+        let mut handles = Vec::new();
+
         for _ in 0..threads() {
-            scope.spawn(f);
+            let handle = scope.spawn(f);
+            handles.push(handle);
         }
-    });
+
+        handles.into_iter().flat_map(ScopedJoinHandle::join).collect()
+    })
 }
 
 /// Spawns `n` scoped threads that each receive a
@@ -28,9 +34,10 @@ where
 /// than other to process, used by popular libraries such as [rayon](https://github.com/rayon-rs/rayon).
 /// Processing at different rates also happens on many modern CPUs with
 /// [heterogeneous performance and efficiency cores](https://en.wikipedia.org/wiki/ARM_big.LITTLE).
-pub fn spawn_parallel_iterator<F, T>(items: &[T], f: F)
+pub fn spawn_parallel_iterator<F, R, T>(items: &[T], f: F) -> Vec<R>
 where
-    F: Fn(ParIter<'_, T>) + Copy + Send,
+    F: Fn(ParIter<'_, T>) -> R + Copy + Send,
+    R: Send,
     T: Sync,
 {
     let threads = threads();
@@ -47,10 +54,15 @@ where
     let workers = workers.as_slice();
 
     scope(|scope| {
+        let mut handles = Vec::new();
+
         for id in 0..threads {
-            scope.spawn(move || f(ParIter { id, items, workers }));
+            let handle = scope.spawn(move || f(ParIter { id, items, workers }));
+            handles.push(handle);
         }
-    });
+
+        handles.into_iter().flat_map(ScopedJoinHandle::join).collect()
+    })
 }
 
 pub struct ParIter<'a, T> {

src/year2015/day06.rs

@@ -5,7 +5,6 @@
 use crate::util::iter::*;
 use crate::util::parse::*;
 use crate::util::thread::*;
-use std::sync::atomic::{AtomicU32, Ordering};
 
 #[derive(Clone, Copy)]
 enum Command {
@@ -62,24 +61,18 @@ pub fn parse(input: &str) -> Vec<Instruction> {
 
 pub fn part1(input: &[Instruction]) -> u32 {
     let items: Vec<_> = (0..1000).collect();
-    let atomic = AtomicU32::new(0);
-
-    spawn_parallel_iterator(&items, |iter| worker_one(input, &atomic, iter));
-    atomic.into_inner()
+    let result = spawn_parallel_iterator(&items, |iter| worker_one(input, iter));
+    result.into_iter().sum()
 }
 
 pub fn part2(input: &[Instruction]) -> u32 {
     let items: Vec<_> = (0..1000).collect();
-    let atomic = AtomicU32::new(0);
-
-    spawn_parallel_iterator(&items, |iter| worker_two(input, &atomic, iter));
-    atomic.into_inner()
+    let result = spawn_parallel_iterator(&items, |iter| worker_two(input, iter));
+    result.into_iter().sum()
 }
 
-fn worker_one(input: &[Instruction], atomic: &AtomicU32, iter: ParIter<'_, usize>) {
-    let mut result = 0;
-
-    for row in iter {
+fn worker_one(input: &[Instruction], iter: ParIter<'_, usize>) -> u32 {
+    iter.map(|row| {
         let mut grid = [0_u8; 1_024];
 
         for &Instruction { command, rectangle: Rectangle { x1, y1, x2, y2 } } in input {
@@ -93,16 +86,13 @@ fn worker_one(input: &[Instruction], atomic: &AtomicU32, iter: ParIter<'_, usize
             }
         }
 
-        result += grid.into_iter().map(|b| b as u32).sum::<u32>();
-    }
-
-    atomic.fetch_add(result, Ordering::Relaxed);
+        grid.into_iter().map(|b| b as u32).sum::<u32>()
+    })
+    .sum()
 }
 
-fn worker_two(input: &[Instruction], atomic: &AtomicU32, iter: ParIter<'_, usize>) {
-    let mut result = 0;
-
-    for row in iter {
+fn worker_two(input: &[Instruction], iter: ParIter<'_, usize>) -> u32 {
+    iter.map(|row| {
         let mut grid = [0_u8; 1_024];
 
         for &Instruction { command, rectangle: Rectangle { x1, y1, x2, y2 } } in input {
@@ -116,8 +106,7 @@ fn worker_two(input: &[Instruction], atomic: &AtomicU32, iter: ParIter<'_, usize
             }
         }
 
-        result += grid.into_iter().map(|b| b as u32).sum::<u32>();
-    }
-
-    atomic.fetch_add(result, Ordering::Relaxed);
+        grid.into_iter().map(|b| b as u32).sum::<u32>()
+    })
+    .sum()
 }

src/year2017/day15.rs

@@ -10,6 +10,7 @@ use crate::util::hash::*;
 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;
@@ -44,7 +45,7 @@ pub fn parse(input: &str) -> Input {
 
     thread::scope(|scope| {
         // Use all cores except one to generate blocks of numbers for judging.
-        for _ in 0..thread::available_parallelism().unwrap().get() - 1 {
+        for _ in 0..threads() - 1 {
             scope.spawn(|| sender(&shared, &tx));
         }
         // Judge batches serially.

src/year2018/day11.rs

@@ -7,7 +7,6 @@
 //! so we can parallelize over multiple threads.
 use crate::util::parse::*;
 use crate::util::thread::*;
-use std::sync::Mutex;
 
 pub struct Result {
     x: usize,
@@ -16,11 +15,6 @@ pub struct Result {
     power: i32,
 }
 
-struct Shared {
-    sat: Vec<i32>,
-    mutex: Mutex<Vec<Result>>,
-}
-
 pub fn parse(input: &str) -> Vec<Result> {
     let grid_serial_number: i32 = input.signed();
 
@@ -45,9 +39,8 @@ pub fn parse(input: &str) -> Vec<Result> {
     // Use as many cores as possible to parallelize the search.
     // Smaller sizes take more time so use work stealing to keep all cores busy.
     let items: Vec<_> = (1..301).collect();
-    let shared = Shared { sat, mutex: Mutex::new(Vec::new()) };
-    spawn_parallel_iterator(&items, |iter| worker(&shared, iter));
-    shared.mutex.into_inner().unwrap()
+    let result = spawn_parallel_iterator(&items, |iter| worker(&sat, iter));
+    result.into_iter().flatten().collect()
 }
 
 pub fn part1(input: &[Result]) -> String {
@@ -60,15 +53,12 @@ pub fn part2(input: &[Result]) -> String {
     format!("{x},{y},{size}")
 }
 
-fn worker(shared: &Shared, iter: ParIter<'_, usize>) {
-    let result: Vec<_> = iter
-        .map(|&size| {
-            let (power, x, y) = square(&shared.sat, size);
-            Result { x, y, size, power }
-        })
-        .collect();
-
-    shared.mutex.lock().unwrap().extend(result);
+fn worker(sat: &[i32], iter: ParIter<'_, usize>) -> Vec<Result> {
+    iter.map(|&size| {
+        let (power, x, y) = square(sat, size);
+        Result { x, y, size, power }
+    })
+    .collect()
 }
 
 /// Find the (x,y) coordinates and max power for a square of the specified size.

src/year2021/day18.rs

@@ -29,7 +29,6 @@
 //! always greater than or equal to zero, `-1` is used as a special sentinel value for non-leaf nodes.
 use crate::util::parse::*;
 use crate::util::thread::*;
-use std::sync::atomic::{AtomicI32, Ordering};
 
 type Snailfish = [i32; 63];
 
@@ -85,20 +84,13 @@ pub fn part2(input: &[Snailfish]) -> i32 {
     }
 
     // Use as many cores as possible to parallelize the calculation.
-    let shared = AtomicI32::new(0);
-    spawn_parallel_iterator(&pairs, |iter| worker(&shared, iter));
-    shared.into_inner()
+    let result = spawn_parallel_iterator(&pairs, worker);
+    result.into_iter().max().unwrap()
 }
 
 /// Pair addition is independent so we can parallelize across multiple threads.
-fn worker(shared: &AtomicI32, iter: ParIter<'_, (&Snailfish, &Snailfish)>) {
-    let mut partial = 0;
-
-    for (a, b) in iter {
-        partial = partial.max(magnitude(&mut add(a, b)));
-    }
-
-    shared.fetch_max(partial, Ordering::Relaxed);
+fn worker(iter: ParIter<'_, (&Snailfish, &Snailfish)>) -> i32 {
+    iter.map(|&(a, b)| magnitude(&mut add(a, b))).max().unwrap()
 }
 
 /// Add two snailfish numbers.

src/year2022/day11.rs

@@ -43,7 +43,8 @@
 //! [`iter_unsigned`]: ParseOps::iter_unsigned
 use crate::util::parse::*;
 use crate::util::thread::*;
-use std::sync::Mutex;
+
+type Pair = (usize, u64);
 
 pub struct Monkey {
     items: Vec<u64>,
@@ -59,19 +60,8 @@ pub enum Operation {
     Add(u64),
 }
 
-type Pair = (usize, u64);
 type Business = [u64; 8];
 
-struct Shared<'a> {
-    monkeys: &'a [Monkey],
-    mutex: Mutex<Exclusive>,
-}
-
-struct Exclusive {
-    pairs: Vec<Pair>,
-    business: Business,
-}
-
 /// Extract each Monkey's info from the flavor text. With the exception of the lines starting
 /// `Operation` we are only interested in the numbers on each line.
 pub fn parse(input: &str) -> Vec<Monkey> {
@@ -102,7 +92,7 @@ pub fn part2(input: &[Monkey]) -> u64 {
 }
 
 /// Convenience wrapper to reuse common logic between part one and two.
-fn solve(monkeys: &[Monkey], play: impl Fn(&[Monkey], Vec<Pair>) -> Business) -> u64 {
+fn solve(monkeys: &[Monkey], play: impl Fn(&[Monkey], &[Pair]) -> Business) -> u64 {
     let mut pairs = Vec::new();
 
     for (from, monkey) in monkeys.iter().enumerate() {
@@ -111,16 +101,16 @@ fn solve(monkeys: &[Monkey], play: impl Fn(&[Monkey], Vec<Pair>) -> Business) ->
         }
     }
 
-    let mut business = play(monkeys, pairs);
+    let mut business = play(monkeys, &pairs);
     business.sort_unstable();
     business.iter().rev().take(2).product()
 }
 
 /// Play 20 rounds dividing the worry level by 3 each inspection.
-fn sequential(monkeys: &[Monkey], pairs: Vec<Pair>) -> Business {
+fn sequential(monkeys: &[Monkey], pairs: &[Pair]) -> Business {
     let mut business = [0; 8];
 
-    for pair in pairs {
+    for &pair in pairs {
         let extra = play(monkeys, 20, |x| x / 3, pair);
         business.iter_mut().enumerate().for_each(|(i, b)| *b += extra[i]);
     }
@@ -129,31 +119,21 @@ fn sequential(monkeys: &[Monkey], pairs: Vec<Pair>) -> Business {
 }
 
 /// Play 10,000 rounds adjusting the worry level modulo the product of all the monkey's test values.
-fn parallel(monkeys: &[Monkey], pairs: Vec<Pair>) -> Business {
-    let shared = Shared { monkeys, mutex: Mutex::new(Exclusive { pairs, business: [0; 8] }) };
-
+fn parallel(monkeys: &[Monkey], pairs: &[Pair]) -> Business {
     // Use as many cores as possible to parallelize the calculation.
-    spawn(|| worker(&shared));
+    let result = spawn_parallel_iterator(pairs, |iter| worker(monkeys, iter));
 
-    shared.mutex.into_inner().unwrap().business
+    let mut business = [0; 8];
+    for extra in result.into_iter().flatten() {
+        business.iter_mut().zip(extra).for_each(|(b, e)| *b += e);
+    }
+    business
 }
 
 /// Multiple worker functions are executed in parallel, one per thread.
-fn worker(shared: &Shared<'_>) {
-    let product: u64 = shared.monkeys.iter().map(|m| m.test).product();
-
-    loop {
-        // Take an item from the queue until empty, using the mutex to allow access
-        // to a single thread at a time.
-        let Some(pair) = shared.mutex.lock().unwrap().pairs.pop() else {
-            break;
-        };
-
-        let extra = play(shared.monkeys, 10000, |x| x % product, pair);
-
-        let mut exclusive = shared.mutex.lock().unwrap();
-        exclusive.business.iter_mut().enumerate().for_each(|(i, b)| *b += extra[i]);
-    }
+fn worker(monkeys: &[Monkey], iter: ParIter<'_, Pair>) -> Vec<Business> {
+    let product: u64 = monkeys.iter().map(|m| m.test).product();
+    iter.map(|&pair| play(monkeys, 10000, |x| x % product, pair)).collect()
 }
 
 /// Play an arbitrary number of rounds for a single item.