veda-rs 1.0.0

High-performance parallel runtime for Rust with work-stealing and adaptive scheduling
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

use crossbeam_channel::{bounded, Sender, Receiver};
use std::marker::PhantomData;

pub struct Scope<'scope> {
    tx: Sender<()>,
    rx: Receiver<()>,
    pending: usize,
    _marker: PhantomData<&'scope ()>,
}

impl<'scope> Scope<'scope> {
    fn new() -> Self {
        let (tx, rx) = bounded(1024);
        Self {
            tx,
            rx,
            pending: 0,
            _marker: PhantomData,
        }
    }
    
    pub fn spawn<F>(&mut self, f: F)
    where
        F: FnOnce() + Send + 'scope,
    {
        let tx = self.tx.clone();
        self.pending += 1;
        
        let f: Box<dyn FnOnce() + Send + 'static> = unsafe {
            std::mem::transmute(Box::new(f) as Box<dyn FnOnce() + Send + 'scope>)
        };
        
        crate::runtime::with_current_runtime(|rt| {
            rt.pool.execute(move || {
                f();
                let _ = tx.send(());
            });
        });
    }
}

impl<'scope> Drop for Scope<'scope> {
    fn drop(&mut self) {
        for _ in 0..self.pending {
            let _ = self.rx.recv();
        }
    }
}

pub fn scope<'scope, F, R>(f: F) -> R
where
    F: FnOnce(&mut Scope<'scope>) -> R,
{
    let mut scope = Scope::new();
    let result = f(&mut scope);
    drop(scope);
    result
}