rust-dpdk-net

KO | EN

gitlite — search

#javascript #hacktoberfest #react #ai #typescript #golang #go #android #rust #awesome #cli #kubernetes #awesome-list #mcp

(★ 17)

DPDK + TCP kernel bypass networking for Rust with async/await (and tokio, axum, tonic grpc)

rust-dpdk-net Latest Version Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# dpdk-net

[![CI](https://github.com/youyuanwu/rust-dpdk-net/actions/workflows/CI.yml/badge.svg)](https://github.com/youyuanwu/rust-dpdk-net/actions/workflows/CI.yml)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://raw.githubusercontent.com/youyuanwu/rust-dpdk-net/main/LICENSE)

High-level async TCP/IP networking for Rust using [DPDK](https://github.com/DPDK/dpdk) for kernel-bypass packet I/O.

## What is this?

`dpdk-net` combines three technologies to provide high-performance networking:

- **[DPDK](https://github.com/DPDK/dpdk)** - Kernel-bypass packet I/O directly to/from the NIC
- **[smoltcp](https://github.com/smoltcp-rs/smoltcp)** - User-space TCP/IP stack
- **Async runtime** - Uses rust async runtime for task scheduling

This enables building network applications (HTTP servers, proxies, etc.) that bypass the kernel network stack entirely, achieving lower latency and higher throughput.

[Benchmarks](docs/Bench/Benchmark.md) shows 2X throughput and half latency than tokio server.

## Architecture

```
┌─────────────────────────────────────────────────────────────────────┐
│                        Application Layer                            │
│   (axum, tonic gRPC, tonic-h3 gRPC/H3, hyper, TcpStream, UdpSocket)│
└─────────────────────────────────────────────────────────────────────┘
                                   │
                                   ▼
┌─────────────────────────────────────────────────────────────────────┐
│                       Framework Layer                               │
│   dpdk-net-util (DpdkApp, WorkerContext, HTTP client,               │
│                  axum serve, tonic serve/channel)                    │
└─────────────────────────────────────────────────────────────────────┘
                                   │
                                   ▼
┌─────────────────────────────────────────────────────────────────────┐
│                    Async Runtime Layer                               │
└─────────────────────────────────────────────────────────────────────┘
                                   │
                                   ▼
┌─────────────────────────────────────────────────────────────────────┐
│                      TCP/IP Stack (smoltcp)                         │
└─────────────────────────────────────────────────────────────────────┘
                                   │
                                   ▼
┌─────────────────────────────────────────────────────────────────────┐
│                     DPDK (kernel-bypass I/O)                        │
└─────────────────────────────────────────────────────────────────────┘
                                   │
                                   ▼
┌─────────────────────────────────────────────────────────────────────┐
│                         Hardware NIC                                │
└─────────────────────────────────────────────────────────────────────┘
```

## Features

- **Async/await support** - `TcpListener`, `TcpStream` with `futures_io::AsyncRead`/`AsyncWrite`; runtime-agnostic
- **axum integration** - Serve axum `Router` directly on DPDK sockets (`dpdk-net-util` feature: `axum`)
- **tonic gRPC** - gRPC server and client over DPDK (`dpdk-net-util` feature: `tonic`)
- **QUIC ([Quinn](https://github.com/quinn-rs/quinn))** - Quinn endpoints over DPDK UDP sockets (`dpdk-net-util` feature: `quinn`)
- **gRPC over HTTP/3** - [tonic-h3](https://github.com/youyuanwu/tonic-h3) gRPC via QUIC/H3 over DPDK
- **HTTP client** - `DpdkHttpClient` for HTTP/1.1 and HTTP/2 requests (`dpdk-net-util`)
- **Multi-queue scaling** - RSS (Receive Side Scaling) distributes connections across CPU cores
- **DpdkApp framework** - Lcore-based application runner with per-queue smoltcp stacks
- **CPU affinity** - Worker threads pinned to cores for optimal cache locality

## Crates

| Crate | Description |
|-------|-------------|
| `dpdk-net` | Core library: DPDK wrappers, smoltcp integration, async TCP sockets |
| `dpdk-net-sys` | FFI bindings to DPDK C library (generated via bindgen) |
| `dpdk-net-util` | `DpdkApp`, `WorkerContext`, HTTP client, `LocalExecutor`, axum `serve()`, tonic `serve()` + `DpdkGrpcChannel`, Quinn/QUIC adapter (`DpdkQuinnRuntime`) |
| `dpdk-net-test` | Test harness, example servers, integration tests |

## Documentation
- [Architecture](docs/Architecture.md) - Crate structure and implementation details
- [Design](docs/Design/) - Design docs for DpdkApp, Axum, Tonic, HTTP Client
- [Benchmarks](docs/Bench/Benchmark.md) - Performance comparison with tokio on Azure
- [Limitations](docs/Limitations.md) - Known limitations and constraints

## Requirements

- Linux with hugepages configured
- DPDK-compatible NIC (Intel, Mellanox, etc.) or virtual device for testing
- Root privileges (for DPDK memory and device access)

## Getting Started

### Install DPDK

From package manager or build from source:

```sh
cmake -S . -B build
cmake --build build --target dpdk_configure
cmake --build build --target dpdk_build --parallel
sudo cmake --build build --target dpdk_install
```

### Axum HTTP Server

```rust
use dpdk_net_util::{DpdkApp, WorkerContext};
use dpdk_net_util::axum::serve;
use dpdk_net::socket::TcpListener;
use axum::{Router, routing::get};
use smoltcp::wire::Ipv4Address;

fn main() {
    // Initialize EAL (e.g., via EalBuilder)
    // ...

let app = Router::new().route("/", get(|| async { "Hello from DPDK!" }));

DpdkApp::new()
        .eth_dev(0)
        .ip(Ipv4Address::new(10, 0, 0, 10))
        .gateway(Ipv4Address::new(10, 0, 0, 1))
        .run(move |ctx: WorkerContext| {
            let app = app.clone();
            async move {
                let listener = TcpListener::bind(&ctx.reactor, 8080, 4096, 4096).unwrap();
                serve(listener, app, std::future::pending::<()>()).await;
            }
        });
}
```

### Tonic gRPC Server

```rust
use dpdk_net_util::tonic::serve;
use dpdk_net::socket::TcpListener;

// Inside DpdkApp::run() closure:
let greeter = GreeterServer::new(MyGreeter::default());
let routes = tonic::service::Routes::new(greeter);
let listener = TcpListener::bind(&ctx.reactor, 50051, 4096, 4096).unwrap();
serve(listener, routes, std::future::pending::<()>()).await;
```

## Project Status

⚠️ **APIs are unstable and subject to change.**

This project is under active development. The core functionality works, but the API surface is evolving.

## References
[References](./docs/References/OtherProjects.md)

## License

MIT

rust-dpdk-net

rust-dpdk-net Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

rust-dpdk-net

rust-dpdk-net Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Download README