use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use std::future::Future;
use std::pin::Pin;
use std::rc::Rc;
use std::sync::mpsc::{channel, Receiver, Sender};
use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
use std::thread;
use std::time::{Duration, Instant};
type BoxFuture = Pin<Box<dyn Future<Output = ()> + 'static>>;
static WAKER_VTABLE: RawWakerVTable =
RawWakerVTable::new(clone_raw, wake_raw, wake_by_ref_raw, drop_raw);
fn make_waker(id: usize, tx: Sender<usize>) -> Waker {
let data = Box::into_raw(Box::new((id, tx))) as *const ();
unsafe { Waker::from_raw(RawWaker::new(data, &WAKER_VTABLE)) }
}
unsafe fn clone_raw(data: *const ()) -> RawWaker {
let (id, tx) = &*(data as *const (usize, Sender<usize>));
let new = Box::into_raw(Box::new((*id, tx.clone()))) as *const ();
RawWaker::new(new, &WAKER_VTABLE)
}
unsafe fn wake_raw(data: *const ()) {
let (id, tx) = &*(data as *const (usize, Sender<usize>));
let _ = tx.send(*id);
}
unsafe fn wake_by_ref_raw(data: *const ()) {
let (id, tx) = &*(data as *const (usize, Sender<usize>));
let _ = tx.send(*id);
}
unsafe fn drop_raw(data: *const ()) {
drop(Box::from_raw(data as *mut (usize, Sender<usize>)));
}
struct Inner {
tx: Sender<usize>,
tasks: RefCell<HashMap<usize, Rc<RefCell<Option<BoxFuture>>>>>,
next_id: Cell<usize>,
}
impl Inner {
fn spawn<F: Future<Output = ()> + 'static>(&self, fut: F) -> usize {
let id = self.next_id.get();
self.next_id.set(id + 1);
self.tasks
.borrow_mut()
.insert(id, Rc::new(RefCell::new(Some(Box::pin(fut)))));
let _ = self.tx.send(id);
id
}
}
pub struct Runtime {
inner: Rc<Inner>,
rx: Receiver<usize>,
}
#[derive(Clone)]
pub struct Handle {
inner: Rc<Inner>,
}
impl Handle {
pub fn spawn<F: Future<Output = ()> + 'static>(&self, fut: F) -> usize {
self.inner.spawn(fut)
}
}
impl Runtime {
pub fn new() -> Self {
let (tx, rx) = channel();
let inner = Rc::new(Inner {
tx,
tasks: RefCell::new(HashMap::new()),
next_id: Cell::new(0),
});
Runtime { inner, rx }
}
pub fn handle(&self) -> Handle {
Handle {
inner: self.inner.clone(),
}
}
pub fn spawn<F: Future<Output = ()> + 'static>(&self, fut: F) -> usize {
self.inner.spawn(fut)
}
pub fn block_on<F: Future + 'static>(&self, fut: F) -> F::Output {
let result: Rc<RefCell<Option<F::Output>>> = Rc::new(RefCell::new(None));
let result2 = result.clone();
self.spawn(async move {
let out = fut.await;
*result2.borrow_mut() = Some(out);
});
self.run();
let x = result.borrow_mut().take().unwrap();
x
}
fn run(&self) {
loop {
if self.inner.tasks.borrow().is_empty() {
break;
}
let Ok(id) = self.rx.recv() else { break };
self.poll(id);
}
}
fn poll(&self, id: usize) {
let task = match self.inner.tasks.borrow().get(&id) {
Some(t) => t.clone(),
None => return,
};
let mut slot = task.borrow_mut();
let Some(mut fut) = slot.take() else { return };
let waker = make_waker(id, self.inner.tx.clone());
let mut cx = Context::from_waker(&waker);
match fut.as_mut().poll(&mut cx) {
Poll::Ready(()) => {
self.inner.tasks.borrow_mut().remove(&id);
}
Poll::Pending => {
*slot = Some(fut);
}
}
}
}
pub struct Sleep {
deadline: Option<Instant>,
spawned: bool,
dur: Duration,
}
impl Future for Sleep {
type Output = ();
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
if self.deadline.is_none() {
self.deadline = Some(Instant::now() + self.dur);
}
if Instant::now() >= self.deadline.unwrap() {
return Poll::Ready(());
}
if !self.spawned {
self.spawned = true;
let waker = cx.waker().clone();
let dur = self.dur;
thread::spawn(move || {
thread::sleep(dur);
waker.wake();
});
}
Poll::Pending
}
}
pub fn sleep(dur: Duration) -> Sleep {
Sleep {
deadline: None,
spawned: false,
dur,
}
}