linux-aio-tokio

This package provides an integration of Linux kernel-level asynchronous I/O to the Tokio platform.

Linux kernel-level asynchronous I/O is different from the Posix AIO library. Posix AIO is implemented using a pool of userland threads, which invoke regular, blocking system calls to perform file I/O. Linux kernel-level AIO, on the other hand, provides kernel-level asynchronous scheduling of I/O operations to the underlying block device.

Usage

Add this to your Cargo.toml:

[dependencies]
linux-aio-tokio = "0.2"

Examples

```rust use tempfile::tempdir;

use linuxaiotokio::{aio_context, AioOpenOptionsExt, LockedBuf, ReadFlags, WriteFlags}; use std::fs::OpenOptions;

[tokio::main]

async fn main() { let (aio, aiohandle) = aiocontext(8).unwrap();

let dir = tempdir().unwrap();

let mut open_options = OpenOptions::new();
open_options
    .read(true)
    .create_new(true)
    .append(true)
    .write(true);

let file = open_options
    .aio_open(dir.path().join("tmp"), false)
    .await
    .unwrap();

let mut write_buf = LockedBuf::with_size(1024).unwrap();

for i in 0..write_buf.size() {
    write_buf.as_mut()[i] = (i % 0xff) as u8;
}

let (_, write_buf) = file
    .write_at(&aio_handle, 0, write_buf, WriteFlags::APPEND)
    .await
    .unwrap();

let read_buf = LockedBuf::with_size(1024).unwrap();

let (_, read_buf) = file
    .read_at(&aio_handle, 0, read_buf, ReadFlags::empty())
    .await
    .unwrap();

assert_eq!(read_buf.as_ref(), write_buf.as_ref());

aio.close().await;

println!("all good!");

} ```

License

This code is licensed under the MIT license.

Credits

The current implementation is based on the code created by Hans-Martin Will, available at GitHub repository.