vthread 0.1.0

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

use crate::{Error, ParkOutcome, Runtime, TaskStatus, park_pair, yield_now};

#[test]
fn round_robin_mounts_are_visible() {
    let runtime = Runtime::new().expect("build runtime");
    let trace = Arc::new(Mutex::new(Vec::new()));

    runtime
        .run_scope(|scope| {
            let left_trace = Arc::clone(&trace);
            let mut left = scope.spawn("left", move || {
                left_trace.lock().expect("trace").push("left:1");
                yield_now().expect("mounted task");
                left_trace.lock().expect("trace").push("left:2");
                20
            })?;
            let right_trace = Arc::clone(&trace);
            let mut right = scope.spawn("right", move || {
                right_trace.lock().expect("trace").push("right:1");
                yield_now().expect("mounted task");
                right_trace.lock().expect("trace").push("right:2");
                22
            })?;

            assert_eq!(left.join()? + right.join()?, 42);
            let snapshot = scope.runtime_snapshot();
            assert_eq!(snapshot.stats.mounts, 4);
            assert_eq!(snapshot.stats.yields, 2);
            assert!(snapshot.tasks.iter().all(|task| task.mounts == 2));
            assert!(
                snapshot
                    .tasks
                    .iter()
                    .all(|task| task.last_suspension == Some(crate::SuspensionReason::YieldNow))
            );
            assert!(
                snapshot
                    .tasks
                    .iter()
                    .all(|task| task.status == TaskStatus::Completed)
            );
            Ok(())
        })
        .expect("scope succeeds");

    let trace = trace.lock().expect("trace");
    assert!(
        trace.iter().position(|entry| *entry == "left:1")
            < trace.iter().position(|entry| *entry == "left:2")
    );
    assert!(
        trace.iter().position(|entry| *entry == "right:1")
            < trace.iter().position(|entry| *entry == "right:2")
    );
}

#[test]
fn snapshots_resolve_the_task_mounted_on_its_owner_carrier() {
    use std::{sync::mpsc, time::Duration};

    let runtime = Runtime::new().expect("build runtime");
    runtime
        .run_scope(|scope| {
            let (started, mounted) = mpsc::sync_channel(0);
            let (release, gate) = mpsc::sync_channel(0);
            let mut task = scope.spawn("mounted", move || {
                started.send(()).unwrap();
                gate.recv_timeout(Duration::from_secs(5)).unwrap();
            })?;
            mounted.recv_timeout(Duration::from_secs(5)).unwrap();
            let status = runtime
                .snapshot()
                .tasks
                .into_iter()
                .find(|snapshot| snapshot.id == task.task_id())
                .map(|snapshot| snapshot.status);
            release.send(()).unwrap();
            task.join()?;
            assert_eq!(status, Some(TaskStatus::Running));
            Ok(())
        })
        .expect("scope succeeds");
}

#[test]
fn a_task_panic_does_not_stop_the_carrier() {
    let runtime = Runtime::new().expect("build runtime");
    runtime
        .run_scope(|scope| {
            let mut failed = scope.spawn("failed", || panic!("boom"))?;
            let mut healthy = scope.spawn("healthy", || 42)?;
            let error = failed.join().expect_err("panic becomes join error");
            assert!(matches!(error.primary(), Error::TaskPanicked { .. }));
            assert_eq!(healthy.join()?, 42);
            Ok(())
        })
        .expect("observed panic does not fail scope");
}

#[test]
fn panic_runs_stack_destructors() {
    struct DropFlag(Arc<AtomicBool>);

    impl Drop for DropFlag {
        fn drop(&mut self) {
            self.0.store(true, Ordering::SeqCst);
        }
    }

    let runtime = Runtime::new().expect("build runtime");
    let dropped = Arc::new(AtomicBool::new(false));
    let task_dropped = Arc::clone(&dropped);
    runtime
        .run_scope(|scope| {
            let mut failed = scope.spawn("failed", move || {
                let _flag = DropFlag(task_dropped);
                panic!("boom");
            })?;
            assert!(failed.join().is_err());
            Ok(())
        })
        .expect("panic is observed");
    assert!(dropped.load(Ordering::SeqCst));
}

#[test]
fn completed_stacks_are_reused_by_later_tasks() {
    let runtime = Runtime::builder()
        .stack_cache_capacity(1)
        .build()
        .expect("build runtime");
    runtime
        .run_scope(|scope| {
            scope.spawn("first", || ())?.join()?;
            scope.spawn("second", || ())?.join()?;
            Ok(())
        })
        .expect("scope succeeds");

    let stacks = runtime.snapshot().stacks;
    assert_eq!(stacks.allocated, 1);
    assert_eq!(stacks.reused, 1);
}

#[test]
fn a_stalled_parked_scope_is_cleaned_before_reuse() {
    let runtime = Runtime::builder()
        .stall_policy(crate::StallPolicy::AbortAfter(Duration::from_millis(10)))
        .build()
        .expect("build runtime");
    let (parker, _unparker) = park_pair();
    let parker = Arc::new(parker);
    let parked_parker = Arc::clone(&parker);
    let error = runtime
        .run_scope(|scope| {
            let _parked = scope.spawn("parked", move || parked_parker.park())?;
            Ok(())
        })
        .expect_err("an unowned indefinite park must stall");
    assert!(matches!(
        error.primary(),
        Error::RuntimeStalled { active: 1 }
    ));

    let snapshot = runtime.snapshot();
    assert_eq!(snapshot.active, 0);
    assert_eq!(snapshot.parked, 0);
    assert_eq!(snapshot.timers, 0);
    assert_eq!(snapshot.stats.aborted, 1);

    runtime
        .run_scope(|scope| {
            assert_eq!(scope.spawn("reused", || 42)?.join()?, 42);
            let reused_parker = Arc::clone(&parker);
            let mut parked = scope.spawn("park-again", move || {
                reused_parker.park_timeout(Duration::from_millis(1))
            })?;
            assert_eq!(parked.join()??, ParkOutcome::TimedOut);
            Ok(())
        })
        .expect("runtime and parker remain reusable");
}
#[test]
fn an_unjoined_result_destructor_panic_does_not_kill_the_carrier() {
    struct BadDrop;
    impl Drop for BadDrop {
        fn drop(&mut self) {
            panic!("result destructor");
        }
    }
    let runtime = crate::Runtime::new().unwrap();
    let (tx, rx) = std::sync::mpsc::sync_channel(1);
    let result = runtime.run_scope(|scope| {
        drop(scope.spawn("unjoined", move || {
            rx.recv_timeout(std::time::Duration::from_secs(5)).unwrap();
            BadDrop
        })?);
        tx.send(()).unwrap();
        Ok(())
    });
    assert!(matches!(
        result.as_ref().map_err(crate::Error::primary),
        Err(crate::Error::TaskPanicked { .. })
    ));
    runtime
        .run_scope(|scope| {
            assert_eq!(scope.spawn("still alive", || 42)?.join()?, 42);
            Ok(())
        })
        .unwrap();
}