vthread 0.0.1

Bounded carrier-affine virtual threads for Rust
Documentation
use std::{
    sync::Arc,
    time::{Duration, Instant},
};

use crate::TaskId;

use super::super::{WaitBegin, WaitCell, WaitHub, WakeCause};

#[test]
fn selected_timeout_emits_the_registered_task_identity() {
    let cell = WaitCell::new();
    let hub = Arc::new(WaitHub::new(64, Arc::default()));
    let request = match cell
        .begin(
            TaskId::new(9),
            &hub,
            Some(Instant::now() + Duration::from_secs(1)),
        )
        .expect("begin wait")
    {
        WaitBegin::Park(request) => request,
        WaitBegin::Immediate(cause) => panic!("unexpected immediate wake: {cause:?}"),
    };
    let registration = hub
        .take_registration(request.token())
        .expect("registration");
    assert!(
        registration
            .select_timeout(request.token())
            .expect("timeout selection")
    );
    let notice = hub.pop_wake().expect("wake notice");
    assert_eq!(notice.task, TaskId::new(9));
    assert_eq!(notice.cause, WakeCause::TimedOut);
}

#[test]
fn concurrent_ready_timeout_cancel_and_close_select_exactly_one_notice() {
    use std::{sync::Barrier, thread};
    for _ in 0..64 {
        let cell = WaitCell::new();
        let hub = Arc::new(WaitHub::new(1, Arc::default()));
        let WaitBegin::Park(request) = cell.begin(TaskId::new(9), &hub, None).expect("park") else {
            panic!("expected a park");
        };
        let token = request.token();
        let registration = hub.take_registration(token).expect("registration");
        let barrier = Barrier::new(4);
        thread::scope(|threads| {
            threads.spawn(|| {
                barrier.wait();
                cell.notify();
            });
            threads.spawn(|| {
                barrier.wait();
                cell.cancel();
            });
            threads.spawn(|| {
                barrier.wait();
                cell.close();
            });
            threads.spawn(|| {
                barrier.wait();
                registration.select_timeout(token).expect("timeout");
            });
        });
        assert_eq!(hub.pending(), 1);
        let notice = hub.pop_wake().expect("one winner");
        assert_eq!(notice.token, token);
        assert_eq!(notice.task, TaskId::new(9));
        assert_eq!(cell.finish(token).expect("finish"), notice.cause);
        assert!(hub.pop_wake().is_none());
        assert_eq!(hub.stale(), 0);
    }
}

#[test]
fn stale_native_ready_and_close_never_select_or_store_for_a_new_generation() {
    let cell = WaitCell::new();
    let hub = Arc::new(WaitHub::new(1, Arc::default()));
    let WaitBegin::Park(first) = cell.begin(TaskId::new(1), &hub, None).unwrap() else {
        panic!("park");
    };
    let registration = cell.registration();
    assert!(registration.select_cancelled(first.token()));
    hub.pop_wake().unwrap();
    cell.finish(first.token()).unwrap();
    let WaitBegin::Park(second) = cell.begin(TaskId::new(1), &hub, None).unwrap() else {
        panic!("park");
    };
    assert!(!registration.select_ready(first.token()));
    assert!(!registration.select_closed(first.token()));
    assert!(hub.pop_wake().is_none());
    assert!(registration.select_ready(second.token()));
    assert!(!registration.select_closed(second.token()));
    hub.pop_wake().unwrap();
    cell.finish(second.token()).unwrap();
    let WaitBegin::Park(third) = cell.begin(TaskId::new(1), &hub, None).unwrap() else {
        panic!("late events must not store permits");
    };
    cell.rollback(third.token());
}