tokio-uring VS liburing

While Mio will probably not implement uring in its current design, there's https://github.com/tokio-rs/tokio-uring if you want to use io_uring in Rust.

It's still in development, but the Tokio team seems intent on getting good io_uring support at least!

As the README states, the Rust implementation requires a kernel newer than the one that shipped with Ubuntu 20.04 so I think it'll be a while before we'll see significant development among major libraries.

That's what the pool is for: https://github.com/tokio-rs/tokio-uring/blob/master/src/buf/fixed/pool.rs

Tokio supports io_uring (https://github.com/tokio-rs/tokio-uring), so perhaps when it's mature and battle-tested, it'd be easier to transition to it if Cloudflare aren't using it already.

- Tokio suffers from a similar problem

Eg via tokio-uring.

I strongly recommend you to look into io-uring and use async executors that take advantages of it: - tokio-uring (not recommended as it is still undergoing development) - monoio - glommio

This is my thinking as well. Specifically, I realized that if you don’t use tasks, but rather futures and join, than structured concurrency just works out (at the cost of less efficient poll). In a single-threaded/thread-per-core runtime, tasks could have the same semantics as futures. Somewhat elaborated here: https://github.com/tokio-rs/tokio-uring/issues/81

There's a new API on Linux called io_uring that has performance benefits, but most executors don't use it yet, except executors meant specifically to harness the power of io_uring like tokio-uring and Glommio

Breaking it down a bit further- Rust's async is zero-cost, and there's no way to write faster equivalent code to the language construct in Rust (and presumably other LLVM languages). Tokio introduces abstractions over OS APIs (indirectly) and provides a runtime. The runtime isn't zero cost, but it is likely to be better optimized for "standard" situations than a homebrewed solution, and its primary competition is in the form of other large async runtimes. On the other hand, Tokio's IO routines are (AFAIK) about as well written as one can get with blocking OS APIs, and the only competitors in that space are projects like tokio-uring that use APIs more well suited for asynchronous usage.

I've tinkered around with io_uring on and off for the last couple years. But I think it's really becoming quite cool (not that it wasn't cool before... :)). This was a really interesting post on what's new https://github.com/axboe/liburing/wiki/io_uring-and-networki.... The combination of ring-mapped buffers and multi-shot operations has some really interesting applications for high-performance networking. Hoping over the next year or two we can start to see really bleeding edge networking perf without having to resort to using DPDK :)

Thought I was doing something wrong at first, but after looking at examples and code, I just wasn't able to reach the epoll numbers. Looking on the Github page, there a few issues there with people who found the same thing, with their own examples. #1, #2

To address my own silly questions, yes, one should use the new fixed buffers described in this document: https://github.com/axboe/liburing/wiki/io_uring-and-networki...

We're working on this! https://github.com/axboe/liburing/issues/830

Link: https://github.com/axboe/liburing/wiki/io_uring-and-networking-in-2023