wait_on_address 0.1.6

Cross-platform atomic wait and wake (aka futex) functionality.
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

#![doc = include_str!("../README.md")]
#![cfg_attr(
    all(nightly, target_arch = "wasm32"),
    feature(stdarch_wasm_atomic_wait)
)]

use std::{
    sync::atomic::{AtomicI32, AtomicI64, AtomicU32, AtomicU64},
    time::Duration,
};

#[cfg(any(target_os = "linux", target_os = "android"))]
#[path = "linux.rs"]
mod platform;

#[cfg(any(target_os = "macos", target_os = "ios", target_os = "watchos"))]
#[path = "macos.rs"]
mod platform;

#[cfg(windows)]
#[path = "windows.rs"]
mod platform;

#[cfg(target_os = "freebsd")]
#[path = "freebsd.rs"]
mod platform;

#[cfg(target_arch = "wasm32")]
#[path = "wasm32.rs"]
mod platform;

#[cfg(not(any(
    target_arch = "wasm32",
    target_os = "linux",
    target_os = "android",
    target_os = "freebsd",
    target_os = "macos",
    target_os = "ios",
    target_os = "watchos",
    windows
)))]
#[path = "fallback.rs"]
mod platform;

/// A table of OS synchronization primitives for manually
/// implementing futex functionality on unsupported platforms.
#[allow(unused)]
mod condvar_table;

/// A type that supports atomic waits.
pub trait AtomicWait: private::AtomicWaitImpl {
    /// If the value is `value`, wait until woken up.
    ///
    /// This function might also return spuriously,
    /// without a corresponding wake operation.
    fn wait(&self, value: Self::AtomicInner) {
        private::AtomicWaitImpl::wait_timeout(self, value, None);
    }

    /// If the value is `value`, wait until timeout elapses
    /// or notify is called.
    ///
    /// This function might also return spuriously,
    /// without a corresponding wake operation.
    fn wait_timeout(&self, value: Self::AtomicInner, timeout: Duration) {
        private::AtomicWaitImpl::wait_timeout(self, value, Some(timeout));
    }

    /// Wake one thread that is waiting on this atomic.
    fn notify_one(&self) {
        private::AtomicWaitImpl::notify_one(self);
    }

    /// Wake all threads that are waiting on this atomic.
    fn notify_all(&self) {
        private::AtomicWaitImpl::notify_all(self);
    }
}

impl AtomicWait for AtomicU32 {}
impl AtomicWait for AtomicU64 {}
impl AtomicWait for AtomicI32 {}
impl AtomicWait for AtomicI64 {}

impl private::AtomicWaitImpl for AtomicI32 {
    type AtomicInner = i32;

    fn notify_all(&self) {
        unsafe {
            private::AtomicWaitImpl::notify_all(std::mem::transmute::<&AtomicI32, &AtomicU32>(
                self,
            ));
        }
    }

    fn notify_one(&self) {
        unsafe {
            private::AtomicWaitImpl::notify_one(std::mem::transmute::<&AtomicI32, &AtomicU32>(
                self,
            ));
        }
    }

    fn wait_timeout(&self, value: Self::AtomicInner, timeout: Option<Duration>) {
        unsafe {
            private::AtomicWaitImpl::wait_timeout(
                std::mem::transmute::<&AtomicI32, &AtomicU32>(self),
                value as u32,
                timeout,
            );
        }
    }
}

impl private::AtomicWaitImpl for AtomicI64 {
    type AtomicInner = i64;

    fn notify_all(&self) {
        unsafe {
            private::AtomicWaitImpl::notify_all(std::mem::transmute::<&AtomicI64, &AtomicU64>(
                self,
            ));
        }
    }

    fn notify_one(&self) {
        unsafe {
            private::AtomicWaitImpl::notify_one(std::mem::transmute::<&AtomicI64, &AtomicU64>(
                self,
            ));
        }
    }

    fn wait_timeout(&self, value: Self::AtomicInner, timeout: Option<Duration>) {
        unsafe {
            private::AtomicWaitImpl::wait_timeout(
                std::mem::transmute::<&AtomicI64, &AtomicU64>(self),
                value as u64,
                timeout,
            );
        }
    }
}

/// Private implementation details.
mod private {
    use std::time::Duration;

    /// A trait that cannot be implemented by other crates.
    pub trait AtomicWaitImpl {
        /// The underlying integer type for the atomic.
        type AtomicInner;

        /// Wake all threads that are waiting on this atomic.
        fn notify_all(&self);

        /// Wake one thread that is waiting on this atomic.
        fn notify_one(&self);

        /// If the value is `value`, wait until woken up.
        ///
        /// This function might also return spuriously,
        /// without a corresponding wake operation.
        fn wait_timeout(&self, value: Self::AtomicInner, timeout: Option<Duration>);
    }
}