arty 0.5.0

Single-threaded, thread-aware application runtime.
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

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

use std::num::NonZeroUsize;

use crate::runtime::blocking_worker::BlockingPool;

/// Resolves whether workers share their blocking-task pool.
#[derive(Debug, Clone)]
pub(crate) enum BlockingPools {
    Shared(BlockingPool),
    PerWorker(Option<NonZeroUsize>),
}

impl BlockingPools {
    pub(crate) const fn per_worker(max_workers: Option<NonZeroUsize>) -> Self {
        Self::PerWorker(max_workers)
    }

    pub(crate) fn shared(max_workers: Option<NonZeroUsize>) -> Self {
        Self::Shared(BlockingPool::new_with_mode(max_workers, "shared"))
    }

    pub(super) fn build_worker(&self) -> BlockingPool {
        match self {
            Self::Shared(pool) => pool.clone(),
            Self::PerWorker(max_workers) => BlockingPool::new_with_mode(*max_workers, "per_worker"),
        }
    }
}

#[cfg(test)]
#[cfg_attr(coverage_nightly, coverage(off))] // Test scaffolding is not runtime behavior.
mod tests {
    use super::*;

    #[test]
    fn shared_policy_reuses_the_same_blocking_pool() {
        let pools = BlockingPools::shared(NonZeroUsize::new(1));
        assert!(pools.build_worker().shares_pool_with(&pools.build_worker()));
    }

    #[test]
    fn per_worker_policy_creates_independent_blocking_pools() {
        let pools = BlockingPools::per_worker(NonZeroUsize::new(1));
        assert!(!pools.build_worker().shares_pool_with(&pools.build_worker()));
    }
}