vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use crate::{
    Runtime,
    net::unix::{UnixListener, UnixStream},
    support_test::until,
};
use std::{net::Shutdown, sync::Arc};

#[test]
fn stream_backpressure_parks_the_writer_without_stopping_the_reader() {
    let runtime = Runtime::new().unwrap();
    let (reader, writer) = UnixStream::pair().unwrap();
    socket2::SockRef::from(&writer.inner)
        .set_send_buffer_size(4096)
        .unwrap();
    runtime
        .run_scope(|scope| {
            let mut send = scope.spawn("write", move || writer.write_all(&vec![7; 1024 * 1024]))?;
            until(|| runtime.snapshot().services.readiness_waits == 1);
            let mut receive = scope.spawn("read", move || {
                let mut buffer = vec![0; 1024 * 1024];
                reader.read_exact(&mut buffer)?;
                assert!(buffer.iter().all(|byte| *byte == 7));
                Ok::<_, crate::Error>(())
            })?;
            send.join()??;
            receive.join()??;
            Ok(())
        })
        .unwrap();
}

#[test]
fn unix_path_connect_is_delegated_and_accept_is_readiness_driven() {
    let path = std::env::temp_dir().join(format!("vthread-unix-{}.sock", std::process::id()));
    let _ = std::fs::remove_file(&path);
    let listener = UnixListener::bind(&path).unwrap();
    let runtime = Runtime::new().unwrap();
    runtime
        .run_scope(|scope| {
            let mut server = scope.spawn("accept", move || listener.accept().map(|pair| pair.0))?;
            let path = path.clone();
            let mut client = scope.spawn("connect", move || UnixStream::connect(path))?;
            let server = server.join()??;
            let client = client.join()??;
            client.shutdown(Shutdown::Write)?;
            scope
                .spawn("eof", move || server.read(&mut [0; 1]))?
                .join()??;
            Ok(())
        })
        .unwrap();
    std::fs::remove_file(path).unwrap();
}

#[test]
fn closing_a_shared_read_direction_wakes_its_parked_reader() {
    let runtime = Runtime::new().unwrap();
    let (reader, _writer) = UnixStream::pair().unwrap();
    let reader = Arc::new(reader);
    runtime
        .run_scope(|scope| {
            let socket = Arc::clone(&reader);
            let mut task = scope.spawn("read", move || socket.read(&mut [0; 1]))?;
            until(|| runtime.snapshot().services.readiness_waits == 1);
            reader.shutdown(Shutdown::Read)?;
            assert_eq!(task.join()??, 0);
            Ok(())
        })
        .unwrap();
}

#[test]
fn competing_readers_recheck_readiness_and_each_consume_one_byte() {
    let runtime = Runtime::builder().carriers(2).build().unwrap();
    let (reader, writer) = UnixStream::pair().unwrap();
    let reader = Arc::new(reader);
    runtime
        .run_scope(|scope| {
            let mut reads = Vec::new();
            for _ in 0..2 {
                let reader = Arc::clone(&reader);
                reads.push(scope.spawn("reader", move || {
                    let mut byte = [0; 1];
                    reader.read_exact(&mut byte)?;
                    Ok::<_, crate::Error>(byte[0])
                })?);
            }
            until(|| runtime.snapshot().services.readiness_waits == 2);
            scope
                .spawn("writer", move || writer.write_all(b"ab"))?
                .join()??;
            let mut values = Vec::new();
            for mut read in reads {
                values.push(read.join()??);
            }
            values.sort_unstable();
            assert_eq!(values, b"ab");
            Ok(())
        })
        .unwrap();
}