Tidy threading

Author: maneatingape

src/year2022/day11.rs

@@ -68,7 +68,6 @@ struct Shared<'a> {
 }
 
 struct Exclusive {
-    pairs: Vec<Pair>,
     business: Business,
 }
 
@@ -102,7 +101,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 +110,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,26 +128,20 @@ 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 {
+    let shared = Shared { monkeys, mutex: Mutex::new(Exclusive { business: [0; 8] }) };
 
     // Use as many cores as possible to parallelize the calculation.
-    spawn(|| worker(&shared));
+    spawn_parallel_iterator(pairs, |iter| worker(&shared, iter));
 
     shared.mutex.into_inner().unwrap().business
 }
 
 /// Multiple worker functions are executed in parallel, one per thread.
-fn worker(shared: &Shared<'_>) {
+fn worker(shared: &Shared<'_>, iter: ParIter<'_, Pair>) {
     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;
-        };
-
+    for &pair in iter {
         let extra = play(shared.monkeys, 10000, |x| x % product, pair);
 
         let mut exclusive = shared.mutex.lock().unwrap();