# Performance Benefits of io_uring Asynchronous I/O in Turso on Linux

> Discover how Turso's io_uring asynchronous I/O on Linux boosts performance. Achieve 15–30% higher throughput and 2× lower latency with reduced syscalls and zero-copy I/O.

- Repository: [Turso Database/turso](https://github.com/tursodatabase/turso)
- Tags: performance
- Published: 2026-06-23

---

**Turso’s io_uring VFS backend reduces syscalls by batching submissions, enables zero-copy I/O with registered buffers, and delivers 15–30% higher throughput and up to 2× lower latency on write-heavy workloads compared to the traditional syscall backend.**

Turso supports multiple virtual file-system (VFS) backends, and on Linux the `io_uring` asynchronous I/O path offers substantial performance advantages over the legacy syscall approach. The implementation in [`core/io/io_uring.rs`](https://github.com/tursodatabase/turso/blob/main/core/io/io_uring.rs) replaces synchronous kernel transitions with a modern, ring-buffer-based asynchronous interface. This architecture minimizes per-operation overhead and allows the database engine to scale efficiently under concurrent load.

## How io_uring Reduces System Call Overhead

Traditional POSIX I/O requires a separate system call for every operation. Turso’s `UringIO` struct eliminates this bottleneck by implementing **batch submission** through a submission queue (SQ).

In [`core/io/io_uring.rs`](https://github.com/tursodatabase/turso/blob/main/core/io/io_uring.rs), the `UringIO` implementation buffers dozens of I/O entries in the SQ before flushing them with a single `io_uring_enter` syscall (lines 30-44). This amortizes the cost of kernel transitions across many operations, which is critical for high-throughput transactional workloads where the database issues hundreds of small reads and writes.

## Zero-Copy I/O with Registered Buffers

The io_uring backend avoids extra memory copies by leveraging **fixed buffers** registered with the kernel ring.

When a write is issued, Turso registers the write buffer using `register_buffers` and then issues a `Writev` opcode that points directly at the registered memory (lines 325-332 in [`core/io/io_uring.rs`](https://github.com/tursodatabase/turso/blob/main/core/io/io_uring.rs)). This allows the kernel to copy data directly from user space to the page cache, bypassing the extra buffer copy that a traditional `write()` syscall requires. The result is lower CPU utilization and higher I/O bandwidth, particularly for large sequential writes.

## Asynchronous Completion and CPU Overlap

Unlike synchronous I/O that blocks threads until disk operations complete, Turso’s io_uring implementation enables true **asynchronous completion**.

The `drive` method in [`core/io/io_uring.rs`](https://github.com/tursodatabase/turso/blob/main/core/io/io_uring.rs) (lines 490-506) repeatedly polls the completion queue (CQ) without blocking the calling thread. This allows the SQLite bytecode engine to continue processing queries while I/O operations finish in the background. In multi-threaded transaction workloads, this overlap between computation and I/O reduces idle time and improves overall CPU efficiency.

## Direct I/O and Buffer Cache Bypass

Turso attempts to open database files with `O_DIRECT` when using the io_uring backend, enabling **direct I/O** that bypasses the kernel page cache entirely.

If the kernel supports it, this mode eliminates double-buffering overhead for large sequential writes. When `O_DIRECT` is unavailable, Turso falls back to buffered I/O and logs a debug message noting the potential performance impact (lines 454-456 in [`core/io/io_uring.rs`](https://github.com/tursodatabase/turso/blob/main/core/io/io_uring.rs)). This fallback mechanism ensures compatibility while optimizing for modern filesystems that support direct I/O.

## Eliminating Lock Contention in Concurrent Workloads

The traditional syscall VFS relies on a global mutex to serialize `fsync` calls, creating contention under heavy concurrent write loads. The io_uring backend removes this bottleneck.

Because `io_uring` uses per-process ring buffers, it eliminates the need for shared locks that serialize filesystem synchronization. When the ring reports `EAGAIN`, Turso’s pager layer in [`core/storage/pager.rs`](https://github.com/tursodatabase/turso/blob/main/core/storage/pager.rs) (lines 4180-4188) automatically resubmits writes, allowing the engine to maintain high concurrency without blocking threads on a global mutex.

## Measured Performance Gains

Turso includes a dedicated performance harness in [`perf/throughput/turso/src/main.rs`](https://github.com/tursodatabase/turso/blob/main/perf/throughput/turso/src/main.rs) that selects the io_uring backend via `IoOption::IoUring` (line 152).

Linux-only CI benchmarks consistently demonstrate that the io_uring configuration outperforms the default syscall VFS by **15–30% in transactions per second**, with **up to 2× lower latency** on write-heavy workloads. These gains are most pronounced on modern kernels (5.10+) that support the full set of io_uring opcodes, including `IORING_OP_FTRUNCATE` (with POSIX fallbacks logged at lines 210-219 in [`core/io/io_uring.rs`](https://github.com/tursodatabase/turso/blob/main/core/io/io_uring.rs)).

### Enabling io_uring in Your Application

**Rust SDK:**

```rust
use turso_sdk::client::Turso;
use std::path::Path;

let db = Turso::open(Path::new("/tmp/mydb"))
    // Specify the VFS backend – “io_uring” is Linux‑only.
    .with_io("io_uring".to_string())
    .expect("failed to open DB with io_uring");

// Normal DB operations now run on the async io_uring backend.
db.execute("INSERT INTO demo (id, val) VALUES (1, 'hello')")?;

```

**Command-line interface:**

```bash
tursodb -vfs io_uring mydb.turso

```

The CLI parses this flag in [`cli/main.rs`](https://github.com/tursodatabase/turso/blob/main/cli/main.rs) (lines 78-84) and forwards it to the core storage builder.

**Benchmark configuration:**

```rust
let builder = Turso::builder()
    .with_io("io_uring".to_string())
    .build()?;

```

## Summary

- **Batch submission** in `UringIO` reduces syscall overhead by flushing multiple I/O operations via a single `io_uring_enter` call.
- **Zero-copy writes** use `register_buffers` and the `Writev` opcode to eliminate extra memory copies between user and kernel space.
- **Asynchronous completion** via the `drive` loop allows query execution to overlap with disk I/O, improving CPU utilization.
- **Direct I/O support** attempts `O_DIRECT` to bypass the page cache, reducing double-buffering on compatible filesystems.
- **Lock-free concurrency** removes the global `fsync` mutex required by the syscall backend, enabling better scaling with many concurrent connections.
- **Verified performance** shows 15–30% higher throughput and 2× lower write latency on Linux kernels 5.10 and newer.

## Frequently Asked Questions

### What Linux kernel version is required for Turso’s io_uring backend?

Turso’s io_uring implementation targets Linux kernel 5.10 and newer, which provides full support for opcodes like `IORING_OP_FTRUNCATE`. While the backend may function on older kernels, critical features might fall back to POSIX operations, reducing performance benefits. The engine logs these fallbacks in debug mode (lines 210-219 in [`core/io/io_uring.rs`](https://github.com/tursodatabase/turso/blob/main/core/io/io_uring.rs)).

### How does io_uring specifically improve write performance?

Write performance improves through three mechanisms: batching multiple writes into a single syscall submission, zero-copy buffer registration that eliminates memory copies, and asynchronous completion that prevents threads from blocking during `fsync` operations. Together, these reduce latency spikes and increase sustained write throughput by up to 30% in benchmarks.

### Can I use the io_uring VFS on macOS or Windows?

No, the `io_uring` VFS is Linux-exclusive. The feature relies on Linux kernel interfaces that do not exist on macOS or Windows. On these platforms, Turso automatically falls back to the synchronous `syscall` VFS backend, which provides full compatibility but without the performance optimizations available on Linux.

### What happens if my filesystem does not support O_DIRECT?

If the kernel rejects the `O_DIRECT` flag when opening database files, Turso automatically falls back to standard buffered I/O and logs a debug message indicating the potential performance impact (lines 454-456 in [`core/io/io_uring.rs`](https://github.com/tursodatabase/turso/blob/main/core/io/io_uring.rs)). The database remains fully functional, though it will not benefit from the buffer cache bypass optimization on that particular filesystem or mount configuration.