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

use crate::*;

#[derive(Clone, Copy, Debug)]
/// Thread pool configuration
pub struct ThreadPoolConfig {
    pub(crate) keep_alive: Duration,
    pub(crate) min_workers: NonZeroU16,
    pub(crate) max_workers: NonZeroU16,
    pub(crate) min_available_workers: NonZeroU16,
    pub(crate) max_available_workers: NonZeroU16,
    pub(crate) queue_size: Option<usize>,
}

impl Default for ThreadPoolConfig {
    fn default() -> Self {
        let min_workers = NonZeroU16::new(num_cpus::get() as u16)
            .unwrap_or(unsafe { NonZeroU16::new_unchecked(4) });
        ThreadPoolConfig {
            keep_alive: Duration::from_secs(30),
            min_workers,
            max_workers: unsafe { NonZeroU16::new_unchecked(512) },
            min_available_workers: unsafe { NonZeroU16::new_unchecked(4) },
            max_available_workers: min_workers,
            queue_size: Some(64),
        }
    }
}

impl ThreadPoolConfig {
    /// Low configuration
    pub fn low() -> Self {
        ThreadPoolConfig {
            keep_alive: Duration::from_secs(5),
            min_workers: unsafe { NonZeroU16::new_unchecked(1) },
            max_workers: unsafe { NonZeroU16::new_unchecked(3) },
            min_available_workers: unsafe { NonZeroU16::new_unchecked(1) },
            max_available_workers: unsafe { NonZeroU16::new_unchecked(3) },
            queue_size: Some(4),
        }
    }
    ///
    pub fn keep_alive(mut self, keep_alive: u64) -> Self {
        self.keep_alive = Duration::from_secs(keep_alive);
        self
    }
    ///
    pub fn min_workers(mut self, min_workers: NonZeroU16) -> Self {
        self.min_workers = min_workers;
        self
    }
    ///
    pub fn max_workers(mut self, max_workers: NonZeroU16) -> Self {
        assert!(self.max_available_workers < max_workers);
        self.max_workers = max_workers;
        self
    }
    ///
    pub fn min_available_workers(mut self, min_available_workers: NonZeroU16) -> Self {
        self.min_available_workers = min_available_workers;
        self
    }
    ///
    pub fn max_available_workers(mut self, max_available_workers: NonZeroU16) -> Self {
        assert!(max_available_workers < self.max_workers);
        self.max_available_workers = max_available_workers;
        self
    }
    ///
    pub fn queue_size(mut self, queue_size: Option<usize>) -> Self {
        self.queue_size = queue_size;
        self
    }
}