vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use crate::{Error, Runtime, RuntimeConfig, control::Shared, support_test::until};
use std::sync::{
    Arc, Barrier,
    atomic::{AtomicBool, Ordering},
    mpsc,
};
use std::time::{Duration, Instant};

#[test]
fn close_and_reserve_have_one_order_and_reserved_work_prevents_drain() {
    for _ in 0..64 {
        let shared = Arc::new(Shared::new(RuntimeConfig::default()));
        let scope = shared.begin_scope().unwrap();
        let barrier = Arc::new(Barrier::new(2));
        let remote = Arc::clone(&shared);
        let entered = Arc::clone(&barrier);
        let reserve = std::thread::spawn(move || {
            entered.wait();
            remote.reserve(scope, "racing admission".into(), None)
        });
        barrier.wait();
        shared.close_scope(scope);
        match reserve.join().unwrap() {
            Ok(record) => {
                assert!(
                    !shared
                        .wait_until(scope, None, Some(Instant::now()))
                        .unwrap()
                );
                shared.complete(&record, None);
            }
            Err(Error::ScopeClosed) => {}
            Err(error) => panic!("unexpected admission error: {error}"),
        }
        assert!(matches!(
            shared.reserve(scope, "late".into(), None),
            Err(Error::ScopeClosed)
        ));
        assert!(
            shared
                .wait_until(scope, None, Some(Instant::now()))
                .unwrap()
        );
        shared.finish_scope(scope);
        assert_eq!(shared.snapshot().active(), 0);
    }
}

#[test]
fn dropping_a_dynamic_handle_keeps_reclamation_owned_by_the_root() {
    struct Guard(Arc<AtomicBool>);
    impl Drop for Guard {
        fn drop(&mut self) {
            self.0.store(true, Ordering::SeqCst);
        }
    }
    let runtime = Runtime::new().unwrap();
    let dropped = Arc::new(AtomicBool::new(false));
    let guard = Guard(Arc::clone(&dropped));
    runtime
        .run_scope(|scope| {
            let spawner = scope.spawner();
            scope
                .spawn("parent", move || {
                    drop(spawner.spawn("owned child", move || {
                        let _guard = guard;
                        crate::yield_now()
                    })?);
                    Ok::<_, Error>(())
                })?
                .join()??;
            Ok(())
        })
        .unwrap();
    assert!(dropped.load(Ordering::SeqCst));
    assert_eq!(runtime.snapshot().active(), 0);
}

#[test]
fn root_unwind_closes_escaped_capabilities_before_reclamation() {
    let runtime = Runtime::new().unwrap();
    let mut retained = None;
    let panic = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        let _: crate::Result<()> = runtime.run_scope(|scope| {
            retained = Some(scope.spawner());
            panic!("root body");
        });
    }));
    assert!(panic.is_err());
    assert!(matches!(
        retained.unwrap().spawn("late", || ()),
        Err(Error::ScopeClosed)
    ));
    runtime.run_scope(|_| Ok(())).unwrap();
}

#[test]
fn remote_capabilities_close_on_supervisor_stop_and_rejection_drops_outside_locks() {
    struct Reenter(crate::Spawner, Arc<AtomicBool>);
    impl Drop for Reenter {
        fn drop(&mut self) {
            assert!(matches!(
                self.0.spawn("reentrant", || ()),
                Err(Error::ScopeClosed)
            ));
            self.1.store(true, Ordering::SeqCst);
        }
    }
    let runtime = Runtime::new().unwrap();
    let supervisor = runtime.supervisor().unwrap();
    let spawner = supervisor.spawner();
    let remote = spawner.clone();
    assert_eq!(
        std::thread::spawn(move || remote.spawn("OS child", || 7).unwrap().join().unwrap())
            .join()
            .unwrap(),
        7
    );
    supervisor.request_shutdown();
    let dropped = Arc::new(AtomicBool::new(false));
    let capture = Reenter(spawner.clone(), Arc::clone(&dropped));
    assert!(matches!(
        spawner.spawn("closed", move || drop(capture)),
        Err(Error::ScopeClosed)
    ));
    assert!(dropped.load(Ordering::SeqCst));
    supervisor.shutdown().unwrap();
    assert!(matches!(
        spawner.spawn("finished", || ()),
        Err(Error::ScopeClosed)
    ));
}

#[test]
fn already_admitted_parent_can_create_borrowed_children_during_root_drain() {
    let runtime = Runtime::new().unwrap();
    let (release, gate) = mpsc::sync_channel(1);
    let finished = Arc::new(AtomicBool::new(false));
    runtime
        .run_scope(|scope| {
            let done = Arc::clone(&finished);
            drop(scope.spawn("admitted parent", move || {
                gate.recv_timeout(Duration::from_secs(5)).unwrap();
                crate::local_scope(|local| {
                    let value = local.spawn("borrowed child", || 42)?.join()?;
                    assert_eq!(value, 42);
                    done.store(true, Ordering::SeqCst);
                    Ok(())
                })
                .unwrap();
            })?);
            *crate::signal::lock(&runtime.shared.scope_drain_hook) = Some(Box::new(move || {
                release.send(()).unwrap();
            }));
            Ok(())
        })
        .unwrap();
    assert!(finished.load(Ordering::SeqCst));
}

#[test]
fn dynamic_capacity_rejection_keeps_existing_children_owned() {
    let runtime = Runtime::builder()
        .max_vthreads(2)
        .stack_cache_capacity(0)
        .build()
        .unwrap();
    runtime
        .run_scope(|scope| {
            let spawner = scope.spawner();
            scope
                .spawn("parent", move || {
                    let mut child =
                        spawner.spawn("last slot", || crate::sleep(Duration::from_secs(5)))?;
                    assert!(matches!(
                        spawner.spawn("excess", || ()),
                        Err(Error::Capacity {
                            resource: crate::error::CapacityResource::Tasks,
                            limit: 2
                        })
                    ));
                    child.cancel();
                    assert!(matches!(child.join()?, Err(Error::Cancelled)));
                    assert_eq!(spawner.spawn("replacement", || 42)?.join()?, 42);
                    Ok::<_, Error>(())
                })?
                .join()??;
            until(|| runtime.snapshot().active() == 0);
            Ok(())
        })
        .unwrap();
}