1 // Copyright 2018 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 #![unstable(feature = "futures_api",
12 reason = "futures in libcore are unstable",
19 /// A `Waker` is a handle for waking up a task by notifying its executor that it
20 /// is ready to be run.
22 /// This handle contains a trait object pointing to an instance of the `UnsafeWake`
23 /// trait, allowing notifications to get routed through it.
26 inner: NonNull<dyn UnsafeWake>,
29 impl Unpin for Waker {}
30 unsafe impl Send for Waker {}
31 unsafe impl Sync for Waker {}
34 /// Constructs a new `Waker` directly.
36 /// Note that most code will not need to call this. Implementers of the
37 /// `UnsafeWake` trait will typically provide a wrapper that calls this
38 /// but you otherwise shouldn't call it directly.
40 /// If you're working with the standard library then it's recommended to
41 /// use the `Waker::from` function instead which works with the safe
42 /// `Arc` type and the safe `Wake` trait.
44 pub unsafe fn new(inner: NonNull<dyn UnsafeWake>) -> Self {
48 /// Wake up the task associated with this `Waker`.
51 unsafe { self.inner.as_ref().wake() }
54 /// Returns whether or not this `Waker` and `other` awaken the same task.
56 /// This function works on a best-effort basis, and may return false even
57 /// when the `Waker`s would awaken the same task. However, if this function
58 /// returns true, it is guaranteed that the `Waker`s will awaken the same
61 /// This function is primarily used for optimization purposes.
63 pub fn will_wake(&self, other: &Waker) -> bool {
64 self.inner == other.inner
67 /// Returns whether or not this `Waker` and `other` `LocalWaker` awaken
70 /// This function works on a best-effort basis, and may return false even
71 /// when the `Waker`s would awaken the same task. However, if this function
72 /// returns true, it is guaranteed that the `Waker`s will awaken the same
75 /// This function is primarily used for optimization purposes.
77 pub fn will_wake_local(&self, other: &LocalWaker) -> bool {
78 self.will_wake(&other.0)
82 impl Clone for Waker {
84 fn clone(&self) -> Self {
86 self.inner.as_ref().clone_raw()
91 impl fmt::Debug for Waker {
92 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
93 f.debug_struct("Waker")
102 self.inner.as_ref().drop_raw()
107 /// A `LocalWaker` is a handle for waking up a task by notifying its executor that it
108 /// is ready to be run.
110 /// This is similar to the `Waker` type, but cannot be sent across threads.
111 /// Task executors can use this type to implement more optimized singlethreaded wakeup
115 pub struct LocalWaker(Waker);
117 impl Unpin for LocalWaker {}
118 impl !Send for LocalWaker {}
119 impl !Sync for LocalWaker {}
122 /// Constructs a new `LocalWaker` directly.
124 /// Note that most code will not need to call this. Implementers of the
125 /// `UnsafeWake` trait will typically provide a wrapper that calls this
126 /// but you otherwise shouldn't call it directly.
128 /// If you're working with the standard library then it's recommended to
129 /// use the `local_waker_from_nonlocal` or `local_waker` to convert a `Waker`
130 /// into a `LocalWaker`.
132 /// For this function to be used safely, it must be sound to call `inner.wake_local()`
133 /// on the current thread.
135 pub unsafe fn new(inner: NonNull<dyn UnsafeWake>) -> Self {
136 LocalWaker(Waker::new(inner))
139 /// Borrows this `LocalWaker` as a `Waker`.
141 /// `Waker` is nearly identical to `LocalWaker`, but is threadsafe
142 /// (implements `Send` and `Sync`).
144 pub fn as_waker(&self) -> &Waker {
148 /// Converts this `LocalWaker` into a `Waker`.
150 /// `Waker` is nearly identical to `LocalWaker`, but is threadsafe
151 /// (implements `Send` and `Sync`).
153 pub fn into_waker(self) -> Waker {
157 /// Wake up the task associated with this `LocalWaker`.
160 unsafe { self.0.inner.as_ref().wake_local() }
163 /// Returns whether or not this `LocalWaker` and `other` `LocalWaker` awaken the same task.
165 /// This function works on a best-effort basis, and may return false even
166 /// when the `LocalWaker`s would awaken the same task. However, if this function
167 /// returns true, it is guaranteed that the `LocalWaker`s will awaken the same
170 /// This function is primarily used for optimization purposes.
172 pub fn will_wake(&self, other: &LocalWaker) -> bool {
173 self.0.will_wake(&other.0)
176 /// Returns whether or not this `LocalWaker` and `other` `Waker` awaken the same task.
178 /// This function works on a best-effort basis, and may return false even
179 /// when the `Waker`s would awaken the same task. However, if this function
180 /// returns true, it is guaranteed that the `LocalWaker`s will awaken the same
183 /// This function is primarily used for optimization purposes.
185 pub fn will_wake_nonlocal(&self, other: &Waker) -> bool {
186 self.0.will_wake(other)
190 impl From<LocalWaker> for Waker {
192 fn from(local_waker: LocalWaker) -> Self {
197 impl fmt::Debug for LocalWaker {
198 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
199 f.debug_struct("LocalWaker")
204 /// An unsafe trait for implementing custom memory management for a `Waker` or `LocalWaker`.
206 /// A `Waker` conceptually is a cloneable trait object for `Wake`, and is
207 /// most often essentially just `Arc<dyn Wake>`. However, in some contexts
208 /// (particularly `no_std`), it's desirable to avoid `Arc` in favor of some
209 /// custom memory management strategy. This trait is designed to allow for such
212 /// When using `std`, a default implementation of the `UnsafeWake` trait is provided for
213 /// `Arc<T>` where `T: Wake`.
214 pub unsafe trait UnsafeWake: Send + Sync {
215 /// Creates a clone of this `UnsafeWake` and stores it behind a `Waker`.
217 /// This function will create a new uniquely owned handle that under the
218 /// hood references the same notification instance. In other words calls
219 /// to `wake` on the returned handle should be equivalent to calls to
220 /// `wake` on this handle.
224 /// This function is unsafe to call because it's asserting the `UnsafeWake`
225 /// value is in a consistent state, i.e. hasn't been dropped.
226 unsafe fn clone_raw(&self) -> Waker;
228 /// Drops this instance of `UnsafeWake`, deallocating resources
229 /// associated with it.
232 /// This method is intended to have a signature such as:
234 /// ```ignore (not-a-doctest)
235 /// fn drop_raw(self: *mut Self);
238 /// Unfortunately in Rust today that signature is not object safe.
239 /// Nevertheless it's recommended to implement this function *as if* that
240 /// were its signature. As such it is not safe to call on an invalid
241 /// pointer, nor is the validity of the pointer guaranteed after this
242 /// function returns.
246 /// This function is unsafe to call because it's asserting the `UnsafeWake`
247 /// value is in a consistent state, i.e. hasn't been dropped.
248 unsafe fn drop_raw(&self);
250 /// Indicates that the associated task is ready to make progress and should
253 /// Executors generally maintain a queue of "ready" tasks; `wake` should place
254 /// the associated task onto this queue.
258 /// Implementations should avoid panicking, but clients should also be prepared
263 /// This function is unsafe to call because it's asserting the `UnsafeWake`
264 /// value is in a consistent state, i.e. hasn't been dropped.
265 unsafe fn wake(&self);
267 /// Indicates that the associated task is ready to make progress and should
268 /// be `poll`ed. This function is the same as `wake`, but can only be called
269 /// from the thread that this `UnsafeWake` is "local" to. This allows for
270 /// implementors to provide specialized wakeup behavior specific to the current
271 /// thread. This function is called by `LocalWaker::wake`.
273 /// Executors generally maintain a queue of "ready" tasks; `wake_local` should place
274 /// the associated task onto this queue.
278 /// Implementations should avoid panicking, but clients should also be prepared
283 /// This function is unsafe to call because it's asserting the `UnsafeWake`
284 /// value is in a consistent state, i.e. hasn't been dropped, and that the
285 /// `UnsafeWake` hasn't moved from the thread on which it was created.
286 unsafe fn wake_local(&self) {