CompleteIo

A thread-per-core Rust IO drivers and async runtime backed by IOCP/io_uring/mio. The name comes from "completion-based IO".

This repository is a fork of compio.

Why not Compio?

The project has different goals:

• provide low overhead IO drivers that preallocate memory on initialization

• drivers API accepts non-'static IO buffers

  • drivers don't own buffers
  • buffers are required to be Unpin

• bias towards IoUring API to achieve zero-cost abstraction on Linux:

  • fixed size submission queue for operations
  • external runtime could submit an external queue of not yet queued operations as a single batch
  • timers are exposed as Timeout operation and use suspend-aware CLOCK_BOOTTIME clock source when it's available

• Async runtime is an example runtime to test implementation of drivers

Quick start

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

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

let buffer = blockon(async { let file = File::open("Cargo.toml").unwrap(); let (read, buffer) = file.readtoendat(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 arrayvec::ArrayVec; use std::collections::VecDeque; use completeio::{ buf::IntoInner, driver::{AsRawFd, Driver, Entry, CompleteIo}, 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::withcapacity(4096)); let mut ops = VecDeque::from([(&mut op, 0).into()]); driver.pushqueue(&mut ops);

// Poll the driver and wait for IO completed. let mut entries = ArrayVec::::new(); unsafe { driver .submitandwaitcompleted(None, &mut entries) .unwrap(); } let entry = entries.drain(..).next().unwrap(); asserteq!(entry.user_data(), 0);

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

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