bysyncify 0.2.6

Bindings and a high-level interface to Binaryen's Asyncify
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

#![no_std]

use core::{
    cell::UnsafeCell,
    future::Future,
    hint::unreachable_unchecked,
    marker::PhantomData,
    mem::MaybeUninit,
    pin::Pin,
    sync::atomic::AtomicBool,
    task::{Context, Poll, Waker},
};

use atomic_waker::AtomicWaker;
// use waker_fn::waker_fn;

#[repr(C)]
pub struct RawStack {
    pub start: *mut u8,
    pub end: *mut u8,
}

#[link(wasm_import_module = "asyncify")]
unsafe extern "C" {
    pub unsafe fn start_unwind(stack: *mut RawStack);
    pub unsafe fn stop_unwind();
    pub unsafe fn start_rewind(stack: *mut RawStack);
    pub unsafe fn stop_rewind();
    pub unsafe fn get_state() -> u32;
}

pub struct RawCore {
    waker: AtomicWaker,
    pub stack: UnsafeCell<RawStack>,
    needs_rewind: AtomicBool,
}

impl RawCore {
    #[inline(never)]
    pub unsafe fn poll<T, U>(
        &self,
        cx: &mut Context,
        go: fn(&MaybeUninit<U>) -> MaybeUninit<T>,
        state: MaybeUninit<U>,
    ) -> Poll<T> {
        self.waker.register(cx.waker());
        let mut r = false;
        unsafe {
            if self
                .needs_rewind
                .swap(false, core::sync::atomic::Ordering::SeqCst)
            {
                r = true;
                start_rewind(core::mem::transmute(self.stack.get()));
            }
            let v = go(&state);
            match get_state() {
                0 => {
                    return Poll::Ready(v.assume_init());
                }
                1 => {
                    stop_unwind();
                    self.needs_rewind
                        .store(true, core::sync::atomic::Ordering::SeqCst);
                    return Poll::Pending;
                }
                _ => unreachable_unchecked(),
            }
        }
    }
    #[inline(never)]
    fn embed_internal<T>(
        &self,
        mut fut: Pin<&mut (dyn Future<Output = T> + '_)>,
    ) -> MaybeUninit<T> {
        unsafe {
            let w = &self.waker;
            loop {
                let w = w.clone();
                match get_state() {
                    0 => match fut.as_mut().poll(&mut Context::from_waker(&match w.take() {
                        Some(w) => w,
                        None => Waker::noop().clone(),
                    })) {
                        Poll::Ready(a) => {
                            return MaybeUninit::new(a);
                        }
                        Poll::Pending => {
                            start_unwind(core::mem::transmute(self.stack.get()));
                            return MaybeUninit::uninit();
                        }
                    },
                    2 => {
                        stop_rewind();
                    }
                    _ => unreachable_unchecked(),
                }
            }
        }
    }
    pub fn embed<T>(&self, mut fut: Pin<&mut (dyn Future<Output = T> + '_)>) -> T {
        unsafe { self.embed_internal(fut).assume_init() }
    }
}
impl awaiter_trait::Awaiter for RawCore{
    fn r#await<T>(&self, f: Pin<&mut dyn Future<Output = T>>) -> T {
        self.embed(f)
    }
}
awaiter_trait::autoimpl!(<> RawCore as Awaiter);
impl awaiter_trait_02::Awaiter for RawCore{
    fn r#await<T>(&self, f: Pin<&mut (dyn Future<Output = T> + '_)>) -> T {
        self.embed(f)
    }
}
awaiter_trait_02::autoimpl!(<> RawCore as Awaiter);
pub struct RawCoroutine<U, T> {
    raw: *const RawCore,
    state: MaybeUninit<MaybeUninit<U>>,
    r#fn: fn(&MaybeUninit<U>) -> MaybeUninit<T>,
}
pub unsafe fn raw_cor_base<F, T>(raw: *const RawCore, f: F, r#fn: fn(&MaybeUninit<F>) -> MaybeUninit<T>) -> RawCoroutine<F, T> {
    RawCoroutine {
        raw,
        state: MaybeUninit::new(MaybeUninit::new(f)),
        r#fn,
    }
}
impl<U, T> Future for RawCoroutine<U, T> {
    type Output = T;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        unsafe {
            self.raw
                .as_ref()
                .unwrap()
                .poll(cx, self.r#fn, self.state.assume_init_read())
        }
    }
}
unsafe impl<U: Send, T> Send for RawCoroutine<U, T> {}
unsafe impl<U: Sync, T> Sync for RawCoroutine<U, T> {}

#[cfg(feature = "alloc")]
extern crate alloc;
#[cfg(feature = "alloc")]
pub mod alloc_support;
#[cfg(feature = "alloc")]
pub use alloc_support::*;