vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
//! Monotonic virtual-thread sleeping.

use std::time::{Duration, Instant};

use crate::{Error, ParkOutcome, Result, park_pair, yield_now};

/// Parks the current virtual thread for at least `duration`.
pub fn sleep(duration: Duration) -> Result<()> {
    if duration.is_zero() {
        return yield_now();
    }
    let deadline = Instant::now()
        .checked_add(duration)
        .ok_or(Error::DeadlineOverflow)?;
    sleep_until(deadline)
}

/// Parks the current virtual thread until a monotonic deadline.
pub fn sleep_until(deadline: Instant) -> Result<()> {
    crate::checkpoint()?;
    if deadline <= Instant::now() {
        return Ok(());
    }
    let (parker, _unparker) = park_pair();
    match parker.park_until(deadline)? {
        ParkOutcome::TimedOut => Ok(()),
        ParkOutcome::Cancelled => Err(Error::Cancelled),
        _ => Err(Error::fault(
            crate::error::FaultComponent::Scheduler,
            "private sleep parker woke without timeout",
        )),
    }
}

#[cfg(test)]
#[path = "time_test.rs"]
mod time_test;