vthread 0.1.0

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

use crate::{
    Error, JoinHandle, Runtime, ScopeOptions, SuspensionReason, TaskStatus, UnparkResult,
    options::TaskOptions,
    park_pair,
    support_test::{run_isolated, until},
    task::{SharedTaskRecord, TaskCell, TaskRecord},
};

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

struct JoinOnDrop<T> {
    handle: JoinHandle<T>,
    outcome: Arc<AtomicU8>,
}

struct DirectJoinOnDrop {
    record: SharedTaskRecord,
    outcome: Arc<AtomicU8>,
}

impl Drop for DirectJoinOnDrop {
    fn drop(&mut self) {
        let task = self.record.lock().id;
        let outcome = match super::wait_for(&self.record, SuspensionReason::Join(task), false) {
            Err(Error::SuspensionDuringPanic) => REJECTED,
            Ok(()) => WAITED,
            Err(_) => UNEXPECTED,
        };
        self.outcome.store(outcome, Ordering::SeqCst);
    }
}

fn unfinished_record_without_waiter_capacity() -> SharedTaskRecord {
    Arc::new(TaskCell::new(
        TaskRecord {
            id: crate::TaskId::new(u64::MAX),
            scope: u64::MAX,
            parent: None,
            options: Some(TaskOptions::root(ScopeOptions::default(), 1)),
            name: "unfinished completion".into(),
            carrier: crate::CarrierId(0),
            deadline: None,
            failure: None,
            status: TaskStatus::Queued,
            parks: 0,
            last_suspension: None,
            last_wake: None,
            outcome_observed: false,
            panic: None,
        },
        0,
    ))
}

impl<T> Drop for JoinOnDrop<T> {
    fn drop(&mut self) {
        let outcome = match self.handle.wait() {
            Err(Error::SuspensionDuringPanic) => REJECTED,
            Ok(()) => WAITED,
            Err(_) => UNEXPECTED,
        };
        self.outcome.store(outcome, Ordering::SeqCst);
    }
}

#[test]
fn a_virtual_join_parks_and_releases_the_single_carrier_for_other_work() {
    let runtime = Runtime::new().unwrap();
    runtime
        .run_scope(|scope| {
            let (parker, waker) = park_pair();
            let mut first = scope.spawn("target", move || {
                parker.park().unwrap();
                42
            })?;
            let mut joining = scope.spawn("joiner", move || first.join())?;
            until(|| scope.runtime_snapshot().parked == 2);
            let mut ready = scope.spawn("other work", move || waker.unpark())?;
            ready.join()?;
            assert_eq!(joining.join()??, 42);
            Ok(())
        })
        .unwrap();
}

#[test]
fn self_join_is_typed_misuse_without_corrupting_completion() {
    Runtime::new()
        .unwrap()
        .run_scope(|scope| {
            assert_eq!(
                scope
                    .spawn("self wait", || {
                        let mounted = crate::context::current().unwrap();
                        let execution = mounted.execution().unwrap();
                        let id = execution.record().lock().id;
                        assert!(matches!(
                            super::wait_for(
                                execution.record(),
                                crate::SuspensionReason::Join(id),
                                false
                            ),
                            Err(crate::Error::JoinSelf)
                        ));
                        42
                    })?
                    .join()?,
                42
            );
            Ok(())
        })
        .unwrap();
}

#[test]
fn panic_is_rejected_before_waiting_for_an_unfinished_join() {
    const CHILD: &str = "VTHREAD_PANIC_JOIN_CHILD";
    const TEST: &str =
        "join_wait::join_wait_test::panic_is_rejected_before_waiting_for_an_unfinished_join";
    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-join 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 outcome = Arc::new(AtomicU8::new(UNSET));
    runtime
        .run_scope(|scope| {
            let (parker, unparker) = park_pair();
            let target = scope.spawn("unfinished target", move || parker.park())?;
            until(|| scope.runtime_snapshot().parked == 1);

            let task_outcome = Arc::clone(&outcome);
            let mut panicking = scope.spawn("panic join", move || {
                let _join = JoinOnDrop {
                    handle: target,
                    outcome: task_outcome,
                };
                panic!("expected join panic");
            })?;
            assert!(matches!(panicking.join(), Err(Error::TaskPanicked { .. })));
            assert_eq!(unparker.unpark(), UnparkResult::Woke);
            Ok(())
        })
        .unwrap();

    assert_eq!(outcome.load(Ordering::SeqCst), REJECTED);
    assert_eq!(runtime.snapshot().active, 0);
    assert_eq!(runtime.snapshot().parked, 0);
    runtime.shutdown().unwrap();
}

#[test]
fn panic_join_is_rejected_before_completion_subscription() {
    let outcome = Arc::new(AtomicU8::new(UNSET));
    let task_outcome = Arc::clone(&outcome);
    let record = unfinished_record_without_waiter_capacity();
    Runtime::new()
        .unwrap()
        .run_scope(|scope| {
            let mut task = scope.spawn("panic direct join", move || {
                let _join = DirectJoinOnDrop {
                    record,
                    outcome: task_outcome,
                };
                panic!("expected direct join panic");
            })?;
            assert!(matches!(task.join(), Err(Error::TaskPanicked { .. })));
            Ok(())
        })
        .unwrap();

    assert_eq!(outcome.load(Ordering::SeqCst), REJECTED);
}