vthread 0.1.0

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

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

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

struct ParkOnDrop {
    parker: Arc<crate::parking::Parker>,
    outcome: Arc<AtomicU8>,
}

impl Drop for ParkOnDrop {
    fn drop(&mut self) {
        let outcome = match self.parker.park_timeout(Duration::from_secs(30)) {
            Err(Error::SuspensionDuringPanic) => REJECTED,
            Ok(_) => SUSPENDED,
            Err(_) => UNEXPECTED,
        };
        self.outcome.store(outcome, Ordering::SeqCst);
    }
}

#[test]
fn rejected_panic_park_leaves_no_wait_timer_or_wake_state() {
    const CHILD: &str = "VTHREAD_PANIC_PARK_CHILD";
    const TEST: &str = "panic_parking_test::rejected_panic_park_leaves_no_wait_timer_or_wake_state";
    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-park child failed: status={:?} timed_out={}\nstdout:\n{stdout}\nstderr:\n{stderr}",
            output.status,
            output.timed_out,
        );
        return;
    }

    let runtime = Runtime::builder().carriers(1).build().unwrap();
    let (parker, unparker) = crate::parking::park_pair();
    let parker = Arc::new(parker);
    let drop_outcome = Arc::new(AtomicU8::new(UNSET));
    let sibling_panicking = Arc::new(AtomicBool::new(false));
    let wake_outcome = Arc::new(AtomicU8::new(UNSET));

    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_parker = Arc::clone(&parker);
            let task_outcome = Arc::clone(&drop_outcome);
            let mut unwinding = scope.spawn("panic park", move || {
                let _park_on_drop = ParkOnDrop {
                    parker: task_parker,
                    outcome: task_outcome,
                };
                panic!("expected task panic");
            })?;
            let observed = Arc::clone(&sibling_panicking);
            let observed_wake = Arc::clone(&wake_outcome);
            let mut sibling = scope.spawn("wake sibling", move || {
                observed.store(std::thread::panicking(), Ordering::SeqCst);
                let outcome = match unparker.unpark() {
                    UnparkResult::Stored => REJECTED,
                    UnparkResult::Woke | UnparkResult::Closed => SUSPENDED,
                };
                observed_wake.store(outcome, Ordering::SeqCst);
            })?;
            release_gate.send(()).unwrap();

            gate.join()?;
            assert!(matches!(unwinding.join(), Err(Error::TaskPanicked { .. })));
            sibling.join()?;
            let mut permit_consumer = scope.spawn("permit consumer", {
                let parker = Arc::clone(&parker);
                move || parker.park()
            })?;
            assert_eq!(permit_consumer.join()??, ParkOutcome::Ready);
            Ok(())
        })
        .unwrap();

    assert_eq!(
        (
            drop_outcome.load(Ordering::SeqCst),
            wake_outcome.load(Ordering::SeqCst),
            sibling_panicking.load(Ordering::SeqCst),
        ),
        (REJECTED, REJECTED, false),
        "panic-time park published wait state or transferred panic state"
    );
    assert_drained(&runtime);
    runtime.shutdown().unwrap();
}

#[test]
fn rejected_panic_park_preserves_a_stored_permit() {
    const CHILD: &str = "VTHREAD_PANIC_STORED_PERMIT_CHILD";
    const TEST: &str = "panic_parking_test::rejected_panic_park_preserves_a_stored_permit";
    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"),
            "stored-permit child failed: status={:?} timed_out={}\nstdout:\n{stdout}\nstderr:\n{stderr}",
            output.status,
            output.timed_out,
        );
        return;
    }

    let runtime = Runtime::builder().carriers(1).build().unwrap();
    let (parker, unparker) = crate::parking::park_pair();
    let parker = Arc::new(parker);
    let outcome = Arc::new(AtomicU8::new(UNSET));
    assert_eq!(unparker.unpark(), UnparkResult::Stored);

    runtime
        .run_scope(|scope| {
            let task_parker = Arc::clone(&parker);
            let task_outcome = Arc::clone(&outcome);
            let mut failed = scope.spawn("panic with stored permit", move || {
                let _park = ParkOnDrop {
                    parker: task_parker,
                    outcome: task_outcome,
                };
                panic!("expected stored-permit panic");
            })?;
            assert!(matches!(failed.join(), Err(Error::TaskPanicked { .. })));

            let mut consume = scope.spawn("consume preserved permit", {
                let parker = Arc::clone(&parker);
                move || parker.park()
            })?;
            assert_eq!(consume.join()??, ParkOutcome::Ready);
            Ok(())
        })
        .unwrap();

    assert_eq!(outcome.load(Ordering::SeqCst), REJECTED);
    assert_drained(&runtime);
    runtime.shutdown().unwrap();
}

