vthread 0.0.1

Bounded carrier-affine virtual threads for Rust
Documentation
use crate::{Error, Runtime, park_pair};
use std::time::Duration;

#[test]
fn a_pending_wake_for_another_scope_does_not_mask_a_stall() {
    use crate::{
        ScopeOptions, SuspensionReason, TaskFailure, TaskStatus,
        signal::lock,
        wait::{WakeCause, WakeNotice},
    };
    use std::{
        sync::{Arc, Weak},
        time::Instant,
    };
    let config = Runtime::builder()
        .stall_policy(crate::StallPolicy::AbortAfter(Duration::from_millis(10)))
        .build()
        .unwrap()
        .config();
    let shared = Arc::new(super::Shared::new(config));
    let scope = shared.begin_scope().unwrap();
    let record = shared.reserve(scope, "ownerless".into(), None).unwrap();
    shared.transition(&record, |r| {
        r.status = TaskStatus::Suspended(SuspensionReason::Park)
    });
    let other_scope = shared.begin_owned(ScopeOptions::default(), true).unwrap();
    let other = shared.reserve(other_scope, "other".into(), None).unwrap();
    let token = vthread_stack::ParkToken::new(100, 1);
    let hub = &shared.inboxes[0].hub;
    hub.register(token, Weak::new()).unwrap();
    hub.enqueue(WakeNotice {
        token,
        task: lock(&other).id,
        cause: WakeCause::Ready,
    });
    let observer = Arc::clone(&shared);
    let watched = Arc::clone(&record);
    let watchdog = std::thread::spawn(move || {
        let deadline = Instant::now() + Duration::from_millis(200);
        while observer.abort_reason(scope).is_none() && Instant::now() < deadline {
            std::thread::yield_now();
        }
        let reason = observer.abort_reason(scope);
        observer.complete(&watched, reason);
    });
    let result = shared.wait(scope, None);
    watchdog.join().unwrap();
    shared.complete(&other, Some(TaskFailure::SupervisorStopped));
    assert!(matches!(
        result.as_ref().map_err(crate::Error::primary),
        Err(Error::RuntimeStalled { active: 1 })
    ));
}

#[test]
fn unrelated_supervisor_activity_cannot_hide_a_stalled_root_scope() {
    use std::sync::{
        Arc,
        atomic::{AtomicBool, Ordering},
    };
    let runtime = Runtime::builder()
        .carriers(2)
        .stall_policy(crate::StallPolicy::AbortAfter(Duration::from_millis(10)))
        .build()
        .unwrap();
    let supervisor = runtime
        .supervisor_with(crate::ScopeOptions::default())
        .unwrap();
    let stop = Arc::new(AtomicBool::new(false));
    let worker_stop = Arc::clone(&stop);
    let mut busy = supervisor
        .spawn("unrelated", move || {
            while !worker_stop.load(Ordering::Acquire) {
                crate::yield_now().unwrap();
            }
        })
        .unwrap();
    let (parker, wake) = park_pair();
    let watchdog = std::thread::spawn(move || {
        std::thread::park_timeout(Duration::from_millis(200));
        wake.unpark();
    });
    let result = runtime.run_scope(|scope| {
        let _ = scope.spawn("ownerless", move || parker.park())?;
        Ok(())
    });
    stop.store(true, Ordering::Release);
    busy.join().unwrap();
    supervisor.shutdown().unwrap();
    watchdog.join().unwrap();
    assert!(matches!(
        result.as_ref().map_err(crate::Error::primary),
        Err(Error::RuntimeStalled { active: 1 })
    ));
    let stall = runtime.snapshot().last_stall.unwrap();
    assert_eq!(stall.tasks.len(), 1);
    assert_eq!(stall.tasks[0].name, "ownerless");
}

#[test]
fn a_terminal_sibling_does_not_hide_an_indefinitely_parked_child() {
    let runtime = Runtime::builder()
        .carriers(2)
        .stall_policy(crate::StallPolicy::AbortAfter(Duration::from_millis(10)))
        .build()
        .expect("runtime");
    let (parker, _unparker) = park_pair();
    let error = runtime
        .run_scope(|scope| {
            let _ = scope.spawn("parked", move || parker.park())?;
            scope.spawn("terminal", || 42)?.join()?;
            Ok(())
        })
        .expect_err("parked child must be reclaimed");
    assert!(matches!(
        error.primary(),
        Error::RuntimeStalled { active: 1 }
    ));
    assert_eq!(runtime.snapshot().active, 0);
    runtime
        .run_scope(|scope| scope.spawn("reused", || ())?.join())
        .expect("reusable");
}