runite 0.1.0

An event-loop-per-thread async runtime built on io_uring (Linux), kqueue (macOS), and IOCP (Windows)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

//! macOS fd readiness backend.

use std::io;
use std::os::fd::RawFd;

use crate::op::completion::completion_for_current_thread;
use crate::platform::current::driver::FdInterest;
use crate::platform::current::runtime::{
    QueueError, cancel_fd_readiness, current_thread_handle, with_current_driver,
};

/// Waits until `fd` becomes readable or reports an error/hangup condition.
pub async fn wait_readable(fd: RawFd) -> io::Result<()> {
    wait_fd_readiness(fd, FdInterest::Readable).await
}

/// Waits until `fd` becomes writable or reports an error/hangup condition.
pub async fn wait_writable(fd: RawFd) -> io::Result<()> {
    wait_fd_readiness(fd, FdInterest::Writable).await
}

async fn wait_fd_readiness(fd: RawFd, interest: FdInterest) -> io::Result<()> {
    let (future, handle) = completion_for_current_thread::<io::Result<()>>();
    let owner = current_thread_handle();
    let token =
        with_current_driver(|driver| driver.register_fd_readiness(fd, interest, handle.clone()));
    match token {
        Ok(token) => {
            handle.set_cancel({
                let handle = handle.clone();
                move || {
                    let queued_handle = handle.clone();
                    let queued = owner.queue_macrotask(move || {
                        cancel_fd_readiness(token);
                        queued_handle.finish(None);
                    });
                    match queued {
                        Ok(()) => {}
                        Err(QueueError::Closed) => handle.finish(None),
                        Err(QueueError::Full) => {
                            // Cancellation must not block waiting for remote
                            // capacity; complete locally and leave driver
                            // cleanup to runtime shutdown.
                            tracing::error!(
                                target: crate::trace_targets::SCHEDULER,
                                event = "fd_cancel_dropped",
                                "dropping fd-readiness cancellation because the remote queue is full"
                            );
                            handle.finish(None);
                        }
                    }
                }
            });
        }
        Err(error) => {
            handle.complete(Err(error));
        }
    }

    future.await
}