struct RegisteredParkOnDrop {
    parker: Arc<crate::parking::Parker>,
    callbacks: Arc<AtomicUsize>,
    outcome: Arc<AtomicU8>,
}

impl Drop for RegisteredParkOnDrop {
    fn drop(&mut self) {
        let callbacks = Arc::clone(&self.callbacks);
        let outcome = match self.parker.park_registered(move |_, _| {
            callbacks.fetch_add(1, Ordering::SeqCst);
            Ok(())
        }) {
            Err(Error::SuspensionDuringPanic) => REJECTED,
            Ok(_) => SUSPENDED,
            Err(_) => UNEXPECTED,
        };
        self.outcome.store(outcome, Ordering::SeqCst);
    }
}

#[test]
fn panic_park_is_rejected_before_registration_or_generation_publication() {
    const CHILD: &str = "VTHREAD_PANIC_REGISTRATION_CHILD";
    const TEST: &str =
        "panic_parking_test::panic_park_is_rejected_before_registration_or_generation_publication";
    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-registration child failed: status={:?} timed_out={}\nstdout:\n{stdout}\nstderr:\n{stderr}",
            output.status,
            output.timed_out,
        );
        return;
    }

    let runtime = Runtime::builder().carriers(1).build().unwrap();
    let (parker, unparker) = crate::parking::park_pair();
    let parker = Arc::new(parker);
    let callbacks = Arc::new(AtomicUsize::new(0));
    let outcome = Arc::new(AtomicU8::new(UNSET));

    runtime
        .run_scope(|scope| {
            let task_parker = Arc::clone(&parker);
            let task_callbacks = Arc::clone(&callbacks);
            let task_outcome = Arc::clone(&outcome);
            let mut failed = scope.spawn("panic registration", move || {
                let _park = RegisteredParkOnDrop {
                    parker: task_parker,
                    callbacks: task_callbacks,
                    outcome: task_outcome,
                };
                panic!("expected registration panic");
            })?;
            assert!(matches!(failed.join(), Err(Error::TaskPanicked { .. })));

            let (registered, registration) = mpsc::sync_channel(1);
            let mut normal = scope.spawn("first real generation", {
                let parker = Arc::clone(&parker);
                move || {
                    parker.park_registered(move |token, _| {
                        registered.send(token.generation()).unwrap();
                        Ok(())
                    })
                }
            })?;
            assert_eq!(
                registration.recv_timeout(Duration::from_secs(5)).unwrap(),
                1
            );
            assert_eq!(unparker.unpark(), UnparkResult::Woke);
            assert_eq!(normal.join()??, ParkOutcome::Ready);
            Ok(())
        })
        .unwrap();

    assert_eq!(outcome.load(Ordering::SeqCst), REJECTED);
    assert_eq!(callbacks.load(Ordering::SeqCst), 0);
    assert_drained(&runtime);
    runtime.shutdown().unwrap();
}

fn assert_drained(runtime: &Runtime) {
    let snapshot = runtime.snapshot();
    assert_eq!(snapshot.active, 0);
    assert_eq!(snapshot.parked, 0);
    assert_eq!(snapshot.timers, 0);
    assert!(
        snapshot
            .carriers
            .iter()
            .all(|carrier| carrier.pending_wakes == 0)
    );
}