Struct UringIO 

pub struct UringIO { /* private fields */ }

Implementations

impl UringIO

pub fn new() -> Result<Self>

Trait Implementations

impl Clock for UringIO

fn current_time_monotonic(&self) -> MonotonicInstant

Monotonic time for timeout checking and elapsed time measurement. Cheap on real systems (reads TSC), controllable in simulation.

fn current_time_wall_clock(&self) -> WallClockInstant

Wall-clock time for timestamps (WAL, datetime functions). Controllable in simulation for deterministic behavior.

impl IO for UringIO

fn step(&self) -> Result<()>

Drive io_uring forward.

Leader/follower concurrency model:

• Submitters only take state (briefly, to push an SQE). They’re never blocked by the kernel-side wait, so concurrent submitters pipeline their SQEs into the ring while another thread is waiting on the kernel.
• One thread at a time is the leader: it holds wait_lock and runs submit_and_wait + drain_cq in a tight loop until the ring drains. The drain must happen while the wait guard is still held — if released before draining, a follower could compute pending_ops to include CQEs we’re about to consume and block forever on completions that no longer exist.
• Followers (concurrent callers of step) try_lock the wait_lock. If they lose the race they return immediately: the current leader will fire their waker as it drains. This replaces the previous “block on wait_lock and serialize” behavior, so N concurrent readers no longer queue up N-deep on the kernel call.
• Multiple concurrent kernel waiters on the same ring would themselves deadlock (Linux only wakes one waiter from the ring’s wait queue when min_complete is reached), which is the other reason for serializing at this layer.

fn supports_shared_wal_coordination(&self) -> bool

Whether this IO backend can back host-filesystem shared WAL coordination.

fn open_file( &self, path: &str, flags: OpenFlags, direct: bool, ) -> Result<Arc<dyn File>>

fn remove_file(&self, path: &str) -> Result<()>

fn cancel(&self, completions: &[Completion]) -> Result<()>

fn register_fixed_buffer(&self, ptr: NonNull<u8>, len: usize) -> Result<u32>

fn open_shared_wal_file(&self, path: &str) -> Result<Arc<dyn File>>

fn drain_completions(&self, completions: &[Completion]) -> Result<()>

Drive the IO backend until each completion in completions is finished(). Used after cancel() (so cancelled ops actually release their buffers before the caller returns) and after a single pwrite/pwritev/sync that the caller wants to await synchronously.

fn wait_for_completion(&self, c: Completion) -> Result<()>

fn generate_random_number(&self) -> i64

fn fill_bytes(&self, dest: &mut [u8])

Fill dest with random data.

fn get_memory_io(&self) -> Arc<MemoryIO>

fn yield_now(&self)

Yield the current thread to the scheduler. Used for backoff in contended lock acquisition.

fn sleep(&self, duration: Duration)

Sleep for the specified duration. Used for progressive backoff in contended lock acquisition.

fn file_id(&self, path: &str) -> Result<FileId>

Return the file identity for the given path. Default uses OS-level metadata; non-filesystem backends override with synthetic hash-based identity.

impl Send for UringIO

impl Sync for UringIO