vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use super::{Kernel, REMOTE_ADMISSION_DISPATCH_BOUND};
use crate::{CarrierId, Runtime, TaskFailure, control::Shared};
use std::sync::{
    Arc,
    atomic::{AtomicBool, Ordering},
    mpsc,
};
use std::time::Duration;

#[test]
fn remote_starts_refill_a_bounded_runnable_window() {
    let config = Runtime::builder()
        .max_vthreads(65)
        .carrier_queue_capacity(65)
        .stack_cache_capacity(65)
        .build()
        .unwrap()
        .config();
    let shared = Arc::new(Shared::new(config));
    let scope = shared.begin_scope().unwrap();
    for _ in 0..65 {
        shared.submit(scope, "queued".into(), || ()).unwrap();
    }
    let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));

    assert!(kernel.receive());
    assert_eq!(kernel.ready.len(), 64);
    assert_eq!(kernel.inbox.pending(), 1);
    for _ in 0..32 {
        assert!(kernel.tick(true).unwrap());
        kernel.receive();
    }
    assert_eq!(kernel.ready.len(), 33);
    assert_eq!(kernel.inbox.pending(), 0);
    kernel.abort(None, TaskFailure::RuntimeStopped);
    shared.finish_scope(scope);
}

#[test]
fn published_depth_is_an_authoritative_receive_obligation() {
    let config = Runtime::builder()
        .max_vthreads(1)
        .carrier_queue_capacity(1)
        .stack_cache_capacity(1)
        .build()
        .unwrap()
        .config();
    let shared = Arc::new(Shared::new(config));
    let scope = shared.begin_scope().unwrap();
    let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
    shared.submit(scope, "published".into(), || ()).unwrap();

    assert!(!kernel.remote_pending());
    assert!(kernel.remote_receive_required());
    kernel.receive();
    assert_eq!(kernel.inbox.pending(), 0);
    assert!(kernel.tick(true).unwrap());
    assert_eq!(shared.scope_report(scope).completed, 1);
    shared.finish_scope(scope);
}

#[test]
fn yielding_window_cannot_starve_later_admissions() {
    let config = Runtime::builder()
        .max_vthreads(65)
        .carrier_queue_capacity(65)
        .stack_cache_capacity(65)
        .build()
        .unwrap()
        .config();
    let shared = Arc::new(Shared::new(config));
    let scope = shared.begin_scope().unwrap();
    for _ in 0..64 {
        shared
            .submit(scope, "yielding".into(), || {
                loop {
                    crate::yield_now().unwrap();
                }
            })
            .unwrap();
    }
    let later_ran = Arc::new(AtomicBool::new(false));
    let ran = Arc::clone(&later_ran);
    shared
        .submit(scope, "later".into(), move || {
            ran.store(true, Ordering::SeqCst);
        })
        .unwrap();
    let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
    kernel.receive();

    for _ in 0..REMOTE_ADMISSION_DISPATCH_BOUND - 1 {
        assert!(kernel.tick(true).unwrap());
        kernel.receive();
    }
    assert_eq!(kernel.inbox.pending(), 1);
    assert!(!later_ran.load(Ordering::SeqCst));

    assert!(kernel.tick(true).unwrap());
    kernel.receive();
    assert_eq!(kernel.inbox.pending(), 0);
    for _ in 0..65 {
        assert!(kernel.tick(true).unwrap());
        kernel.receive();
    }
    assert!(later_ran.load(Ordering::SeqCst));
    kernel.abort(None, TaskFailure::RuntimeStopped);
    shared.finish_scope(scope);
}

#[test]
fn an_empty_remote_queue_does_not_precharge_admission_pressure() {
    let config = Runtime::builder()
        .max_vthreads(65)
        .carrier_queue_capacity(65)
        .stack_cache_capacity(65)
        .build()
        .unwrap()
        .config();
    let shared = Arc::new(Shared::new(config));
    let scope = shared.begin_scope().unwrap();
    for _ in 0..64 {
        shared
            .submit(scope, "yielding".into(), || {
                loop {
                    crate::yield_now().unwrap();
                }
            })
            .unwrap();
    }
    let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
    assert!(!kernel.receive());

    for _ in 0..64 {
        assert!(kernel.tick(true).unwrap());
    }
    assert_eq!(kernel.admission_pressure, 0);

    shared.submit(scope, "later".into(), || ()).unwrap();
    assert!(kernel.receive());
    assert_eq!(kernel.inbox.pending(), 1);
    kernel.abort(None, TaskFailure::RuntimeStopped);
    shared.finish_scope(scope);
}

#[test]
fn pending_ingress_never_enters_the_signal_wait() {
    let config = Runtime::builder()
        .max_vthreads(1)
        .carrier_queue_capacity(1)
        .stack_cache_capacity(1)
        .build()
        .unwrap()
        .config();
    let shared = Arc::new(Shared::new(config));
    let scope = shared.begin_scope().unwrap();
    let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
    kernel.publish(crate::CarrierStatus::Running);
    shared.submit(scope, "queued".into(), || ()).unwrap();
    let observed = kernel.inbox.signal.version();
    let signal = Arc::clone(&kernel.inbox.signal);
    let (cancel, cancelled) = mpsc::channel();
    let rescue = std::thread::spawn(move || {
        if cancelled.recv_timeout(Duration::from_secs(1)).is_ok() {
            false
        } else {
            signal.notify();
            true
        }
    });

    kernel.wait_for_work(observed);
    let _ = cancel.send(());
    assert!(
        !rescue.join().unwrap(),
        "pending ingress entered signal wait"
    );
    assert_eq!(
        shared.snapshot().carriers[0].status,
        crate::CarrierStatus::Running
    );

    kernel.abort(None, TaskFailure::RuntimeStopped);
    shared.finish_scope(scope);
}