worker_synchronizer 0.1.0

Makes it easier to write multi thread workers that need to synchronize on a shared work pool
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

use std::{collections::VecDeque, thread};

use worker_synchronizer::Synchronizer;

const TARGET: u32 = 10;
fn main() {
    let numbers: [_; 32] = std::array::from_fn(|i| i as u32);
    let init = (0, 0, numbers.as_slice());
    let synchronizer = Synchronizer::new(VecDeque::from([init]));
    thread::scope(|scope| {
        for _ in 0..thread::available_parallelism().unwrap().get() {
            scope.spawn(|| {
                for ((current, selected, remaining_slice), writer) in &synchronizer {
                    use std::cmp::Ordering::*;
                    match current.cmp(&TARGET) {
                        Less => {
                            let Some((next, remaining_slice)) = remaining_slice.split_first()
                            else {
                                continue;
                            };
                            writer
                                .write_multiples([
                                    (current + next, (selected << 1) + 1, remaining_slice),
                                    (current, selected << 1, remaining_slice),
                                ])
                                .unwrap();
                        }
                        Equal => {
                            dbg!(current, selected, remaining_slice);
                            synchronizer.close();
                        }
                        Greater => (),
                    }
                }
            });
        }
    })
}