vthread-stack 0.1.0

Stack and context backend for vthread
Documentation
use std::{
    cell::{Cell, RefCell},
    panic::{AssertUnwindSafe, catch_unwind},
    rc::Rc,
    time::{Duration, Instant},
};

use crate::{ContextKey, MappedStack};

use crate::suspend;
use crate::{Fiber, FiberState, ParkRequest, ParkToken, Resume, Suspension};

static TEST_CONTEXT: ContextKey<u64> = ContextKey::new();

fn nested_yield() {
    suspend(Suspension::YieldNow).expect("fiber must be mounted");
}

#[test]
fn a_nested_function_can_suspend_and_resume() {
    let trace = Rc::new(RefCell::new(Vec::new()));
    let body_trace = Rc::clone(&trace);
    let stack = MappedStack::new(128 * 1024, 0).expect("allocate stack");
    let mut fiber = Fiber::new(stack, move || {
        body_trace.borrow_mut().push("before");
        nested_yield();
        body_trace.borrow_mut().push("after");
    });

    assert_eq!(fiber.resume(), FiberState::Suspended(Suspension::YieldNow));
    assert_eq!(&*trace.borrow(), &["before"]);
    assert_eq!(fiber.resume(), FiberState::Complete);
    assert_eq!(&*trace.borrow(), &["before", "after"]);
    assert!(fiber.is_complete());
    drop(fiber.into_stack());
}

#[test]
fn resume_decision_returns_to_the_suspension_point() {
    let observed = Rc::new(Cell::new(Resume::Continue));
    let body_observed = Rc::clone(&observed);
    let stack = MappedStack::new(128 * 1024, 0).expect("allocate stack");
    let mut fiber = Fiber::new(stack, move || {
        body_observed.set(suspend(Suspension::YieldNow).unwrap());
    });

    assert_eq!(fiber.resume(), FiberState::Suspended(Suspension::YieldNow));
    assert_eq!(fiber.resume_with(Resume::Interrupt), FiberState::Complete);
    assert_eq!(observed.get(), Resume::Interrupt);
    drop(fiber.into_stack());
}

#[test]
fn suspended_fiber_can_move_before_resuming() {
    let stack = MappedStack::new(128 * 1024, 0).expect("allocate stack");
    let mut fiber = Fiber::new(stack, || {
        nested_yield();
        nested_yield();
    });

    assert_eq!(fiber.resume(), FiberState::Suspended(Suspension::YieldNow));
    let mut moved = fiber;
    assert_eq!(moved.resume(), FiberState::Suspended(Suspension::YieldNow));
    assert_eq!(moved.resume(), FiberState::Complete);
    drop(moved.into_stack());
}

#[test]
fn parking_requests_preserve_token_and_deadline() {
    let deadline = Instant::now() + Duration::from_secs(1);
    let request = ParkRequest::new(ParkToken::new(7, 3), Some(deadline));
    let stack = MappedStack::new(128 * 1024, 0).expect("allocate stack");
    let mut fiber = Fiber::new(stack, move || {
        suspend(Suspension::Park(request)).expect("fiber must be mounted");
    });

    match fiber.resume() {
        FiberState::Suspended(Suspension::Park(request)) => {
            assert_eq!(request.token().wait(), 7);
            assert_eq!(request.token().generation(), 3);
            assert_eq!(request.deadline(), Some(deadline));
        }
        state => panic!("unexpected fiber state: {state:?}"),
    }
    assert_eq!(fiber.resume(), FiberState::Complete);
    drop(fiber.into_stack());
}

#[test]
fn suspension_outside_a_fiber_is_rejected() {
    let error = suspend(Suspension::YieldNow).expect_err("no fiber is mounted");
    assert_eq!(
        error.to_string(),
        "no virtual-thread stack is mounted on this carrier"
    );
}

#[test]
fn typed_context_tracks_each_resume_and_restores_the_caller() {
    let observed = Rc::new(RefCell::new(Vec::new()));
    let body_observed = Rc::clone(&observed);
    let stack = MappedStack::new(128 * 1024, 0).expect("allocate stack");
    let mut fiber = Fiber::new(stack, move || {
        body_observed
            .borrow_mut()
            .push(TEST_CONTEXT.with(|value| *value));
        nested_yield();
        body_observed
            .borrow_mut()
            .push(TEST_CONTEXT.with(|value| *value));
    });

    assert!(TEST_CONTEXT.with(|_| ()).is_none());
    assert_eq!(
        fiber.resume_with_context(Resume::Continue, &TEST_CONTEXT, &7),
        FiberState::Suspended(Suspension::YieldNow)
    );
    assert!(TEST_CONTEXT.with(|_| ()).is_none());
    assert_eq!(
        fiber.resume_with_context(Resume::Continue, &TEST_CONTEXT, &11),
        FiberState::Complete
    );
    assert_eq!(&*observed.borrow(), &[Some(7), Some(11)]);
    assert!(TEST_CONTEXT.with(|_| ()).is_none());
    drop(fiber.into_stack());
}

