tokio 0.2.13

An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications.
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

use crate::loom::sync::Arc;
use crate::runtime::thread_pool::{slice, Owned};

use std::cell::Cell;
use std::ptr;

/// Tracks the current worker
#[derive(Debug)]
pub(super) struct Current {
    inner: Inner,
}

#[derive(Debug, Copy, Clone)]
struct Inner {
    // thread-local variables cannot track generics. However, the current worker
    // is only checked when `P` is already known, so the type can be figured out
    // on demand.
    workers: *const (),
    idx: usize,
}

// Pointer to the current worker info
thread_local!(static CURRENT_WORKER: Cell<Inner> = Cell::new(Inner::new()));

pub(super) fn set<F, R>(pool: &Arc<slice::Set>, index: usize, f: F) -> R
where
    F: FnOnce() -> R,
{
    CURRENT_WORKER.with(|cell| {
        assert!(cell.get().workers.is_null());

        struct Guard<'a>(&'a Cell<Inner>);

        impl Drop for Guard<'_> {
            fn drop(&mut self) {
                self.0.set(Inner::new());
            }
        }

        cell.set(Inner {
            workers: pool.shared() as *const _ as *const (),
            idx: index,
        });

        let _g = Guard(cell);

        f()
    })
}

pub(super) fn clear() {
    CURRENT_WORKER.with(|cell| cell.set(Inner::new()))
}

pub(super) fn get<F, R>(f: F) -> R
where
    F: FnOnce(&Current) -> R,
{
    CURRENT_WORKER.with(|cell| {
        let current = Current { inner: cell.get() };
        f(&current)
    })
}

impl Current {
    pub(super) fn as_member<'a>(&self, set: &'a slice::Set) -> Option<&'a Owned> {
        let inner = CURRENT_WORKER.with(|cell| cell.get());

        if ptr::eq(inner.workers as *const _, set.shared().as_ptr()) {
            Some(unsafe { &*set.owned()[inner.idx].get() })
        } else {
            None
        }
    }
}

impl Inner {
    fn new() -> Inner {
        Inner {
            workers: ptr::null(),
            idx: 0,
        }
    }
}