mfio 0.1.0

Flexible completion I/O primitives
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

use core::sync::atomic::{AtomicU8, Ordering};
use core::task::{RawWaker, RawWakerVTable, Waker};

use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle, RawHandle};
use tarc::{Arc, BaseArc};

use windows_sys::Win32::System::Threading::{CreateEventA, ResetEvent, SetEvent};

#[repr(transparent)]
pub struct EventWakerOwner(EventWaker);

impl Drop for EventWakerOwner {
    fn drop(&mut self) {
        self.0.close()
    }
}

impl EventWakerOwner {
    pub fn new() -> Option<Self> {
        let handle = unsafe { CreateEventA(core::ptr::null(), 1, 0, core::ptr::null()) };

        let handle = if handle == 0 {
            return None;
        } else {
            unsafe { OwnedHandle::from_raw_handle(handle as _) }
        };

        Some(Self(EventWaker(
            BaseArc::new(EventWakerInner {
                handle,
                flags: Default::default(),
            })
            .into_raw(),
        )))
    }

    pub fn clear(&self) -> Option<()> {
        let inner = unsafe { &*self.0 .0 };
        if unsafe { ResetEvent(inner.handle.as_raw_handle() as _) } != 0 {
            Some(())
        } else {
            None
        }
    }
}

impl core::ops::Deref for EventWakerOwner {
    type Target = EventWaker;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

/// An Event backed waker.
///
/// This waker simply signals an event handle, which can be awaited for externally.
#[repr(transparent)]
pub struct EventWaker(*const EventWakerInner);

unsafe impl Send for EventWaker {}
unsafe impl Sync for EventWaker {}

impl Clone for EventWaker {
    fn clone(&self) -> Self {
        unsafe {
            BaseArc::increment_strong_count(self.0);
        }
        Self(self.0)
    }
}

impl Drop for EventWaker {
    fn drop(&mut self) {
        unsafe {
            BaseArc::decrement_strong_count(self.0);
        }
    }
}

impl EventWaker {
    pub fn flags(&self) -> Arc<AtomicU8> {
        unsafe {
            BaseArc::increment_strong_count(self.0);
        }
        unsafe { BaseArc::from_raw(self.0) }.transpose()
    }

    pub fn wake_by_ref(&self) {
        let inner = unsafe { &*self.0 };
        let flags = inner.flags.fetch_or(0b1, Ordering::AcqRel);
        log::trace!("Flags {flags:b}");
        if flags & 0b111 == 0 {
            let ret = unsafe { SetEvent(inner.handle.as_raw_handle() as _) };
            assert_ne!(0, ret);
        }
    }

    pub fn close(&self) {
        let inner = unsafe { &*self.0 };
        inner.flags.fetch_or(0b100, Ordering::AcqRel);
    }

    pub fn into_raw_waker(self) -> RawWaker {
        let data: *const () = unsafe { core::mem::transmute(self) };
        let vtbl = &RawWakerVTable::new(
            Self::raw_clone,
            Self::raw_wake,
            Self::raw_wake_by_ref,
            Self::raw_drop,
        );
        RawWaker::new(data, vtbl)
    }

    pub fn into_waker(self) -> Waker {
        unsafe { Waker::from_raw(self.into_raw_waker()) }
    }

    unsafe fn raw_wake(data: *const ()) {
        let waker = core::ptr::read((&data as *const _) as *const Self);
        waker.wake_by_ref()
    }

    unsafe fn raw_wake_by_ref(data: *const ()) {
        let waker: &Self = &*((&data as *const _) as *const Self);
        waker.wake_by_ref()
    }

    unsafe fn raw_clone(data: *const ()) -> RawWaker {
        let waker: &Self = &*((&data as *const _) as *const Self);
        waker.clone().into_raw_waker()
    }

    unsafe fn raw_drop(data: *const ()) {
        core::ptr::drop_in_place((&data as *const _) as *const Self as *mut Self)
    }
}

impl AsRawHandle for EventWaker {
    fn as_raw_handle(&self) -> RawHandle {
        unsafe { &*self.0 }.handle.as_raw_handle()
    }
}

struct EventWakerInner {
    handle: OwnedHandle,
    flags: AtomicU8,
}

impl AsRef<AtomicU8> for EventWakerInner {
    fn as_ref(&self) -> &AtomicU8 {
        &self.flags
    }
}