#[test]
fn nested_fiber_context_restores_the_outer_value() {
    let inner_stack = MappedStack::new(128 * 1024, 0).expect("allocate inner stack");
    let outer_stack = MappedStack::new(128 * 1024, 0).expect("allocate outer stack");
    let mut outer = Fiber::new(outer_stack, move || {
        assert_eq!(TEST_CONTEXT.with(|value| *value), Some(7));
        let mut inner = Fiber::new(inner_stack, || {
            assert_eq!(TEST_CONTEXT.with(|value| *value), Some(11));
        });
        assert_eq!(
            inner.resume_with_context(Resume::Continue, &TEST_CONTEXT, &11),
            FiberState::Complete
        );
        assert_eq!(TEST_CONTEXT.with(|value| *value), Some(7));
        drop(inner.into_stack());
    });

    assert_eq!(
        outer.resume_with_context(Resume::Continue, &TEST_CONTEXT, &7),
        FiberState::Complete
    );
    assert!(TEST_CONTEXT.with(|_| ()).is_none());
    drop(outer.into_stack());
}

#[test]
fn panic_unwinds_values_on_the_fiber_stack() {
    struct DropFlag(Rc<Cell<bool>>);

    impl Drop for DropFlag {
        fn drop(&mut self) {
            self.0.set(true);
        }
    }

    let dropped = Rc::new(Cell::new(false));
    let body_dropped = Rc::clone(&dropped);
    let stack = MappedStack::new(128 * 1024, 0).expect("allocate stack");
    let mut fiber = Fiber::new(stack, move || {
        let _flag = DropFlag(body_dropped);
        panic!("task panic");
    });

    let result = catch_unwind(AssertUnwindSafe(|| {
        fiber.resume_with_context(Resume::Continue, &TEST_CONTEXT, &7)
    }));
    assert!(result.is_err());
    assert!(TEST_CONTEXT.with(|_| ()).is_none());
    assert!(dropped.get());
    assert!(fiber.is_complete());
    drop(fiber.into_stack());
}

#[test]
fn completed_resume_panics_before_installing_a_stale_mount() {
    use std::sync::{
        Arc,
        atomic::{AtomicBool, Ordering},
    };
    let mut fiber = Fiber::new(MappedStack::new(128 * 1024, 0).unwrap(), || {});
    assert_eq!(fiber.resume(), FiberState::Complete);
    let wrong_mount = Arc::new(AtomicBool::new(false));
    let observed = Arc::clone(&wrong_mount);
    let owner = std::thread::current().id();
    let previous = Arc::new(std::panic::take_hook());
    let forwarded = Arc::clone(&previous);
    std::panic::set_hook(Box::new(move |info| {
        if std::thread::current().id() == owner {
            observed.store(has_mounted_block(), Ordering::Relaxed);
        }
        forwarded(info);
    }));
    let result = catch_unwind(AssertUnwindSafe(|| fiber.resume()));
    std::panic::set_hook(Box::new(move |info| previous(info)));
    assert!(result.is_err());
    assert!(!wrong_mount.load(Ordering::Relaxed));
}

#[test]
fn incomplete_stack_extraction_reclaims_with_its_block_mounted() {
    struct ObserveMount(Rc<Cell<bool>>);
    impl Drop for ObserveMount {
        fn drop(&mut self) {
            self.0.set(has_mounted_block());
        }
    }
    let mounted = Rc::new(Cell::new(false));
    let observed = Rc::clone(&mounted);
    let mut fiber = Fiber::new(MappedStack::new(128 * 1024, 0).unwrap(), move || {
        let _probe = ObserveMount(observed);
        suspend(Suspension::YieldNow).unwrap();
    });
    assert_eq!(fiber.resume(), FiberState::Suspended(Suspension::YieldNow));
    let result = catch_unwind(AssertUnwindSafe(|| fiber.into_stack()));
    assert!(result.is_err());
    assert!(mounted.get());
    assert!(!has_mounted_block());
}

fn has_mounted_block() -> bool {
    !crate::mount::mounted_core().is_null()
}