vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use super::Wait;
use std::sync::{
    Arc,
    atomic::{AtomicU8, Ordering},
};

use crate::{Error, Runtime, SuspensionReason, context};

const UNSET: u8 = 0;
const REJECTED: u8 = 1;
const ENTERED: u8 = 2;
const UNEXPECTED: u8 = 3;

struct EnterWaitOnDrop(Arc<AtomicU8>);

impl Drop for EnterWaitOnDrop {
    fn drop(&mut self) {
        let outcome = match Wait::enter_after_check(SuspensionReason::Mutex) {
            Err(Error::SuspensionDuringPanic) => REJECTED,
            Ok(_) => ENTERED,
            Err(_) => UNEXPECTED,
        };
        self.0.store(outcome, Ordering::SeqCst);
    }
}

#[test]
fn diagnostic_reason_is_nested_and_restored() {
    assert!(matches!(
        Wait::enter(SuspensionReason::Mutex),
        Err(Error::OutsideVThread)
    ));
    Runtime::new()
        .unwrap()
        .run_scope(|scope| {
            scope
                .spawn("reasons", || {
                    let mounted = context::current().unwrap();
                    let data = &mounted.execution().unwrap().data;
                    let outer = Wait::enter(SuspensionReason::Mutex).unwrap();
                    {
                        let _inner = Wait::enter(SuspensionReason::Condvar).unwrap();
                        assert_eq!(data.reason(), SuspensionReason::Condvar);
                    }
                    assert_eq!(data.reason(), SuspensionReason::Mutex);
                    drop(outer);
                    assert_eq!(data.reason(), SuspensionReason::Park);
                })?
                .join()
        })
        .unwrap();
}

#[test]
fn panic_is_rejected_before_a_synchronization_wait_changes_task_state() {
    let outcome = Arc::new(AtomicU8::new(UNSET));
    let task_outcome = Arc::clone(&outcome);
    Runtime::new()
        .unwrap()
        .run_scope(|scope| {
            let mut task = scope.spawn("panic wait", move || {
                let _wait = EnterWaitOnDrop(task_outcome);
                panic!("expected synchronization panic");
            })?;
            assert!(matches!(task.join(), Err(Error::TaskPanicked { .. })));
            Ok(())
        })
        .unwrap();

    assert_eq!(outcome.load(Ordering::SeqCst), REJECTED);
}