minimal-executor 0.4.1

A minimal executor for asynchronous tasks based on the futures-rs library.
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

use core::mem::ManuallyDrop;
use core::sync::atomic::{AtomicBool, Ordering};
use futures::task::WakerRef;
use core::task::{Waker, RawWaker, RawWakerVTable};

#[allow(dead_code)]
#[derive(Debug)]
pub struct SingleWake {
    woken: AtomicBool,
}

#[allow(dead_code)]
impl SingleWake {
    pub fn new() -> Self {
        Self {
            woken: Default::default()
        }
    }
    pub fn read_reset(&self) -> bool {
        self.woken.fetch_and(false, Ordering::Relaxed)
    }
}

impl SimpleWaker for SingleWake {
    fn wake(&self) {
        self.woken.store(true, Ordering::Relaxed)
    }
}

pub struct AlwaysWake {}

impl AlwaysWake {
    pub const INSTANCE: AlwaysWake = Self::new();
    pub const fn new() -> Self {
        Self {}
    }
}

impl SimpleWaker for AlwaysWake {
    fn wake(&self) {}
}

pub(super) trait SimpleWaker {
    fn wake(&self);
}

/// Creates a reference to a [`Waker`] from a reference to `Arc<impl ArcWake>`.
///
/// The resulting [`Waker`] will call
/// [`ArcWake.wake()`](ArcWake::wake) if awoken.
#[inline]
pub(crate) fn waker_ref<W>(wake: &W) -> WakerRef<'_>
    where
        W: SimpleWaker,
{
    let ptr = (wake as *const W) as *const ();

    let waker =
        ManuallyDrop::new(unsafe { Waker::from_raw(RawWaker::new(ptr, waker_vtable::<W>())) });
    WakerRef::new_unowned(waker)
}

pub(super) fn waker_vtable<W: SimpleWaker>() -> &'static RawWakerVTable {
    &RawWakerVTable::new(
        copy_ref_raw::<W>,
        wake_raw::<W>,
        wake_by_ref_raw::<W>,
        drop_raw::<W>,
    )
}


unsafe fn copy_ref_raw<T: SimpleWaker>(data: *const ()) -> RawWaker {
    RawWaker::new(data, waker_vtable::<T>())
}

unsafe fn wake_raw<T: SimpleWaker>(data: *const ()) {
    let data = core::ptr::read(data as *const T);
    SimpleWaker::wake(&data);
    drop(data)
}

unsafe fn wake_by_ref_raw<T: SimpleWaker>(data: *const ()) {
    let data = &*(data as *const T);
    SimpleWaker::wake(data);
}

unsafe fn drop_raw<T: SimpleWaker>(data: *const ()) {
    let data = core::ptr::read(data as *const T);
    drop(data)
}