vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use crate::{Runtime, RuntimeConfig, StallPolicy, TaskStatus, control::Shared};
use std::{
    sync::{Arc, atomic::Ordering, mpsc},
    time::{Duration, Instant},
};

#[test]
fn completion_is_committed_once() {
    let shared = Shared::new(RuntimeConfig::default());
    let scope = shared.begin_scope().unwrap();
    let record = shared.reserve(scope, "done".into(), None).unwrap();
    shared.complete(&record, None);
    shared.complete(&record, None);
    assert_eq!(record.lock().status, TaskStatus::Completed);
}

#[test]
fn completion_notifications_are_coalesced_until_scope_drains() {
    let shared = Shared::new(RuntimeConfig::default());
    let scope = shared.begin_scope().unwrap();
    let first = shared.reserve(scope, "first".into(), None).unwrap();
    let second = shared.reserve(scope, "second".into(), None).unwrap();
    let last = shared.reserve(scope, "last".into(), None).unwrap();
    let observed = shared.changed.version();

    shared.complete(&first, None);
    shared.complete(&second, None);
    assert_eq!(shared.changed.version(), observed);

    shared.complete(&last, None);
    assert!(shared.changed.version() > observed);
}

#[test]
fn completion_batch_retires_scope_and_carrier_load_together() {
    let config = Runtime::builder()
        .carriers(1)
        .build()
        .expect("config")
        .config();
    let shared = Shared::new(config);
    let scope = shared.begin_scope().unwrap();
    let records = (0..3)
        .map(|index| {
            shared
                .reserve(scope, format!("task {index}"), None)
                .unwrap()
        })
        .collect::<Vec<_>>();
    let mut completions = super::CompletionBatch::new();
    for record in &records {
        completions.push(shared.prepare_completion(record, None).unwrap());
    }

    let progress = shared.scope_progress(scope);
    shared.publish_completions(&completions, &progress);

    let snapshot = shared.snapshot();
    assert_eq!(snapshot.active, 0);
    assert_eq!(snapshot.carriers[0].active, 0);
    let report = shared.scope_report(scope);
    assert_eq!(report.completed, 3);
    assert_eq!(report.panicked, 0);
    assert_eq!(report.aborted, 0);
    shared.finish_scope(scope);
}

#[test]
fn target_waiter_is_notified_before_its_scope_drains() {
    let shared = Arc::new(Shared::new(RuntimeConfig::default()));
    let scope = shared.begin_scope().unwrap();
    let target = shared.reserve(scope, "target".into(), None).unwrap();
    let sibling = shared.reserve(scope, "sibling".into(), None).unwrap();
    let waiting_for = Arc::clone(&target);
    let observer = Arc::clone(&shared);
    let (sent, received) = mpsc::sync_channel(1);
    let waiter = std::thread::spawn(move || sent.send(observer.wait(scope, Some(&waiting_for))));

    let deadline = Instant::now() + Duration::from_secs(1);
    while shared.target_waiters.load(Ordering::SeqCst) == 0 {
        assert!(Instant::now() < deadline, "target waiter did not register");
        std::thread::yield_now();
    }
    shared.complete(&target, None);
    let result = received
        .recv_timeout(Duration::from_secs(1))
        .expect("target completion did not wake its waiter");
    result.unwrap();

    shared.complete(&sibling, None);
    waiter.join().unwrap().unwrap();
    shared.finish_scope(scope);
}

#[test]
fn stall_detection_observes_each_completion() {
    let config = Runtime::builder()
        .stall_policy(StallPolicy::ReportAfter(Duration::from_secs(1)))
        .build()
        .unwrap()
        .config();
    let shared = Shared::new(config);
    let scope = shared.begin_scope().unwrap();
    let first = shared.reserve(scope, "first".into(), None).unwrap();
    let last = shared.reserve(scope, "last".into(), None).unwrap();
    let observed = shared.changed.version();

    shared.complete(&first, None);
    assert!(shared.changed.version() > observed);
    shared.complete(&last, None);
}

#[test]
fn a_target_observer_can_retire_before_its_completion_batch_is_queued() {
    use crate::{CarrierId, kernel::Kernel};
    use std::io::Write;

    let config = Runtime::builder()
        .max_vthreads(2)
        .carrier_queue_capacity(2)
        .stack_cache_capacity(2)
        .build()
        .unwrap()
        .config();
    let shared = Arc::new(Shared::new(config));
    let scope = shared.begin_scope().unwrap();
    let target = shared.reserve(scope, "target".into(), None).unwrap();
    let sibling = shared.reserve(scope, "sibling".into(), None).unwrap();
    let completion = std::thread::scope(|threads| {
        // TargetWaiter registers before acquiring this lock. Hold it so the
        // observer cannot inspect the target until its completion is visible.
        let state = crate::signal::lock(&shared.state);
        let observer = threads.spawn(|| shared.wait(scope, Some(&target)));
        crate::support_test::until(|| !shared.may_defer_completion());
        let completion = shared.prepare_completion(&target, None).unwrap();
        target.completion().complete();
        drop(state);
        observer.join().unwrap().unwrap();
        completion
    });
    let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
    kernel.queue_completion(completion);
    let observed = (
        target.completion().done(),
        shared.may_defer_completion(),
        kernel.completions.len(),
        shared.scope_report(scope).completed,
    );
    // Clean up before checking the disputed assertion; no reserved task remains.
    kernel.flush_completions();
    shared.complete(&sibling, None);
    assert_eq!(shared.scope_report(scope).completed, 2);
    shared.finish_scope(scope);
    writeln!(
        std::io::stdout().lock(),
        "completion boundary: (target_done, may_defer, batched, scope_completed)={observed:?}"
    )
    .unwrap();
    assert_eq!(observed, (true, true, 1, 0));
}