#![deny(missing_docs)]
use std::cell::RefCell;
use std::collections::VecDeque;
use std::future::Future;
use std::pin::Pin;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
type BoxFut = Pin<Box<dyn Future<Output = ()> + Send>>;
struct Task {
fut: Mutex<Option<BoxFut>>,
queue: Arc<Mutex<VecDeque<Arc<Task>>>>,
queued: AtomicBool,
}
impl Task {
fn schedule(self: &Arc<Self>) {
if !self.queued.swap(true, Ordering::AcqRel) {
self.queue.lock().unwrap().push_back(self.clone());
}
}
}
static VT: RawWakerVTable = RawWakerVTable::new(clone_raw, wake_raw, wake_by_ref_raw, drop_raw);
fn raw(p: *const ()) -> RawWaker {
RawWaker::new(p, &VT)
}
unsafe fn clone_raw(p: *const ()) -> RawWaker {
let arc = Arc::from_raw(p as *const Task);
let cloned = arc.clone();
std::mem::forget(arc); raw(Arc::into_raw(cloned) as *const ())
}
unsafe fn wake_raw(p: *const ()) {
let arc = Arc::from_raw(p as *const Task);
arc.schedule();
}
unsafe fn wake_by_ref_raw(p: *const ()) {
let arc = Arc::from_raw(p as *const Task);
arc.schedule();
std::mem::forget(arc); }
unsafe fn drop_raw(p: *const ()) {
drop(Arc::from_raw(p as *const Task));
}
fn waker_of(task: Arc<Task>) -> Waker {
unsafe { Waker::from_raw(raw(Arc::into_raw(task) as *const ())) }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Cond {
AtTick(u64),
Event(u64),
}
struct Signal {
inner: Mutex<SignalInner>,
}
struct SignalInner {
fired: Option<u64>, waker: Option<Waker>,
}
impl Signal {
fn new() -> Arc<Self> {
Arc::new(Signal {
inner: Mutex::new(SignalInner {
fired: None,
waker: None,
}),
})
}
}
struct Parked {
cond: Cond,
signal: Arc<Signal>,
}
pub struct Reactor {
tick: u64,
parked: Vec<Parked>,
}
impl Reactor {
fn new() -> Self {
Reactor {
tick: 0,
parked: Vec::new(),
}
}
#[must_use = "the returned wakers must be woken after the reactor lock is dropped"]
pub fn advance(&mut self, tick: u64, events: &[u64]) -> Vec<Waker> {
self.tick = tick;
let mut survivors = Vec::with_capacity(self.parked.len());
let mut wakers = Vec::new();
for p in self.parked.drain(..) {
let hit = match p.cond {
Cond::AtTick(t) => tick >= t,
Cond::Event(id) => events.contains(&id),
};
if hit {
let waker = {
let mut g = p.signal.inner.lock().unwrap();
g.fired = Some(tick);
g.waker.take()
};
if let Some(w) = waker {
wakers.push(w);
}
} else {
survivors.push(p);
}
}
self.parked = survivors;
wakers
}
#[must_use]
pub fn tick(&self) -> u64 {
self.tick
}
}
struct Ctx {
queue: Arc<Mutex<VecDeque<Arc<Task>>>>,
reactor: Arc<Mutex<Reactor>>,
}
thread_local! {
static CTX: RefCell<Option<Ctx>> = const { RefCell::new(None) };
}
fn with_ctx<R>(f: impl FnOnce(&Ctx) -> R) -> R {
CTX.with(|c| {
let b = c.borrow();
let ctx = b
.as_ref()
.expect("vixitic: called outside Runtime::block_on / Runtime::step");
f(ctx)
})
}
pub struct Await {
cond: Cond,
signal: Arc<Signal>,
reactor: Arc<Mutex<Reactor>>,
registered: bool,
}
impl Future for Await {
type Output = u64;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<u64> {
let me = self.get_mut();
let mut g = me.signal.inner.lock().unwrap();
if let Some(tick) = g.fired {
return Poll::Ready(tick);
}
g.waker = Some(cx.waker().clone());
drop(g);
if !me.registered {
me.registered = true;
me.reactor.lock().unwrap().parked.push(Parked {
cond: me.cond,
signal: me.signal.clone(),
});
}
Poll::Pending
}
}
fn park(cond: Cond) -> Await {
with_ctx(|ctx| Await {
cond,
signal: Signal::new(),
reactor: ctx.reactor.clone(),
registered: false,
})
}
pub fn await_event(id: u64) -> Await {
park(Cond::Event(id))
}
pub fn sleep_ticks(n: u64) -> Await {
let now = with_ctx(|ctx| ctx.reactor.lock().unwrap().tick);
park(Cond::AtTick(now + n))
}
fn make_task(fut: BoxFut, queue: &Arc<Mutex<VecDeque<Arc<Task>>>>) -> Arc<Task> {
let t = Arc::new(Task {
fut: Mutex::new(Some(fut)),
queue: queue.clone(),
queued: AtomicBool::new(false),
});
t.schedule();
t
}
pub fn spawn<F: Future<Output = ()> + Send + 'static>(fut: F) {
with_ctx(|ctx| {
make_task(Box::pin(fut), &ctx.queue);
});
}
pub struct Runtime {
queue: Arc<Mutex<VecDeque<Arc<Task>>>>,
reactor: Arc<Mutex<Reactor>>,
}
impl Default for Runtime {
fn default() -> Self {
Self::new()
}
}
impl Runtime {
#[must_use]
pub fn new() -> Self {
Runtime {
queue: Arc::new(Mutex::new(VecDeque::new())),
reactor: Arc::new(Mutex::new(Reactor::new())),
}
}
pub fn block_on<F, T, E>(&self, root: F, mut engine: E, max_tick: u64) -> T
where
F: Future<Output = T> + Send + 'static,
T: Send + 'static,
E: FnMut(u64) -> Vec<u64>,
{
let out: Arc<Mutex<Option<T>>> = Arc::new(Mutex::new(None));
let out2 = out.clone();
let root_fut: BoxFut = Box::pin(async move {
let v = root.await;
*out2.lock().unwrap() = Some(v);
});
CTX.with(|c| {
*c.borrow_mut() = Some(Ctx {
queue: self.queue.clone(),
reactor: self.reactor.clone(),
});
});
make_task(root_fut, &self.queue);
let mut tick = 0u64;
loop {
drain(&self.queue);
if out.lock().unwrap().is_some() {
break;
}
if tick >= max_tick {
CTX.with(|c| *c.borrow_mut() = None);
panic!(
"vixitic: root future stalled past max_tick={max_tick} — a Cond never fired (deadlocked reactor)"
);
}
tick += 1;
let events = engine(tick);
let wakers = self.reactor.lock().unwrap().advance(tick, &events);
for w in wakers {
w.wake();
}
}
CTX.with(|c| *c.borrow_mut() = None);
let result = out.lock().unwrap().take().expect("root completed");
result
}
pub fn spawn_on<F: Future<Output = ()> + Send + 'static>(&self, fut: F) {
make_task(Box::pin(fut), &self.queue);
}
pub fn step<E: FnMut(u64) -> Vec<u64>>(&self, mut engine: E) -> u64 {
CTX.with(|c| {
*c.borrow_mut() = Some(Ctx {
queue: self.queue.clone(),
reactor: self.reactor.clone(),
});
});
drain(&self.queue);
let tick = self.reactor.lock().unwrap().tick + 1;
let events = engine(tick);
let wakers = self.reactor.lock().unwrap().advance(tick, &events);
for w in wakers {
w.wake();
}
drain(&self.queue);
CTX.with(|c| *c.borrow_mut() = None);
tick
}
#[must_use]
pub fn tick(&self) -> u64 {
self.reactor.lock().unwrap().tick
}
}
fn drain(queue: &Arc<Mutex<VecDeque<Arc<Task>>>>) {
loop {
let next = queue.lock().unwrap().pop_front();
match next {
Some(task) => poll_task(task),
None => break,
}
}
}
fn poll_task(task: Arc<Task>) {
task.queued.store(false, Ordering::Release);
let mut slot = task.fut.lock().unwrap();
if let Some(mut fut) = slot.take() {
let waker = waker_of(task.clone());
let mut cx = Context::from_waker(&waker);
match fut.as_mut().poll(&mut cx) {
Poll::Pending => *slot = Some(fut),
Poll::Ready(()) => {}
}
}
}