pub use crate::scheduler::TaskId;
use crate::scheduler::{self, BlockOutcome};
use core::cell::UnsafeCell;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Timeout;
impl core::fmt::Display for Timeout {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "wait timed out")
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum WakeReason {
Woken,
Timeout,
}
pub fn park(deadline: Option<u64>) -> WakeReason {
let me = scheduler::current_task_id();
let d = deadline.unwrap_or(0);
loop {
match scheduler::block_until_tick_if(me, d, || unsafe {
scheduler::take_wake_flag_locked()
}) {
BlockOutcome::Ready => return WakeReason::Woken,
BlockOutcome::Blocked => {}
BlockOutcome::AlreadyPast => return WakeReason::Timeout,
BlockOutcome::NoCurrentTask => return WakeReason::Timeout,
}
}
}
pub fn wake(id: TaskId) {
scheduler::wake_task(id.raw());
}
pub fn wait_until(mut ready: impl FnMut() -> bool, deadline_tick: u64) -> Result<(), Timeout> {
while !ready() {
if scheduler::tick_count() >= deadline_tick {
return Err(Timeout);
}
scheduler::yield_now();
}
Ok(())
}
pub struct Signal {
set: UnsafeCell<bool>,
waiter: UnsafeCell<u32>,
}
unsafe impl Sync for Signal {}
impl Default for Signal {
fn default() -> Self {
Self::new()
}
}
impl Signal {
pub const fn new() -> Self {
Signal {
set: UnsafeCell::new(false),
waiter: UnsafeCell::new(0),
}
}
pub fn set(&self) {
let waiter = {
let g = crate::critical::enter();
unsafe { *self.set.get() = true };
let id = unsafe { *self.waiter.get() };
unsafe { *self.waiter.get() = 0 };
drop(g);
id
};
if waiter != 0 {
scheduler::wake_task(waiter);
}
}
pub fn try_take(&self) -> bool {
let g = crate::critical::enter();
let was = unsafe { *self.set.get() };
unsafe { *self.set.get() = false };
drop(g);
was
}
pub fn is_set(&self) -> bool {
let g = crate::critical::enter();
let v = unsafe { *self.set.get() };
drop(g);
v
}
pub fn wait(&self, deadline: Option<u64>) -> Result<(), Timeout> {
let me = scheduler::current_task_id();
let d = deadline.unwrap_or(0);
loop {
let outcome = scheduler::block_until_tick_if(me, d, || unsafe {
if *self.set.get() {
*self.set.get() = false;
true
} else {
*self.waiter.get() = me;
false
}
});
match outcome {
BlockOutcome::Ready => return Ok(()),
BlockOutcome::Blocked => {}
BlockOutcome::AlreadyPast => return Err(Timeout),
BlockOutcome::NoCurrentTask => return Err(Timeout),
}
}
}
}
pub struct WaitQueue {
id: u32,
}
impl Default for WaitQueue {
fn default() -> Self {
Self::new()
}
}
impl WaitQueue {
pub fn new() -> Self {
WaitQueue {
id: scheduler::alloc_resource_id(),
}
}
pub const fn with_id(id: u32) -> Self {
WaitQueue { id }
}
pub const fn id(&self) -> u32 {
self.id
}
pub fn wait(&self, deadline: Option<u64>) -> Result<(), Timeout> {
let d = deadline.unwrap_or(0);
loop {
match scheduler::block_until_tick_if(self.id, d, || unsafe {
scheduler::take_wake_flag_locked()
}) {
BlockOutcome::Ready => return Ok(()),
BlockOutcome::Blocked => {}
BlockOutcome::AlreadyPast => return Err(Timeout),
BlockOutcome::NoCurrentTask => return Err(Timeout),
}
}
}
pub fn wake_one(&self) -> bool {
scheduler::wake_first_blocked_on(self.id)
}
pub fn wake_all(&self) -> usize {
let n = self.waiters();
scheduler::wake_blocked_on(self.id);
n
}
pub fn waiters(&self) -> usize {
scheduler::blocked_on_count(self.id)
}
}