Monoio
A thread-per-core Rust runtime with io_uring.
Design Goal
As a runtime based on io_uring, Monoio is designed to be the most efficient and performant Rust runtime.
For some use cases, it is not necessary to make task schedulable between threads. For example, if we want to implement a load balancer like nginx, we may want to write it in a thread-per-core way. The thread local data need not to be shared between threads, so the Sync and Send will not have to be implemented.
Also, the Monoio is designed to be efficient. To achieve this goal, we enabled many Rust unstable features like GAT; and we designed a whole new IO abstraction to avoid copying, which may cause some compatibility problems.
Our benchmark shows that Monoio has a better performance than other common Rust runtimes.
Quick Start
To use monoio, you need the latest nightly rust toolchain. If you already installed it, please make sure it is the latest version.
To force using nightly, create a file named rust-toolchain and write nightly in it. Also, you can use cargo +nightly to build or run.
Here is a basic exmaple of how to use Monoio.
/// A echo example.
///
/// Run the example and `nc 127.0.0.1 50002` in another shell.
/// All your input will be echoed out.
use monoio::io::{AsyncReadRent, AsyncWriteRentExt};
use monoio::net::{TcpListener, TcpStream};
#[monoio::main]
async fn main() {
let listener = TcpListener::bind("127.0.0.1:50002").unwrap();
println!("listening");
loop {
let incoming = listener.accept().await;
match incoming {
Ok((stream, addr)) => {
println!("accepted a connection from {}", addr);
monoio::spawn(echo(stream));
}
Err(e) => {
println!("accepted connection failed: {}", e);
return;
}
}
}
}
async fn echo(stream: TcpStream) -> std::io::Result<()> {
let mut buf: Vec<u8> = Vec::with_capacity(8 * 1024);
loop {
// read
let (res, _buf) = stream.read(buf).await;
buf = _buf;
let res: usize = res?;
if res == 0 {
return Ok(());
}
// write all
let (res, _buf) = stream.write_all(buf).await;
buf = _buf;
res?;
// clear
buf.clear();
}
}
Limitations
- Since we rely on io_uring, currently monoio depends on Linux 5.6 or later. Epoll or other multiplex I/O will be supported soon.
- Monoio can not solve all problems. If the workload is very unbalanced, it may cause performance degradation than Tokio since CPU cores may not be fully utilized.
Contributors
Thanks for their contributions!
Licenses
Monoio is licensed under the MIT license or Apache license.
During developing we referenced a lot from Tokio, Mio, Tokio-uring and other related projects. We would like to thank the authors of these projects.
338 Jan 1, 2023
34 Apr 17, 2023
169 Jan 8, 2023
10 Dec 10, 2021
7.6k Dec 31, 2022
189 Dec 25, 2022
11 Jun 3, 2021
3.5k Jan 6, 2023
13 Aug 23, 2022
229 Nov 27, 2022
73 Dec 26, 2022
3 Jan 4, 2023
2 Dec 15, 2022
12 Jan 21, 2023
22 Jan 7, 2023
4 Feb 9, 2023
4 May 20, 2023
30 Aug 24, 2022
6 Dec 22, 2021