par-core 2.0.0

Switchable parallel execution core
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! # par-core
//!
//! A wrapper for various parallelization library for Rust.
//! This crate currently supports
//!
//! - [`chili`](https://github.com/dragostis/chili)
//! - [`rayon`](https://github.com/rayon-rs/rayon)
//! - Disable parallelization.
//!
//! # Usage
//!
//! If you are developing a library, you should not force the parallelization
//! library, and let the users choose the parallelization library.
//!
//! ## Final application
//!
//! If you are developing a final application, you can use cargo feature to
//! select the parallelization library.
//!
//! ### `chili`
//!
//! ```toml
//! [dependencies]
//! par-core = { version = "1.0.1", features = ["chili"] }
//! ```
//!
//! ### `rayon`
//!
//! ```toml
//! [dependencies]
//! par-core = { version = "1.0.1", features = ["rayon"] }
//! ```
//!
//! ### Disable parallelization
//!
//! ```toml
//! [dependencies]
//! par-core = { version = "1.0.1", default-features = false }
//! ```
//!
//! ## Library developers
//!
//! If you are developing a library, you can simply depend on `par-core` without
//! any features. **Note**: To prevent a small mistake of end-user making the
//! appplication slower, `par-core` emits a error message using a default
//! feature. So if you are a library developer, you should specify
//! `default-features = false`.
//!
//! ```toml
//! [dependencies]
//! par-core = { version = "1.0.1", default-features = false }
//! ```

#[cfg(all(not(feature = "chili"), not(feature = "rayon"), feature = "parallel"))]
compile_error!("You must enable `chili` or `rayon` feature if you want to use `parallel` feature");

#[cfg(all(feature = "chili", feature = "rayon"))]
compile_error!("You must enable `chili` or `rayon` feature, not both");

#[cfg(feature = "chili")]
mod par_chili {
    use std::{cell::RefCell, mem::transmute};

    use chili::Scope;

    thread_local! {
        static SCOPE: RefCell<Option<&'static mut Scope<'static>>> = Default::default();
    }

    #[inline]
    fn join_scoped<A, B, RA, RB>(scope: &mut Scope<'_>, oper_a: A, oper_b: B) -> (RA, RB)
    where
        A: Send + FnOnce() -> RA,
        B: Send + FnOnce() -> RB,
        RA: Send,
        RB: Send,
    {
        scope.join(
            |scope| {
                let old_scope = SCOPE.take();
                // SATETY: it will be only accessed during `oper_a`
                SCOPE.set(Some(unsafe { transmute::<&mut Scope, &mut Scope>(scope) }));

                let ra = oper_a();
                SCOPE.set(old_scope);

                ra
            },
            |scope| {
                let old_scope = SCOPE.take();
                // SATETY: it will be only accessed during `oper_b`
                SCOPE.set(Some(unsafe { transmute::<&mut Scope, &mut Scope>(scope) }));

                let rb = oper_b();
                SCOPE.set(old_scope);

                rb
            },
        )
    }

    #[inline]
    pub fn join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
    where
        A: Send + FnOnce() -> RA,
        B: Send + FnOnce() -> RB,
        RA: Send,
        RB: Send,
    {
        let old_scope: Option<&mut Scope<'_>> = SCOPE.take();
        match old_scope {
            Some(scope) => {
                let (ra, rb) = join_scoped(scope, oper_a, oper_b);
                SCOPE.set(Some(scope));
                (ra, rb)
            }
            None => join_scoped(&mut Scope::global(), oper_a, oper_b),
        }
    }
}

pub fn join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
where
    A: Send + FnOnce() -> RA,
    B: Send + FnOnce() -> RB,
    RA: Send,
    RB: Send,
{
    #[cfg(feature = "chili")]
    let (ra, rb) = par_chili::join(oper_a, oper_b);

    #[cfg(feature = "rayon")]
    let (ra, rb) = rayon::join(oper_a, oper_b);

    #[cfg(not(feature = "parallel"))]
    let (ra, rb) = (oper_a(), oper_b());

    (ra, rb)
}