arty 0.6.0

Thread-aware async runtime that keeps each task on one worker thread.
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

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

use std::cell::RefCell;

use performables::arc::Arc;

use crate::runtime::worker;
use crate::runtime::worker::blocking::PoolIdentity;

thread_local! {
    static CURRENT: RefCell<Option<LocalWorker>> = const { RefCell::new(None) };
}

/// Blocking pool identity attached to each pool thread.
#[derive(Debug)]
pub(crate) struct LocalWorker {
    pool: PoolIdentity,
}

impl LocalWorker {
    #[cfg_attr(test, mutants::skip)] // Missing pool identity disables the same-pool join deadlock guard.
    pub(crate) fn attach(pool: PoolIdentity) {
        worker::WorkerMarker::attach();
        CURRENT.with_borrow_mut(|current| {
            assert!(current.is_none(), "a blocking local worker is already attached to this thread");
            *current = Some(Self { pool });
        });
    }

    fn owns_pool(&self, pool: &PoolIdentity) -> bool {
        Arc::ptr_eq(&self.pool, pool)
    }

    pub(crate) fn is_current_pool(pool: &PoolIdentity) -> bool {
        CURRENT
            .try_with(|current| current.borrow().as_ref().is_some_and(|current| current.owns_pool(pool)))
            .unwrap_or(false)
    }
}