vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use super::CancellationToken;
use std::{
    sync::{Arc, Barrier},
    thread,
};

#[test]
fn child_registration_and_intermediate_pruning_race_cancellation() {
    for cancel_owner in [false, true] {
        for _ in 0..128 {
            let ancestor = CancellationToken::root(2);
            let owner = ancestor.child_token();
            let parent = ancestor.child_token();
            let retained = parent.clone();
            let barrier = Arc::new(Barrier::new(2));
            let remote_barrier = Arc::clone(&barrier);
            let remote_owner = owner.clone();
            let worker = thread::spawn(move || {
                remote_barrier.wait();
                let intermediate = parent.child_for_scope(&remote_owner);
                let descendant = intermediate.child_token();
                drop(intermediate);
                descendant
            });
            barrier.wait();
            if cancel_owner {
                owner.cancel();
            } else {
                retained.cancel();
            }
            let descendant = worker.join().unwrap();
            assert!(descendant.is_cancelled());
            assert!(!ancestor.is_cancelled());
            assert_eq!(retained.is_cancelled(), !cancel_owner);
            assert_eq!(owner.is_cancelled(), cancel_owner);
        }
    }
}

#[test]
fn dropping_a_retained_deep_token_chain_does_not_recurse() {
    thread::Builder::new()
        .stack_size(128 * 1024)
        .spawn(|| {
            let root = CancellationToken::root(2);
            let mut tokens = vec![root.clone()];
            for _ in 0..100_000 {
                tokens.push(tokens.last().unwrap().child_token());
            }
            let last = tokens.last().unwrap().clone();
            drop(tokens);
            assert_eq!(root.graph_snapshot(), (2, 0, 1));
            root.cancel();
            assert!(last.is_cancelled());
        })
        .unwrap()
        .join()
        .unwrap();
}

#[test]
fn alternating_owners_prune_history_without_losing_any_retained_canceller() {
    for canceller in 0..3 {
        let root = CancellationToken::root(2);
        let owners = [root.child_token(), root.child_token()];
        let ancestor = owners[0].child_token();
        let mut current = ancestor.child_for_scope(&owners[1]);
        for generation in 0..100_000 {
            current = current.child_for_scope(&owners[generation % 2]);
            if generation % 64 == 0 {
                let (nodes, relays, edges) = current.graph_snapshot();
                assert_eq!(nodes, 5);
                assert_eq!(relays, 0);
                assert!(edges <= 6);
            }
        }
        [&ancestor, &owners[0], &owners[1]][canceller].cancel();
        assert!(current.is_cancelled());
        assert!(!root.is_cancelled());
        assert!(!owners[usize::from(canceller != 2)].is_cancelled());
    }
}