vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use std::{
    panic,
    sync::{
        Arc,
        atomic::{AtomicBool, AtomicU8, AtomicUsize, Ordering},
        mpsc,
    },
    time::Duration,
};

use crate::{Error, Runtime, support_test::run_isolated};

const UNSET: u8 = 0;
const REJECTED: u8 = 1;
const SUSPENDED: u8 = 2;
const UNEXPECTED: u8 = 3;

struct YieldOnDrop(Arc<AtomicU8>);

impl Drop for YieldOnDrop {
    fn drop(&mut self) {
        let outcome = match crate::yield_now() {
            Err(Error::SuspensionDuringPanic) => REJECTED,
            Ok(()) => SUSPENDED,
            Err(_) => UNEXPECTED,
        };
        self.0.store(outcome, Ordering::SeqCst);
    }
}

#[test]
fn unwinding_task_cannot_expose_carrier_panic_state_to_sibling() {
    let runtime = Runtime::builder().carriers(1).build().unwrap();
    let drop_outcome = Arc::new(AtomicU8::new(UNSET));
    let sibling_panicking = Arc::new(AtomicBool::new(false));

    runtime
        .run_scope(|scope| {
            let (gate_entered, wait_for_gate) = mpsc::sync_channel(1);
            let (release_gate, gate_release) = mpsc::sync_channel(1);
            let mut gate = scope.spawn("admission gate", move || {
                gate_entered.send(()).unwrap();
                gate_release.recv_timeout(Duration::from_secs(5)).unwrap();
            })?;
            wait_for_gate.recv_timeout(Duration::from_secs(5)).unwrap();

            let task_outcome = Arc::clone(&drop_outcome);
            let mut unwinding = scope.spawn("unwinding", move || {
                let _yield_on_drop = YieldOnDrop(task_outcome);
                panic!("expected task panic");
            })?;
            let observed = Arc::clone(&sibling_panicking);
            let mut sibling = scope.spawn("sibling", move || {
                observed.store(std::thread::panicking(), Ordering::SeqCst);
            })?;
            release_gate.send(()).unwrap();

            gate.join()?;
            assert!(matches!(unwinding.join(), Err(Error::TaskPanicked { .. })));
            sibling.join()?;
            Ok(())
        })
        .unwrap();

    assert_eq!(
        (
            drop_outcome.load(Ordering::SeqCst),
            sibling_panicking.load(Ordering::SeqCst),
        ),
        (REJECTED, false),
        "an unwinding task transferred carrier panic state to its sibling"
    );
    runtime.shutdown().unwrap();
}

#[test]
fn panic_hook_cannot_transfer_control_to_another_task() {
    const CHILD: &str = "VTHREAD_PANIC_HOOK_SUSPENSION_CHILD";
    const TEST: &str = "panic_suspension_test::panic_hook_cannot_transfer_control_to_another_task";
    if std::env::var_os(CHILD).is_none() {
        let output = run_isolated(TEST, (CHILD, "1"), Duration::from_secs(15));
        let stdout = String::from_utf8_lossy(&output.stdout);
        let stderr = String::from_utf8_lossy(&output.stderr);
        assert!(
            output.status.success() && !output.timed_out && stdout.contains("1 passed"),
            "panic-hook suspension child failed: status={:?} timed_out={}\nstdout:\n{stdout}\nstderr:\n{stderr}",
            output.status,
            output.timed_out,
        );
        return;
    }

    let hook_calls = Arc::new(AtomicUsize::new(0));
    let hook_outcome = Arc::new(AtomicU8::new(UNSET));
    let observed_calls = Arc::clone(&hook_calls);
    let observed_outcome = Arc::clone(&hook_outcome);
    panic::set_hook(Box::new(move |_| {
        if observed_calls.fetch_add(1, Ordering::SeqCst) == 0 {
            let outcome = match crate::yield_now() {
                Err(Error::SuspensionDuringPanic) => REJECTED,
                Ok(()) => SUSPENDED,
                Err(_) => UNEXPECTED,
            };
            observed_outcome.store(outcome, Ordering::SeqCst);
        }
    }));

    let runtime = Runtime::builder().carriers(1).build().unwrap();
    runtime
        .run_scope(|scope| {
            let (gate_entered, wait_for_gate) = mpsc::sync_channel(1);
            let (release_gate, gate_release) = mpsc::sync_channel(1);
            let mut gate = scope.spawn("admission gate", move || {
                gate_entered.send(()).unwrap();
                gate_release.recv_timeout(Duration::from_secs(5)).unwrap();
            })?;
            wait_for_gate.recv_timeout(Duration::from_secs(5)).unwrap();

            let mut first = scope.spawn("first panic", move || {
                panic!("first expected panic");
            })?;
            let mut second = scope.spawn("second panic", || panic!("second expected panic"))?;
            release_gate.send(()).unwrap();
            gate.join()?;
            assert!(matches!(first.join(), Err(Error::TaskPanicked { .. })));
            assert!(matches!(second.join(), Err(Error::TaskPanicked { .. })));
            Ok(())
        })
        .unwrap();
    runtime.shutdown().unwrap();
    drop(panic::take_hook());

    assert_eq!(hook_calls.load(Ordering::SeqCst), 2);
    assert_eq!(hook_outcome.load(Ordering::SeqCst), REJECTED);
}