tasc 0.3.3

A minimnal, asynchronous threadpool
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 crate::{com, std_impl};
use core::sync::atomic::{AtomicUsize, Ordering};

/// The signal type used by the global context.
pub type Signal = std_impl::Signal;

static INITIAL_WORKERS: AtomicUsize = AtomicUsize::new(0);

/// The global context, which is used in [`ThreadBuilder::default`], [`tasc::task`], [`tasc::scope`], [`tasc::sync::task`] and [`tasc::sync::scope`].
pub struct GlobalContext {
    imp: std_impl::Context,
}

static GLOBAL: spin::Lazy<GlobalContext> = spin::Lazy::new(|| GlobalContext {
    imp: std_impl::Context::new({
        let workers = INITIAL_WORKERS.load(Ordering::Acquire);
        if workers == 0 {
            num_cpus::get()
        } else {
            workers
        }
    }),
});

/// Only works if called before anything uses the Global context.
/// Setting the amount to zero will cause it to pick the amount of cores
/// that are available to the system as a default.
pub fn init_with_limit(limit: usize) {
    INITIAL_WORKERS.store(limit, Ordering::Release);
    spin::Lazy::force(&GLOBAL);
}

impl GlobalContext {
    #[allow(missing_docs)]
    pub fn get() -> &'static Self {
        &GLOBAL
    }

    /// Creates a signal which is the same signal used by the global context. This is the same as using
    /// [`StdSignal::new`]
    pub fn signal() -> Signal {
        Signal::new()
    }
}

impl crate::TaskContext for GlobalContext {
    fn set_workers(&self, max: usize) {
        self.imp.set_workers(max)
    }

    fn workers(&self) -> usize {
        self.imp.workers()
    }

    fn create_task(&self, f: com::TaskFut) -> com::ComHandle {
        self.imp.create_task(f)
    }
}