vthread 0.1.0

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

#[test]
fn placement_rotates_between_equal_loads_and_respects_queue_capacity() {
    let config = Runtime::builder()
        .carriers(2)
        .carrier_queue_capacity(1)
        .build()
        .expect("config")
        .config();
    let shared = Shared::new(config);
    let scope = shared.begin_scope().expect("scope");
    shared.submit(scope, "left".into(), || ()).expect("left");
    shared.submit(scope, "right".into(), || ()).expect("right");
    let snapshot = shared.snapshot();
    assert_eq!(snapshot.tasks[0].carrier, CarrierId(0));
    assert_eq!(snapshot.tasks[1].carrier, CarrierId(1));
    assert!(matches!(
        shared.submit(scope, "full".into(), || ()),
        Err(Error::Capacity {
            resource: crate::error::CapacityResource::CarrierQueue,
            ..
        })
    ));
    assert_eq!(shared.snapshot().active, 2);
}

#[test]
fn placement_observes_retirement_within_one_carrier_cycle() {
    let config = Runtime::builder()
        .carriers(3)
        .carrier_queue_capacity(4)
        .build()
        .expect("config")
        .config();
    let shared = Shared::new(config);
    let scope = shared.begin_scope().expect("scope");
    let first = shared.reserve(scope, "first".into(), None).unwrap();
    let second = shared.reserve(scope, "second".into(), None).unwrap();
    let third = shared.reserve(scope, "third".into(), None).unwrap();

    assert_eq!(first.lock().carrier, CarrierId(0));
    assert_eq!(second.lock().carrier, CarrierId(1));
    assert_eq!(third.lock().carrier, CarrierId(2));

    shared.complete(&second, None);
    let bounded_lag = shared.reserve(scope, "bounded lag".into(), None).unwrap();
    let replacement = shared
        .reserve(scope, "retired carrier".into(), None)
        .unwrap();
    assert_eq!(replacement.lock().carrier, CarrierId(1));

    shared.complete(&first, None);
    shared.complete(&third, None);
    shared.complete(&bounded_lag, None);
    shared.complete(&replacement, None);
    shared.finish_scope(scope);
}

#[test]
fn completed_unobserved_records_are_bounded_and_join_restores_capacity() {
    let runtime = Runtime::builder()
        .max_vthreads(1)
        .stack_cache_capacity(1)
        .build()
        .expect("runtime");
    runtime
        .run_scope(|scope| {
            let mut first = scope.spawn("first", || 1)?;
            crate::support_test::until(|| first.is_finished());
            assert!(matches!(
                scope.spawn("unobserved", || 2),
                Err(Error::Capacity {
                    resource: crate::error::CapacityResource::Tasks,
                    limit: 1
                })
            ));
            assert_eq!(first.join()?, 1);
            assert_eq!(scope.spawn("next", || 2)?.join()?, 2);
            assert_eq!(scope.runtime_snapshot().tasks.len(), 1);
            Ok(())
        })
        .expect("scope");
}

#[test]
fn names_are_bounded_and_whitespace_is_preserved() {
    let runtime = crate::Runtime::new().unwrap();
    runtime
        .run_scope(|scope| {
            assert!(matches!(
                scope.spawn("é".repeat(65), || ()),
                Err(Error::LimitExceeded { limit: 128, .. })
            ));
            let mut task = scope.spawn("  intentional name  ", || ())?;
            task.wait()?;
            assert_eq!(
                scope.runtime_snapshot().tasks()[0].name(),
                "  intentional name  "
            );
            task.join()?;
            Ok(())
        })
        .unwrap();
}

#[test]
fn admission_without_stall_detection_does_not_publish_a_control_change() {
    let shared = Shared::new(Runtime::builder().build().unwrap().config());
    let scope = shared.begin_scope().unwrap();
    let observed = shared.changed.version();

    let record = shared
        .reserve(scope, "quiet admission".into(), None)
        .unwrap();
    assert_eq!(shared.changed.version(), observed);

    shared.complete(&record, None);
    shared.finish_scope(scope);
}

#[test]
fn admission_notifies_enabled_stall_detection() {
    let config = Runtime::builder()
        .stall_policy(StallPolicy::ReportAfter(Duration::from_secs(1)))
        .build()
        .unwrap()
        .config();
    let shared = Shared::new(config);
    let scope = shared.begin_scope().unwrap();
    let observed = shared.changed.version();

    let record = shared
        .reserve(scope, "observed admission".into(), None)
        .unwrap();
    assert!(shared.changed.version() > observed);

    shared.complete(&record, None);
    shared.finish_scope(scope);
}