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 |
@@ -312,7 +312,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 11 | [Hex Ed](https://adventofcode.com/2017/day/11) | [Source](src/year2017/day11.rs) | 15 |
 | 12 | [Digital Plumber](https://adventofcode.com/2017/day/12) | [Source](src/year2017/day12.rs) | 61 |
 | 13 | [Packet Scanners](https://adventofcode.com/2017/day/13) | [Source](src/year2017/day13.rs) | 1 |
-| 14 | [Disk Defragmentation](https://adventofcode.com/2017/day/14) | [Source](src/year2017/day14.rs) | 438 |
+| 14 | [Disk Defragmentation](https://adventofcode.com/2017/day/14) | [Source](src/year2017/day14.rs) | 488 |
 | 15 | [Dueling Generators](https://adventofcode.com/2017/day/15) | [Source](src/year2017/day15.rs) | 20000 |
 | 16 | [Permutation Promenade](https://adventofcode.com/2017/day/16) | [Source](src/year2017/day16.rs) | 68 |
 | 17 | [Spinlock](https://adventofcode.com/2017/day/17) | [Source](src/year2017/day17.rs) | 85 |
@@ -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/day14.rs

@@ -6,33 +6,16 @@
 //! [`Day 10`]: crate::year2017::day10
 //! [`Day 12`]: crate::year2017::day12
 use crate::util::thread::*;
-use std::sync::Mutex;
-use std::sync::atomic::{AtomicUsize, Ordering};
-
-/// Atomics can be safely shared between threads.
-pub struct Shared {
-    prefix: String,
-    counter: AtomicUsize,
-    mutex: Mutex<Exclusive>,
-}
-
-/// Regular data structures need to be protected by a mutex.
-struct Exclusive {
-    grid: Vec<u8>,
-}
 
 /// Parallelize the hashing as each row is independent.
 pub fn parse(input: &str) -> Vec<u8> {
-    let shared = Shared {
-        prefix: input.trim().to_owned(),
-        counter: AtomicUsize::new(0),
-        mutex: Mutex::new(Exclusive { grid: vec![0; 0x4000] }),
-    };
-
-    // Use as many cores as possible to parallelize the hashing.
-    spawn(|| worker(&shared));
+    let prefix = &input.trim();
+    let rows: Vec<_> = (0..128).collect();
+    let result = spawn_parallel_iterator(&rows, |iter| worker(prefix, iter));
 
-    shared.mutex.into_inner().unwrap().grid
+    let mut sorted: Vec<_> = result.into_iter().flatten().collect();
+    sorted.sort_unstable_by_key(|&(index, _)| index);
+    sorted.into_iter().flat_map(|(_, row)| row).collect()
 }
 
 pub fn part1(input: &[u8]) -> u32 {
@@ -56,30 +39,18 @@ pub fn part2(input: &[u8]) -> u32 {
 
 /// Each worker thread chooses the next available index then computes the hash and patches the
 /// final vec with the result.
-fn worker(shared: &Shared) {
-    loop {
-        let index = shared.counter.fetch_add(1, Ordering::Relaxed);
-        if index >= 128 {
-            break;
-        }
-
-        let row = fill_row(&shared.prefix, index);
-        let start = index * 128;
-        let end = start + 128;
-
-        let mut exclusive = shared.mutex.lock().unwrap();
-        exclusive.grid[start..end].copy_from_slice(&row);
-    }
+fn worker(prefix: &str, iter: ParIter<'_, usize>) -> Vec<(usize, Vec<u8>)> {
+    iter.map(|&index| (index, fill_row(prefix, index))).collect()
 }
 
 /// Compute the knot hash for a row and expand into an array of bytes.
-fn fill_row(prefix: &str, index: usize) -> [u8; 128] {
+fn fill_row(prefix: &str, index: usize) -> Vec<u8> {
     let s = format!("{prefix}-{index}");
     let mut lengths: Vec<_> = s.bytes().map(|b| b as usize).collect();
     lengths.extend([17, 31, 73, 47, 23]);
 
     let knot = knot_hash(&lengths);
-    let mut result = [0; 128];
+    let mut result = vec![0; 128];
 
     for (i, chunk) in knot.chunks_exact(16).enumerate() {
         let reduced = chunk.iter().fold(0, |acc, n| acc ^ n);

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.