use crate::task::error::TaskResult;
use crate::task::id::TaskId;
use std::future::Future;
use std::panic::{AssertUnwindSafe, catch_unwind};
use std::pin::Pin;
use std::sync::Arc;
use std::sync::Mutex;
use std::sync::atomic::{AtomicU64, Ordering};
use std::task::{Context, Poll, Wake, Waker};
pub(super) type ErasedOutput = Box<dyn std::any::Any + Send>;
pub(super) type ErasedFuture = Pin<Box<dyn Future<Output = ErasedOutput> + Send>>;
const IDLE: u64 = 0;
const SCHEDULED: u64 = 1 << 0;
const RUNNING: u64 = 1 << 1;
const COMPLETED: u64 = 1 << 2;
pub(super) struct TaskCell {
id: TaskId,
state: AtomicU64,
future: Mutex<Option<ErasedFuture>>,
result_sender: crossbeam_channel::Sender<TaskResult>,
queue_sender: crossbeam_channel::Sender<Arc<TaskCell>>,
}
impl TaskCell {
pub(super) fn new(
id: TaskId,
future: ErasedFuture,
result_sender: crossbeam_channel::Sender<TaskResult>,
queue_sender: crossbeam_channel::Sender<Arc<TaskCell>>,
) -> Self {
Self {
id,
state: AtomicU64::new(SCHEDULED),
future: Mutex::new(Some(future)),
result_sender,
queue_sender,
}
}
pub(super) fn id(&self) -> TaskId {
self.id
}
pub(super) fn wake(self: &Arc<Self>) {
let prev = self.state.fetch_or(SCHEDULED, Ordering::AcqRel);
if prev == IDLE {
self.enqueue();
}
}
pub(super) fn run_once(self: &Arc<Self>) -> bool {
loop {
let state = self.state.load(Ordering::Acquire);
if state & COMPLETED != 0 {
return true;
}
let claimed = (state | RUNNING) & !SCHEDULED;
match self.state.compare_exchange_weak(
state,
claimed,
Ordering::AcqRel,
Ordering::Acquire,
) {
Ok(_) => break,
Err(_) => continue,
}
}
let waker = Waker::from(Arc::new(TaskWaker {
cell: Arc::downgrade(self),
}));
let mut cx = Context::from_waker(&waker);
let mut future_guard = self.future.lock().expect("task future mutex poisoned");
let result = match future_guard.as_mut() {
Some(future) => catch_unwind(AssertUnwindSafe(|| future.as_mut().poll(&mut cx))),
None => return true,
};
match result {
Ok(Poll::Ready(output)) => {
future_guard.take();
drop(future_guard);
self.complete(TaskResult::Ok(output));
true
}
Err(panic_payload) => {
future_guard.take();
drop(future_guard);
let msg = panic_message(&*panic_payload);
self.complete(TaskResult::Panic(msg));
true
}
Ok(Poll::Pending) => {
drop(future_guard);
loop {
let state = self.state.load(Ordering::Acquire);
if state & COMPLETED != 0 {
return true;
}
let next = state & !RUNNING;
match self.state.compare_exchange_weak(
state,
next,
Ordering::AcqRel,
Ordering::Acquire,
) {
Ok(_) => {
if next & SCHEDULED != 0 {
self.enqueue();
}
return false;
}
Err(_) => continue,
}
}
}
}
}
fn complete(&self, result: TaskResult) {
loop {
let state = self.state.load(Ordering::Acquire);
if state & COMPLETED != 0 {
return;
}
match self.state.compare_exchange_weak(
state,
COMPLETED,
Ordering::AcqRel,
Ordering::Acquire,
) {
Ok(_) => {
let _ = self.result_sender.try_send(result);
return;
}
Err(_) => continue,
}
}
}
pub(super) fn sweep(&self) {
loop {
let state = self.state.load(Ordering::Acquire);
if state & COMPLETED != 0 {
return;
}
match self.state.compare_exchange_weak(
state,
COMPLETED,
Ordering::AcqRel,
Ordering::Acquire,
) {
Ok(_) => {
let _ = self.result_sender.try_send(TaskResult::Shutdown);
return;
}
Err(_) => continue,
}
}
}
pub(super) fn enqueue(self: &Arc<Self>) {
let _ = self.queue_sender.send(self.clone());
}
}
fn panic_message(payload: &(dyn std::any::Any + Send)) -> String {
if let Some(s) = payload.downcast_ref::<&str>() {
(*s).to_string()
} else if let Some(s) = payload.downcast_ref::<String>() {
s.clone()
} else {
"Unknown panic".to_string()
}
}
struct TaskWaker {
cell: std::sync::Weak<TaskCell>,
}
impl Wake for TaskWaker {
fn wake(self: Arc<Self>) {
self.wake_by_ref();
}
fn wake_by_ref(self: &Arc<Self>) {
if let Some(cell) = self.cell.upgrade() {
cell.wake();
}
}
}