vthread 0.0.1

Bounded carrier-affine virtual threads for Rust
Documentation
use crate::{
    CarrierId, RuntimeConfig, TaskFailure,
    control::Shared,
    kernel::{Kernel, Task},
    signal::lock,
    task_context::TaskContext,
    task_fiber::TaskFiber,
};
use std::{rc::Rc, sync::Arc, time::Duration};

#[test]
fn revoked_parked_stacks_release_registrations_before_timer_processing() {
    let shared = Arc::new(Shared::new(RuntimeConfig::default()));
    let scope = shared.begin_scope().unwrap();
    let record = shared.reserve(scope, "revoked".into(), None).unwrap();
    let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
    vthread_stack::fiber_scope(1, |fibers| {
        let lease = fibers
            .spawn(kernel.local.stacks.borrow_mut().acquire().unwrap(), || {
                let (parker, _waker) = crate::park_pair();
                parker.park_timeout(Duration::from_secs(5)).unwrap();
            })
            .unwrap();
        let data = Rc::new(TaskContext::new(lock(&record).options.clone(), 1));
        kernel.ready.push_back(Task {
            record: Arc::clone(&record),
            data,
            fiber: Some(TaskFiber::Borrowed(lease)),
        });
        kernel.tick().unwrap();
        assert_eq!(shared.snapshot().parked, 1);
    });
    kernel.tick().unwrap();
    let snapshot = shared.snapshot();
    assert_eq!(snapshot.active, 0);
    assert_eq!(snapshot.timers, 0);
    assert_eq!(snapshot.tasks[0].failure, Some(TaskFailure::ScopeClosed));
}