vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use super::*;
use crate::wait::WaitHub;
use crate::{
    TaskId,
    task_slab::TaskKey,
    wait::{WaitBegin, WakeCause},
};
use std::sync::Arc;

#[test]
fn claimed_owner_interest_does_not_become_a_next_generation_permit() {
    let signal = Arc::default();
    let hub = Arc::new(WaitHub::new(1, Arc::clone(&signal)));
    let cell = WaitCell::new();
    let WaitBegin::Park { request, .. } = cell
        .begin(TaskId::new(1), TaskKey::owned(0), &hub, None)
        .unwrap()
    else {
        panic!("expected park");
    };
    let token = request.token();
    let active = cell.state.load();
    let claim = active.claimed(WakeCause::Ready);
    assert!(cell.state.compare_exchange(active, claim).is_ok());
    let observed = signal.version();
    assert_eq!(cell.publication(token), Publication::InFlight);
    assert!(!cell.try_abandon(token));
    assert!(cell.state.load().has_permit());
    cell.state.publish_claim(claim);
    assert_ne!(signal.version(), observed);
    assert_eq!(cell.publication(token), Publication::Published);
    assert!(!cell.state.load().has_permit());
    assert_eq!(cell.finish(token).unwrap(), WakeCause::Ready);
    assert_eq!(cell.publication(token), Publication::Stale);
    assert!(matches!(
        cell.begin(TaskId::new(1), TaskKey::owned(0), &hub, None)
            .unwrap(),
        WaitBegin::Park { .. }
    ));
}

#[test]
fn owner_retirement_preserves_selected_resources_until_ticket_cleanup() {
    let hub = Arc::new(WaitHub::new(1, Arc::default()));
    let cell = WaitCell::new();
    let WaitBegin::Park { request, .. } = cell
        .begin(TaskId::new(1), TaskKey::owned(0), &hub, None)
        .unwrap()
    else {
        panic!("expected park");
    };
    let token = request.token();
    assert!(cell.offer_resource(super::super::ResourceSelection::Permit));
    assert!(cell.try_abandon(token));
    assert_eq!(cell.publication(token), Publication::Stale);
    assert_eq!(
        cell.take_resource(),
        Some(super::super::ResourceSelection::Permit)
    );
    assert_eq!(cell.take_resource(), None);
    assert!(hub.pop_wake().is_none());
}

#[test]
fn a_delayed_completion_notifies_the_original_hub_after_rebinding() {
    use crate::wait::wait_publication_probe_test::{PausedPublication, Stage};
    let original_signal = Arc::default();
    let next_signal = Arc::default();
    let original = Arc::new(WaitHub::new(1, Arc::clone(&original_signal)));
    let next = Arc::new(WaitHub::new(1, Arc::clone(&next_signal)));
    let cell = WaitCell::new();
    let WaitBegin::Park { request, .. } = cell
        .begin(TaskId::new(1), TaskKey::owned(0), &original, None)
        .unwrap()
    else {
        panic!("expected park");
    };
    let token = request.token();
    let active = cell.state.load();
    let claimed = active.claimed(WakeCause::Ready);
    assert!(cell.state.compare_exchange(active, claimed).is_ok());
    assert_eq!(cell.publication(token), Publication::InFlight);
    let original_epoch = original_signal.version();
    let next_epoch = next_signal.version();
    std::thread::scope(|threads| {
        let mut pause = PausedPublication::install_at(&cell, Stage::ClaimPublished);
        let publisher = threads.spawn(|| cell.state.publish_claim(claimed));
        pause.observe(Stage::ClaimPublished);
        assert_eq!(cell.finish(token).unwrap(), WakeCause::Ready);
        let WaitBegin::Park { request, .. } = cell
            .begin(TaskId::new(2), TaskKey::owned(0), &next, None)
            .unwrap()
        else {
            panic!("expected next park");
        };
        assert_ne!(request.token(), token);
        assert_eq!(cell.publication(token), Publication::Stale);
        assert_eq!(cell.notify(), crate::wait::NotifyResult::Woke);
        assert_eq!(next.pop_wake().unwrap().token, request.token());
        assert_eq!(cell.finish(request.token()).unwrap(), WakeCause::Ready);
        assert_eq!(original_signal.version(), original_epoch);
        pause.release();
        publisher.join().unwrap();
    });
    assert_ne!(original_signal.version(), original_epoch);
    assert_eq!(next_signal.version(), next_epoch);
}