vthread 0.0.1

Bounded carrier-affine virtual threads for Rust
Documentation
use super::Mutex;
use crate::{Error, Runtime, local_scope, yield_now};
use std::{sync::Arc, thread};

#[test]
fn single_carrier_contention_is_fifo_and_guards_can_yield() {
    Runtime::new()
        .unwrap()
        .run_scope(|scope| {
            scope
                .spawn("parent", || {
                    let mutex = Mutex::with_wait_capacity(Vec::new(), 4).unwrap();
                    let guard = mutex.lock().unwrap();
                    local_scope(|local| {
                        let mut children = Vec::new();
                        for i in 0..4 {
                            let mutex = &mutex;
                            children.push(local.spawn("contender", move || {
                                let owner = thread::current().id();
                                let mut guard = mutex.lock().unwrap();
                                yield_now().unwrap();
                                assert_eq!(owner, thread::current().id());
                                guard.push(i);
                            })?);
                            while mutex.waiting() != i + 1 {
                                yield_now()?;
                            }
                        }
                        drop(guard);
                        assert!(matches!(mutex.try_lock(), Err(Error::WouldBlock)));
                        for mut child in children {
                            child.join()?;
                        }
                        Ok(())
                    })
                    .unwrap();
                    assert_eq!(*mutex.lock().unwrap(), vec![0, 1, 2, 3]);
                })?
                .join()
        })
        .unwrap();
}

#[test]
fn multiple_carriers_exclude_each_other_and_preserve_updates() {
    let runtime = Runtime::builder().carriers(4).build().unwrap();
    let mutex = Arc::new(Mutex::with_wait_capacity(0, 16).unwrap());
    runtime
        .run_scope(|scope| {
            let mut children = Vec::new();
            for _ in 0..16 {
                let mutex = Arc::clone(&mutex);
                children.push(scope.spawn("increment", move || {
                    for _ in 0..64 {
                        let mut value = mutex.lock().unwrap();
                        let before = *value;
                        yield_now().unwrap();
                        *value = before + 1;
                    }
                })?);
            }
            for mut child in children {
                child.join()?;
            }
            Ok(())
        })
        .unwrap();
    assert_eq!(*mutex.try_lock().unwrap(), 1024);
}

#[test]
fn panic_unlocks_and_returns_the_modified_value_without_poisoning() {
    let runtime = Runtime::new().unwrap();
    let mutex = Arc::new(Mutex::with_wait_capacity(0, 1).unwrap());
    runtime
        .run_scope(|scope| {
            let shared = Arc::clone(&mutex);
            let mut task = scope.spawn("panic", move || {
                *shared.lock().unwrap() = 42;
                let _guard = shared.lock().unwrap();
                panic!("owner failed");
            })?;
            assert!(matches!(task.join(), Err(Error::TaskPanicked { .. })));
            Ok(())
        })
        .unwrap();
    assert_eq!(*mutex.try_lock().unwrap(), 42);
}

#[test]
fn local_mutexes_can_protect_borrowed_non_send_values() {
    use std::{cell::Cell, rc::Rc};
    Runtime::new()
        .unwrap()
        .run_scope(|scope| {
            scope
                .spawn("parent", || {
                    let value = Rc::new(Cell::new(0));
                    let mutex = Mutex::with_wait_capacity(&value, 1).unwrap();
                    local_scope(|local| {
                        local
                            .spawn("borrower", || {
                                let guard = mutex.lock().unwrap();
                                yield_now().unwrap();
                                guard.set(42);
                            })?
                            .join()
                    })
                    .unwrap();
                    assert_eq!(value.get(), 42);
                })?
                .join()
        })
        .unwrap();
}