Why Traditional Linux Network I/O Falls Short and How DPDK Boosts Performance

Network I/O Situation and Trends

Network speeds have continuously increased (1GE/10GE/25GE/40GE/100GE), and single‑node network I/O must keep pace. Traditional telecom hardware (routers, switches, firewalls, base stations) uses ASIC/FPGA solutions, which are hard to debug and cannot iterate quickly with evolving standards such as 2G/3G/4G/5G. Cloud and private‑cloud NFV also demand a high‑performance, software‑based network I/O framework.

Traditional telecom field

Cloud development (NFV)

Single‑node performance surge (NICs from 1G to 100G, CPUs from single‑core to many‑core)

Even with powerful hardware, software cannot fully utilize the bandwidth; many workloads (big‑data analytics, AI) require massive data transfer between distributed servers.

Linux + x86 Network I/O Bottlenecks

On an 8‑core CPU, processing 10 000 packets consumes about 1 % of a soft‑interrupt CPU, giving a theoretical upper bound of 1 M PPS. Real‑world measurements show 1 M PPS for Netfilter, 1.5 M PPS after AliLVS tuning. To saturate a 10 GE NIC (64‑byte packets) requires 20 M PPS; a 100 GE NIC needs 200 M PPS, meaning each packet must be processed in <50 ns. Cache misses (≈65 ns) and NUMA cross‑node communication (≈40 ns) dominate latency, making pure packet processing extremely challenging.

Key problems:

Hard interrupts cost ~100 µs each, not counting cache‑miss overhead.

Kernel‑user copying and global lock contention.

System‑call overhead for each packet.

Lock‑free kernels still suffer from bus locking and memory barriers.

Long data paths (e.g., netfilter) add unnecessary latency and cache misses.

DPDK Basic Principle

To bypass the kernel bottleneck, DPDK moves packet I/O to user space using a poll‑mode driver (PMD). This eliminates interrupts, system calls, and most kernel processing, allowing zero‑copy and full CPU utilization.

DPDK supports x86, ARM, and PowerPC architectures and a wide range of NICs (e.g., Intel 82599, Intel X540).

DPDK Foundation: UIO

Linux provides the UIO (User‑space I/O) mechanism, which lets a driver run in user space, receive interrupts via read, and communicate with the NIC via mmap. Developing a UIO driver involves:

Implementing a kernel UIO module (interrupts must be handled in kernel).

Reading interrupts from /dev/uioX.

Sharing memory with the device via mmap.

DPDK Core Optimization: PMD

PMD runs in user space with active polling, providing zero‑copy and eliminating system‑call overhead. While this yields maximum throughput, the CPU may spin at 100 % when the network is idle, leading to higher power consumption. DPDK therefore offers an interrupt‑driven mode similar to NAPI, allowing the poll loop to sleep when no packets are available.

High‑Performance Code Techniques in DPDK

HugePages to reduce TLB misses (2 MiB or 1 GiB pages instead of 4 KiB).

Shared‑nothing architecture to avoid global contention and NUMA cross‑node memory access.

SIMD (MMX/SSE/AVX2) for batch processing of packets.

Avoiding slow APIs (e.g., gettimeofday) and using cycle counters like rte_get_tsc_cycles.

Example of reading the TSC efficiently:

static inline uint64_t rte_rdtsc(void) {
    union {
        uint64_t tsc_64;
        struct { uint32_t lo_32; uint32_t hi_32; };
    } tsc;
    asm volatile ("rdtsc" : "=a" (tsc.lo_32), "=d" (tsc.hi_32));
    return tsc.tsc_64;
}

Further optimizations include:

CPU affinity to keep threads on specific cores.

Memory barriers to prevent out‑of‑order execution errors.

Disabling frequency scaling (Turbo Boost) for stable timing.

Compilation Optimizations

Branch prediction hints ( likely, unlikely).

Cache prefetching ( rte_prefetch0).

Memory alignment to avoid false sharing and cache‑line splits.

Constant folding using compile‑time evaluation (e.g., rte_bswap32).

Direct CPU instructions (e.g., bswap for byte order conversion).

DPDK Ecosystem

DPDK itself provides low‑level primitives; higher‑level protocols (ARP, IP, TCP/UDP) must be implemented by the user or by projects built on top of DPDK. Mature user‑space networking stacks include FD.io/VPP, which offers comprehensive protocol support, and TLDK for TCP/UDP. Seastar also integrates DPDK but is less widely adopted.