Compio

A thread-per-core Rust runtime with IOCP/io_uring/mio. The name comes from "completion-based IO". This crate is inspired by monoio.

Why not Tokio?

Tokio is a great generic-propose async runtime. However, it is poll-based, and even uses undocumented APIs on Windows. We would like some new high-level APIs to perform IOCP/io_uring.

Unlike tokio-uring, this runtime isn't Tokio-based. This is mainly because that no public APIs to control IOCP in mio, and tokio won't public APIs to control mio before mio reaches 1.0.

Quick start

With runtime feature enabled, we can use the high level APIs to perform fs & net IO.

```rust,norun use compio::{fs::File, task::blockon};

let buffer = blockon(async { let file = File::open("Cargo.toml").unwrap(); let (read, buffer) = file.readat(Vec::withcapacity(1024), 0).await; let read = read.unwrap(); asserteq!(read, buffer.len()); String::from_utf8(buffer).unwrap() }); println!("{}", buffer); ```

While you can also control the low-level driver manually:

```rust,no_run use compio::{ buf::IntoInner, driver::{AsRawFd, Driver, Poller}, fs::File, op::ReadAt, };

let mut driver = Driver::new().unwrap(); let file = File::open("Cargo.toml").unwrap(); // Attach the RawFd to driver first. driver.attach(file.asrawfd()).unwrap();

// Create operation and push it to the driver. let mut op = ReadAt::new(file.asrawfd(), 0, Vec::with_capacity(4096)); unsafe { driver.push(&mut op, 0) }.unwrap();

// Poll the driver and wait for IO completed. let entry = driver.pollone(None).unwrap(); asserteq!(entry.user_data(), 0);

// Resize the buffer by return value. let n = entry.intoresult().unwrap(); let mut buffer = op.intoinner().intoinner(); unsafe { buffer.setlen(n); }

println!("{}", String::from_utf8(buffer).unwrap()); ```