vthread 0.0.1

Bounded carrier-affine virtual threads for Rust
Documentation
use super::Semaphore;
use crate::{Error, Runtime, local_scope, yield_now};
use std::cell::RefCell;

#[test]
fn cancelling_a_selected_waiter_returns_its_permit_to_the_next_waiter() {
    Runtime::new()
        .unwrap()
        .run_scope(|scope| {
            scope
                .spawn("parent", || {
                    let semaphore = Semaphore::with_wait_capacity(1, 2).unwrap();
                    let permit = semaphore.try_acquire().unwrap();
                    let token = RefCell::new(None);
                    local_scope(|local| {
                        let mut first = local.spawn("cancelled", || {
                            *token.borrow_mut() = Some(crate::cancellation_token().unwrap());
                            semaphore.acquire().map(drop)
                        })?;
                        let mut second =
                            local.spawn("successor", || semaphore.acquire().map(drop))?;
                        while semaphore.waiting() != 2 {
                            yield_now()?;
                        }
                        drop(permit);
                        token.borrow().as_ref().unwrap().cancel();
                        assert!(matches!(first.join()?, Err(Error::Cancelled)));
                        second.join()??;
                        Ok(())
                    })
                    .unwrap();
                    assert_eq!(semaphore.waiting(), 0);
                    assert_eq!(semaphore.available_permits(), 1);
                })?
                .join()
        })
        .unwrap();
}

#[test]
fn close_fails_waiters_and_held_permits_cannot_reopen_it() {
    Runtime::new()
        .unwrap()
        .run_scope(|scope| {
            scope
                .spawn("parent", || {
                    let semaphore = Semaphore::with_wait_capacity(1, 1).unwrap();
                    let permit = semaphore.try_acquire().unwrap();
                    local_scope(|local| {
                        let mut waiter =
                            local.spawn("waiting", || semaphore.acquire().map(drop))?;
                        while semaphore.waiting() == 0 {
                            yield_now()?;
                        }
                        semaphore.close();
                        assert!(matches!(waiter.join()?, Err(Error::Closed)));
                        Ok(())
                    })
                    .unwrap();
                    drop(permit);
                    assert!(semaphore.is_closed());
                    assert_eq!(semaphore.available_permits(), 0);
                })?
                .join()
        })
        .unwrap();
}

#[test]
fn waiter_overflow_is_explicit_and_nonblocking_callers_do_not_barge() {
    Runtime::new()
        .unwrap()
        .run_scope(|scope| {
            scope
                .spawn("parent", || {
                    let semaphore = Semaphore::with_wait_capacity(1, 1).unwrap();
                    let permit = semaphore.try_acquire().unwrap();
                    local_scope(|local| {
                        let mut waiter = local.spawn("first", || semaphore.acquire().map(drop))?;
                        while semaphore.waiting() == 0 {
                            yield_now()?;
                        }
                        assert!(matches!(
                            semaphore.acquire(),
                            Err(Error::Capacity {
                                resource: crate::error::CapacityResource::Waiters,
                                limit: 1
                            })
                        ));
                        drop(permit);
                        assert!(matches!(semaphore.try_acquire(), Err(Error::WouldBlock)));
                        waiter.join()??;
                        Ok(())
                    })
                    .unwrap();
                })?
                .join()
        })
        .unwrap();
}

#[test]
fn multiple_permits_bound_concurrent_holders_across_carriers() {
    use std::sync::{
        Arc,
        atomic::{AtomicUsize, Ordering},
    };
    let runtime = Runtime::builder().carriers(4).build().unwrap();
    let semaphore = Arc::new(Semaphore::with_wait_capacity(3, 16).unwrap());
    let holders = Arc::new(AtomicUsize::new(0));
    runtime
        .run_scope(|scope| {
            let mut tasks = Vec::new();
            for _ in 0..16 {
                let semaphore = Arc::clone(&semaphore);
                let holders = Arc::clone(&holders);
                tasks.push(scope.spawn("holder", move || {
                    for _ in 0..32 {
                        let _permit = semaphore.acquire().unwrap();
                        assert!(holders.fetch_add(1, Ordering::SeqCst) < 3);
                        yield_now().unwrap();
                        holders.fetch_sub(1, Ordering::SeqCst);
                    }
                })?);
            }
            for mut task in tasks {
                task.join()?;
            }
            Ok(())
        })
        .unwrap();
    assert_eq!(holders.load(Ordering::SeqCst), 0);
    assert_eq!(semaphore.available_permits(), 3);
    assert_eq!(semaphore.waiting(), 0);
}