vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use super::super::current;
use crate::wait::{WaitBegin, WaitCell};

#[test]
fn a_published_wait_is_taken_once_by_exact_generation() {
    let runtime = crate::Runtime::new().unwrap();
    runtime
        .run_scope(|scope| {
            scope
                .spawn("published-wait", || {
                    let mounted = current().unwrap();
                    let execution = mounted.execution().unwrap();
                    let wait = WaitCell::new();
                    let WaitBegin::Park {
                        request,
                        registration,
                    } = wait
                        .begin(execution.id, execution.task_key(), execution.hub(), None)
                        .unwrap()
                    else {
                        panic!("expected a park request");
                    };
                    let expected = registration.state.clone();
                    let publication = execution
                        .publish_wait(request.token(), registration)
                        .unwrap();
                    let retained = execution
                        .take_wait(request.token())
                        .unwrap()
                        .expect("shared wait registration");
                    assert!(std::sync::Weak::ptr_eq(&retained.state, &expected));
                    assert!(execution.take_wait(request.token()).is_err());
                    drop(publication);
                    wait.rollback(request.token());
                })?
                .join()
        })
        .unwrap();
}

#[test]
fn a_task_resident_wait_is_recognized_only_by_exact_identity() {
    let runtime = crate::Runtime::new().unwrap();
    runtime
        .run_scope(|scope| {
            scope
                .spawn("task-resident-wait", || {
                    let mounted = current().unwrap();
                    let execution = mounted.execution().unwrap();
                    let wait = execution.synchronization_wait().unwrap();
                    let WaitBegin::Park { request, .. } = wait
                        .begin(execution.id, execution.task_key(), execution.hub(), None)
                        .unwrap()
                    else {
                        panic!("expected a park request");
                    };
                    let token = request.token();
                    let wrong = vthread_stack::ParkToken::new(token.wait() + 1, token.generation());
                    assert!(execution.take_wait(wrong).is_err());
                    let stale = vthread_stack::ParkToken::new(token.wait(), token.generation() + 1);
                    assert!(execution.take_wait(stale).is_err());
                    assert!(execution.take_wait(token).unwrap().is_none());
                    wait.rollback(token);
                })?
                .join()
        })
        .unwrap();
}

#[test]
fn dropping_a_publication_clears_the_pending_handoff() {
    let runtime = crate::Runtime::new().unwrap();
    runtime
        .run_scope(|scope| {
            scope
                .spawn("rolled-back-publication", || {
                    let mounted = current().unwrap();
                    let execution = mounted.execution().unwrap();
                    let wait = WaitCell::new();
                    let WaitBegin::Park {
                        request,
                        registration,
                    } = wait
                        .begin(execution.id, execution.task_key(), execution.hub(), None)
                        .unwrap()
                    else {
                        panic!("expected a park request");
                    };
                    let publication = execution
                        .publish_wait(request.token(), registration)
                        .unwrap();
                    drop(publication);
                    assert!(execution.take_wait(request.token()).is_err());
                    wait.rollback(request.token());
                })?
                .join()
        })
        .unwrap();
}