vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use crate::{CarrierId, RuntimeConfig, TaskFailure, control::Shared, kernel::Kernel};
use std::sync::{
    Arc,
    atomic::{AtomicUsize, Ordering},
};

struct DropCount(Arc<AtomicUsize>);
impl Drop for DropCount {
    fn drop(&mut self) {
        self.0.fetch_add(1, Ordering::SeqCst);
    }
}

#[test]
fn fault_cleanup_keeps_both_the_pending_packet_and_queued_packets_owned() {
    let shared = Arc::new(Shared::new(RuntimeConfig::default()));
    let scope = shared.begin_scope().expect("scope");
    let drops = Arc::new(AtomicUsize::new(0));
    for _ in 0..2 {
        let guard = DropCount(Arc::clone(&drops));
        shared
            .submit(scope, "unstarted".into(), move || drop(guard))
            .expect("submit");
    }
    let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
    kernel.pending = kernel.inbox.pop();
    kernel.abort(None, TaskFailure::CarrierFailed);
    assert_eq!(drops.load(Ordering::SeqCst), 2);
    assert_eq!(shared.snapshot().active, 0);
    assert!(
        shared
            .snapshot()
            .tasks
            .iter()
            .all(|task| task.failure == Some(TaskFailure::CarrierFailed))
    );
}

#[test]
fn fault_cleanup_reclaims_every_batch_drained_packet() {
    let shared = Arc::new(Shared::new(RuntimeConfig::default()));
    let scope = shared.begin_scope().expect("scope");
    let drops = Arc::new(AtomicUsize::new(0));
    for _ in 0..3 {
        let guard = DropCount(Arc::clone(&drops));
        shared
            .submit(scope, "drained".into(), move || drop(guard))
            .expect("submit");
    }
    let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
    assert_eq!(kernel.inbox.drain_into(&mut kernel.incoming, 3), 3);

    kernel.abort(None, TaskFailure::CarrierFailed);

    assert!(kernel.incoming.is_empty());
    assert_eq!(drops.load(Ordering::SeqCst), 3);
    assert_eq!(shared.snapshot().active, 0);
}

#[test]
fn delayed_abort_for_an_old_scope_preserves_every_new_scope_queue() {
    let shared = Arc::new(Shared::new(RuntimeConfig::default()));
    let old = shared.begin_scope().expect("old scope");
    shared.finish_scope(old);
    let current = shared.begin_scope().expect("new scope");
    let (parker, _unparker) = crate::park_pair();
    shared
        .submit(current, "parked".into(), move || parker.park())
        .expect("parked");
    shared
        .submit(current, "ready".into(), || ())
        .expect("ready");
    let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
    kernel.receive();
    kernel.tick(true).expect("park the first task");
    shared
        .submit(current, "queued".into(), || ())
        .expect("queued");

    kernel.abort(Some(old), TaskFailure::ScopeStalled);
    let snapshot = shared.snapshot();
    assert_eq!(snapshot.active, 3);
    assert_eq!(snapshot.parked, 1);
    assert_eq!(snapshot.runnable, 2);
    assert!(snapshot.tasks.iter().all(|task| task.failure.is_none()));
    kernel.abort(None, TaskFailure::RuntimeStopped);
}

#[test]
fn selective_abort_keeps_a_retained_in_flight_task_located() {
    let shared = Arc::new(Shared::new(RuntimeConfig::default()));
    let retained = shared.begin_scope().expect("retained scope");
    let aborted = shared
        .begin_owned(crate::ScopeOptions::default(), true)
        .expect("aborted scope");
    shared
        .submit(retained, "retained".into(), || ())
        .expect("retained task");
    shared
        .submit(aborted, "aborted".into(), || ())
        .expect("aborted task");
    let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
    kernel.receive();
    kernel.in_flight = kernel.ready.pop_front();
    let retained_key = kernel.in_flight.expect("retained in-flight task");

    kernel.abort(Some(aborted), TaskFailure::ScopeStalled);

    assert_eq!(kernel.in_flight, Some(retained_key));
    assert!(kernel.ready.is_empty());
    assert_eq!(shared.snapshot().active, 1);
    kernel.abort(None, TaskFailure::RuntimeStopped);
}

#[test]
fn selective_abort_reclaims_a_middle_wake_exactly_once() {
    let shared = Arc::new(Shared::new(RuntimeConfig::default()));
    let retained = shared.begin_scope().unwrap();
    let aborted = shared
        .begin_owned(crate::ScopeOptions::default(), true)
        .unwrap();
    for (index, scope) in [retained, aborted, retained, retained]
        .into_iter()
        .enumerate()
    {
        shared
            .submit(scope, format!("wake-{index}"), || ())
            .unwrap();
    }
    let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
    kernel.receive();
    let tasks = (0..4)
        .map(|_| kernel.ready.pop_front().unwrap())
        .collect::<Vec<_>>();
    for task in tasks {
        kernel.ready.push_wake(task);
    }

    assert!(kernel.abort(Some(aborted), TaskFailure::ScopeStalled));

    assert_eq!(shared.scope_report(aborted).aborted, 1);
    assert_eq!(kernel.ready.len(), 3);
    kernel.abort(None, TaskFailure::RuntimeStopped);
}

#[test]
fn selective_abort_restores_in_flight_identity_beside_wakes() {
    let shared = Arc::new(Shared::new(RuntimeConfig::default()));
    let retained = shared.begin_scope().unwrap();
    let aborted = shared
        .begin_owned(crate::ScopeOptions::default(), true)
        .unwrap();
    for index in 0..3 {
        shared
            .submit(retained, format!("retained-{index}"), || ())
            .unwrap();
    }
    let mut kernel = Kernel::new(shared, CarrierId(0));
    kernel.receive();
    kernel.in_flight = kernel.ready.pop_front();
    let retained = kernel.in_flight;
    let wakes = (0..2)
        .map(|_| kernel.ready.pop_front().unwrap())
        .collect::<Vec<_>>();
    for task in wakes {
        kernel.ready.push_wake(task);
    }

    assert!(kernel.abort(Some(aborted), TaskFailure::ScopeStalled));

    assert_eq!(kernel.in_flight, retained);
    assert_eq!(kernel.ready.len(), 2);
    kernel.abort(None, TaskFailure::RuntimeStopped);
}