amity 0.6.3

Concurrency algorithms
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

//! This module abstracts over the park-unpark mechanism.

#[cfg(feature = "std")]
use std::thread::{current, park, yield_now, Thread};

/// Generic unpark mechanism.
/// With `std` enabled `std::thread::Thread` implements this trait.
pub trait Unpark: Clone {
    fn unpark(&self);
}

/// Generic unpark mechanism that can be default-constructed.
/// With `std` enabled `std::thread::Thread` implements this trait.
pub trait DefaultPark: Unpark + Sized {
    type Park: Park<Self>;
    fn default_park() -> Self::Park;
}

#[cfg(feature = "std")]
impl Unpark for Thread {
    #[inline]
    fn unpark(&self) {
        self.unpark();
    }
}

#[cfg(feature = "std")]
impl DefaultPark for Thread {
    type Park = CurrentThread;

    #[inline]
    fn default_park() -> Self::Park {
        CurrentThread
    }
}

/// Generic parking mechanism.
///
/// # Usage
///
/// Call `unpark_token` to get a token that can be used to unpark this thread.
/// Place where another token can find it to unpark this thread.
/// Call `park` to block the current thread until it is unparked.
///
/// With `"std"` feature enabled `CurrentThread` implement this trait with `Thread` as unpark token.
///
/// `ParkYield` implements this trait with `UnparkYield` as unpark token.
/// It yields the current thread when `park` is called instead of blocking it.
/// This behavior is valid since spurious wakeups are allowed.
pub trait Park<T: Unpark> {
    /// Returns a token that can be used to unpark this thread.
    fn unpark_token(&self) -> T;

    /// Blocks the current thread until it is unparked using
    /// unpark token returned by `unpark_token` previously called from this thread.
    fn park(&self);
}

#[cfg(feature = "std")]
pub struct CurrentThread;

#[cfg(feature = "std")]
impl Park<Thread> for CurrentThread {
    #[inline]
    fn park(&self) {
        park();
    }

    #[inline]
    fn unpark_token(&self) -> Thread {
        current()
    }
}

#[derive(Clone, Copy)]
pub struct UnparkYield;

impl Unpark for UnparkYield {
    #[inline]
    fn unpark(&self) {}
}

pub struct ParkYield;

impl Park<UnparkYield> for ParkYield {
    #[inline]
    fn park(&self) {
        #[cfg(feature = "std")]
        yield_now();

        #[cfg(not(feature = "std"))]
        core::hint::spin_loop();
    }

    #[inline]
    fn unpark_token(&self) -> UnparkYield {
        UnparkYield
    }
}