tokio-uring VS diesel_async

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.

So I want to use diesel_async in my web backend.

The already linked discussion from last time already contains a lot of information about this. Diesel itself does not provide async operations and that will likely remain that way for a foreseeable future. At least my preferred solution is to keep async support in a separate crate. A prototype for this is currently available here. Keep in mind that this is not released yet, so there might be bugs everywhere. I plan to cut a first release of this crate after the final release of diesel 2.0, which means hopefully soon. As for ETA's: I generally do not give any ETA's for releases, as this is currently a free time project for me.

So, diesel is an ORM that tries to take full advantage of rust's typing expressivity to allow for statically checked, and fast, queries. I absolutely loved it when trying it out the first time.

i don't see why you or anyone else would consider it too big of an issue that Diesel doesn't have async. For those who really want async diesel right now, the author already released diesel_async as a stop-gap solution, but even without that there's nothing wrong with using spawn_blocking. It feels worse than it really is to use blocking thread pools; until io_uring is a thing, there's no real getting around the necessity of threads being blocked for I/O and so adding async to the mix doesn't magically make things faster.

As for now there is an prototype available here. It's technically feature complete, but depends on a unpublished diesel version + has some remaining bugs with certain mysql versions. If that is fixed I will likely publish a first alpha version officially. That can take same time because that's a second large project that needs maintenance time beside diesel itself and that's quite a lot to do in my free time. You can support this work by sponsoring me on github

Async support for diesel currently lives in a separate repository as there are language level blocking issues for publishing a version of this crate where we could commit to a stable release at all. See the corresponding diesel issue for details.

https://github.com/weiznich/diesel_async tho'.

Weiznich (the maintainer of Diesel) has created an experimental async version of the diesel Connection and RunQueryDsl traits, which should help with ease-of-use for Diesel within async contexts. It is not yet published on crates, but you can find it here: https://github.com/weiznich/diesel_async