ringcore 0.1.0

A minimal async runtime built on Linux io_uring, designed to expose how Rust futures map to kernel I/O.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

//! # RingCore
//! 
//! A minimalist async runtime powered by Linux's `io_uring`.
//! 
//! RingCore provides a transparent, "from-scratch" implementation of an asynchronous
//! runtime. It is designed for educational purposes and high-performance I/O tasks
//! where transparency over the underlying kernel operations is preferred.
//! 
//! ## Key Components
//! - `executor`: A single-threaded task scheduler and event loop.
//! - `ring`: Low-level abstraction over the `io_uring` submission and completion queues.
//! - `op`: Asynchronous operations (read, write, accept, etc.) that map to `io_uring` SQEs.
//! - `net`/`fs`: High-level wrappers for networking and file system operations.
//! 
//! ## Example: Simple Echo Server
//! ```no_run
//! use ringcore::{run, spawn, TcpListener};
//! 
//! fn main() {
//!     spawn(async {
//!         let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
//!         loop {
//!             let (stream, _) = listener.accept().await.unwrap();
//!             spawn(async move {
//!                 let mut buf = [0u8; 1024];
//!                 let n = stream.read(&mut buf).await.unwrap();
//!                 stream.write(&buf[..n]).await.unwrap();
//!             });
//!         }
//!     });
//!     run();
//! }
//! ```

#![warn(missing_docs)]

pub mod sys;
pub mod ring;
pub mod executor;
pub mod op;
pub mod net;
pub mod fs;

pub use executor::{run, spawn, init, RING};
pub use net::{TcpListener, TcpStream};
pub use fs::File;