vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use crate::{Error, Runtime, ScopeOptions, SpawnOptions, park_pair, support_test::until};
use std::{
    sync::mpsc,
    time::{Duration, Instant},
};

#[test]
fn either_cross_scope_owner_or_caller_cancels_a_dynamically_spawned_child() {
    for cancel_owner in [false, true] {
        let runtime = Runtime::builder().carriers(2).build().unwrap();
        let supervisor = runtime.supervisor().unwrap();
        runtime
            .run_scope(|scope| {
                let spawner = supervisor.spawner();
                let (sent, received) = mpsc::sync_channel(1);
                let (parent_wait, parent_wake) = park_pair();
                let mut parent = scope.spawn("foreign owner parent", move || {
                    let child = spawner.spawn("cross scope child", || {
                        let (wait, _wake) = park_pair();
                        wait.park()
                    })?;
                    sent.send(child).unwrap();
                    parent_wait.park()
                })?;
                let mut child = received.recv_timeout(Duration::from_secs(5)).unwrap();
                until(|| runtime.snapshot().parked() == 2);
                if cancel_owner {
                    supervisor.cancel();
                } else {
                    parent.cancel();
                }
                assert!(matches!(child.join()?, Err(Error::Cancelled)));
                assert!(!scope.cancellation_token().is_cancelled());
                if cancel_owner {
                    assert!(!parent.cancellation_token().is_cancelled());
                    parent_wake.unpark();
                    assert!(parent.join()?.is_ok());
                } else {
                    assert!(!supervisor.cancellation_token().is_cancelled());
                    assert!(matches!(parent.join()?, Err(Error::Cancelled)));
                }
                Ok(())
            })
            .unwrap();
        supervisor.shutdown().unwrap();
    }
}

#[test]
fn dynamic_deadline_is_the_minimum_of_owner_caller_and_request() {
    let runtime = Runtime::builder().carriers(2).build().unwrap();
    let now = Instant::now();
    for (owner_secs, parent_secs, requested_secs) in [(5, 7, 9), (9, 5, 7), (9, 7, 5)] {
        let owner = now + Duration::from_secs(owner_secs);
        let parent = now + Duration::from_secs(parent_secs);
        let requested = now + Duration::from_secs(requested_secs);
        let supervisor = runtime
            .supervisor_with(ScopeOptions::default().deadline(owner))
            .unwrap();
        runtime
            .run_scope(|scope| {
                let spawner = supervisor.spawner();
                let observed = scope
                    .spawn_with(
                        SpawnOptions::default().deadline(parent),
                        "parent",
                        move || {
                            spawner
                                .spawn_with(
                                    SpawnOptions::default().deadline(requested),
                                    "child",
                                    crate::deadline,
                                )?
                                .join()?
                        },
                    )?
                    .join()??;
                assert_eq!(observed, Some(owner.min(parent).min(requested)));
                Ok(())
            })
            .unwrap();
        supervisor.shutdown().unwrap();
    }
}

#[test]
fn foreign_runtime_caller_does_not_supply_parentage_or_inherited_policy() {
    let source = Runtime::new().unwrap();
    let target = Runtime::new().unwrap();
    let supervisor = target.supervisor().unwrap();
    source
        .run_scope(|scope| {
            let spawner = supervisor.spawner();
            let mut parent = scope.spawn_with(
                SpawnOptions::default().deadline(Instant::now() + Duration::from_secs(5)),
                "foreign runtime",
                move || spawner.spawn("target child", crate::deadline),
            )?;
            let mut child = parent.join()??;
            parent.cancel();
            assert_eq!(child.join()??, None);
            assert!(!child.cancellation_token().is_cancelled());
            let snapshot = target.snapshot();
            assert_eq!(snapshot.tasks()[0].parent(), None);
            Ok(())
        })
        .unwrap();
    supervisor.shutdown().unwrap();
}