vthread-stack 0.1.0

Stack and context backend for vthread
Documentation
use super::fiber_scope;
use crate::{Fiber, FiberState, StackPool, Suspension, suspend};
use std::{
    cell::{Cell, RefCell},
    panic::{AssertUnwindSafe, catch_unwind},
    rc::Rc,
};

#[test]
fn forced_parent_reclamation_preserves_the_backend_unwind_token() {
    let drops = Rc::new(Cell::new(0));
    let child_drops = Rc::clone(&drops);
    struct Count(Rc<Cell<usize>>);
    impl Drop for Count {
        fn drop(&mut self) {
            self.0.set(self.0.get() + 1);
        }
    }
    let mut pool = StackPool::new(128 * 1024, 0);
    let mut parent = Fiber::new(pool.acquire().unwrap(), move || {
        fiber_scope(1, |scope| {
            let child = scope
                .spawn(pool.acquire().unwrap(), || {
                    let _count = Count(child_drops);
                    suspend(Suspension::YieldNow).unwrap();
                })
                .unwrap();
            child.resume();
            suspend(Suspension::YieldNow).unwrap();
        });
    });
    parent.resume();
    let result = catch_unwind(AssertUnwindSafe(|| drop(parent)));
    assert!(result.is_ok(), "forced unwind became an ordinary panic");
    assert_eq!(drops.get(), 1);
}

#[test]
fn a_running_lease_can_be_inspected_without_borrowing_its_executing_fiber() {
    let slot = Rc::new(RefCell::new(None::<super::FiberLease>));
    let mut pool = StackPool::new(128 * 1024, 0);
    fiber_scope(1, |scope| {
        let current = Rc::clone(&slot);
        let lease = scope
            .spawn(pool.acquire().unwrap(), move || {
                assert!(current.borrow().as_ref().unwrap().live());
            })
            .unwrap();
        *slot.borrow_mut() = Some(lease.clone());
        assert_eq!(lease.resume(), Some(FiberState::Complete));
    });
}

#[test]
fn incomplete_extraction_preserves_the_lease_for_later_completion() {
    let mut pool = StackPool::new(128 * 1024, 0);
    fiber_scope(1, |scope| {
        let lease = scope
            .spawn(pool.acquire().unwrap(), || {
                suspend(Suspension::YieldNow).unwrap();
            })
            .unwrap();
        lease.resume();
        let result = catch_unwind(AssertUnwindSafe(|| lease.take_stack()));
        assert!(
            matches!(result, Ok(None)),
            "incomplete extraction destroyed its fiber"
        );
        assert!(lease.live());
        assert_eq!(lease.resume(), Some(FiberState::Complete));
        assert!(lease.take_stack().is_some());
    });
}

#[test]
fn failed_cleanup_mount_preserves_ownership_for_retry() {
    let mut pool = StackPool::new(128 * 1024, 0);
    fiber_scope(1, |scope| {
        let lease = scope
            .spawn(pool.acquire().unwrap(), || {
                suspend(Suspension::YieldNow).unwrap();
            })
            .unwrap();
        lease.resume();
        let first = Cell::new(true);
        lease.cleanup_context(move || {
            assert!(!first.replace(false), "injected mount failure");
            Box::new(())
        });
        assert!(catch_unwind(AssertUnwindSafe(|| lease.reclaim())).is_err());
        assert!(
            lease.live(),
            "mount failure lost ownership of the suspended stack"
        );
        lease.reclaim();
        assert!(!lease.live());
    });
}

#[test]
fn escaped_and_forgotten_leases_cannot_outlive_borrowed_values() {
    let mut count = 0;
    let mut pool = StackPool::new(128 * 1024, 0);
    let lease = fiber_scope(1, |scope| {
        let lease = scope
            .spawn(pool.acquire().unwrap(), || {
                count += 1;
                suspend(Suspension::YieldNow).unwrap();
                count += 100;
            })
            .unwrap();
        assert_eq!(
            lease.resume(),
            Some(FiberState::Suspended(Suspension::YieldNow))
        );
        std::mem::forget(lease.clone());
        lease
    });
    assert_eq!(count, 1);
    assert_eq!(lease.resume(), None);
}

#[test]
fn parent_unwind_drops_borrowed_children() {
    struct Guard<'a>(&'a Cell<usize>);
    impl Drop for Guard<'_> {
        fn drop(&mut self) {
            self.0.set(self.0.get() + 1);
        }
    }
    let count = Cell::new(0);
    let mut pool = StackPool::new(128 * 1024, 0);
    let result = catch_unwind(AssertUnwindSafe(|| {
        fiber_scope(2, |scope| {
            for _ in 0..2 {
                let lease = scope
                    .spawn(pool.acquire().unwrap(), || {
                        let _guard = Guard(&count);
                        suspend(Suspension::YieldNow).unwrap();
                    })
                    .unwrap();
                lease.resume();
            }
            panic!("parent");
        })
    }));
    assert!(result.is_err());
    assert_eq!(count.get(), 2);
}

#[test]
fn reclaiming_a_nested_stack_restores_the_parent_mount() {
    let finished = Rc::new(Cell::new(false));
    let flag = Rc::clone(&finished);
    let mut pool = StackPool::new(128 * 1024, 0);
    let mut parent = Fiber::new(pool.acquire().unwrap(), move || {
        fiber_scope(1, |scope| {
            let child = scope
                .spawn(pool.acquire().unwrap(), || {
                    suspend(Suspension::YieldNow).unwrap();
                })
                .unwrap();
            child.resume();
        });
        suspend(Suspension::YieldNow).unwrap();
        flag.set(true);
    });
    assert_eq!(parent.resume(), FiberState::Suspended(Suspension::YieldNow));
    assert_eq!(parent.resume(), FiberState::Complete);
    assert!(finished.get());
}

#[test]
fn scope_value_remains_live_while_borrowed_destructors_run() {
    struct OnDrop<F: Fn()>(F);
    impl<F: Fn()> Drop for OnDrop<F> {
        fn drop(&mut self) {
            self.0();
        }
    }
    let owners = Cell::new(0);
    let mut pool = StackPool::new(128 * 1024, 0);
    fiber_scope(1, |scope| {
        let lease = scope
            .spawn(pool.acquire().unwrap(), || {
                let _guard = OnDrop(|| owners.set(Rc::strong_count(&scope.registry)));
                suspend(Suspension::YieldNow).unwrap();
            })
            .unwrap();
        lease.resume();
    });
    assert_eq!(
        owners.get(),
        2,
        "both the lexical scope and reclamation guard remain live"
    );
}