vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use std::sync::Arc;

use vthread_stack::ParkToken;

use super::WaitHub;
use crate::{
    TaskId,
    task_slab::TaskKey,
    wait::{WakeCause, WakeNotice},
};

#[test]
fn duplicates_and_stale_generations_cannot_fill_the_inbox() {
    let hub = WaitHub::new_tracked(1, Arc::default());
    let token = ParkToken::new(1, 2);
    let notice = WakeNotice {
        token,
        task: TaskId::new(1),
        route: TaskKey::owned(0),
        cause: WakeCause::Ready,
    };
    hub.enqueue(notice);
    for _ in 0..100 {
        hub.enqueue(notice);
        hub.enqueue(WakeNotice {
            token: ParkToken::new(1, 1),
            ..notice
        });
    }
    assert_eq!(hub.pending(), 1);
    assert_eq!(hub.pending_tasks(), vec![TaskId::new(1)]);
    assert_eq!(hub.stale(), 200);
    assert_eq!(hub.pop_wake(), Some(notice));
    assert!(hub.pop_wake().is_none());
}

#[test]
fn queued_wakes_release_predicate_waiters_without_advancing_the_epoch() {
    for route_index in [0, 31] {
        let signal = Arc::default();
        let hub = WaitHub::new(32, Arc::clone(&signal));
        let first = ParkToken::new(1, 1);
        let second = ParkToken::new(2, 1);
        let empty = signal.version();
        std::thread::scope(|threads| {
            threads.spawn(|| {
                hub.wait_while(empty, None, || false);
            });
            while signal.waiting() == 0 {
                std::thread::yield_now();
            }
            hub.enqueue(WakeNotice {
                token: first,
                task: TaskId::new(1),
                route: TaskKey::owned(route_index),
                cause: WakeCause::Ready,
            });
        });
        let queued = signal.version();
        assert_eq!(queued, empty);
        hub.enqueue(WakeNotice {
            token: second,
            task: TaskId::new(2),
            route: TaskKey::owned(1),
            cause: WakeCause::Ready,
        });
        assert_eq!(signal.version(), queued);
        assert!(hub.pop_wake().is_some());
        assert!(hub.pop_wake().is_some());
    }
}

#[test]
fn published_predicate_never_precedes_its_queue_item() {
    let hub = Arc::new(WaitHub::new(1, Arc::default()));
    let (arrived_tx, arrived_rx) = std::sync::mpsc::channel();
    let (resume_tx, resume_rx) = std::sync::mpsc::channel();
    hub.before_pending_publication(move || {
        arrived_tx.send(()).unwrap();
        resume_rx.recv().unwrap();
    });
    let producer_hub = Arc::clone(&hub);
    let producer = std::thread::spawn(move || {
        producer_hub.enqueue(WakeNotice {
            token: ParkToken::new(1, 1),
            task: TaskId::new(1),
            route: TaskKey::owned(0),
            cause: WakeCause::Ready,
        });
    });

    arrived_rx.recv().unwrap();
    assert_eq!(hub.pending(), 1);
    assert!(!hub.ready.has_pending());
    resume_tx.send(()).unwrap();
    producer.join().unwrap();
    assert_eq!(hub.pending(), 1);
    assert!(hub.ready.has_pending());
    assert!(hub.pop_wake().is_some());
}

#[test]
fn wake_inbox_preserves_publication_order() {
    let hub = WaitHub::new(3, Arc::default());
    for index in 0..3 {
        hub.enqueue(WakeNotice {
            token: ParkToken::new(index as u64 + 1, 1),
            task: TaskId::new(index as u64 + 1),
            route: TaskKey::owned(index),
            cause: WakeCause::Ready,
        });
    }

    for expected in 1..=3 {
        assert_eq!(hub.pop_wake().unwrap().task, TaskId::new(expected));
    }
    assert!(hub.pop_wake().is_none());
}