Wabrix, yet another data plane?
Wabrix, yet another data plane?
I’ve been working on Wabrix, a new high-performance network data plane.
Whenever a new data plane pops up, the immediate and fair question is: "Why not use DPDK (first released in 2010), VPP (developed in 2002 and open-sourced in 2016) or Click (first published in 1999)?"
Right, there are many options available, but each has its own set of trade-offs and limitations.
While DPDK, VPP, and Click pioneered high-performance packet processing, they carry the architectural baggage of the eras in which they were designed. Building a new data plane today isn't about reinventing the wheel—it is about addressing the fundamental friction points these legacy giants introduced regarding memory safety, extensibility, and kernel integration.
Here is a breakdown of the specific trade-offs that leave room for a modern alternative:
The Legacy Giants and Their Trade-offs
DPDK (The Brute-Force Hardware Takeover)
- The Approach: DPDK achieves extreme throughput by completely bypassing the kernel and using Poll Mode Drivers (PMDs) to constantly poll the NIC for packets.
- The Trade-offs:
- Resource Inefficiency: PMDs burn 100% of a CPU core's cycles even when there is no traffic.
- Memory Safety: Written in C, DPDK pipelines are highly susceptible to buffer overflows and memory leaks. A single out-of-bounds read in a custom packet parser can compromise the entire node.
- Hardware Monopolization: DPDK typically requires you to unbind the NIC from the Linux kernel. You lose access to standard networking tools (like
tcpdump,ethtool) for that interface. However, recently modern DPDK with bifurcated drivers (leveraging hardware flow steering like rte_flow) elegantly solves this old "hardware monopolization" problem for some NICs For those NICs you can now get user-space bypass speeds while keeping ethtool, tcpdump, and the Linux kernel happily managing the same physical port.
FD.io VPP (The Graph-Node Powerhouse)
- The Approach: VPP processes packets in batches (vectors) through a graph of nodes, maximizing instruction cache hits and achieving incredible routing performance.
- The Trade-offs:
- Steep Learning Curve: Developing custom plugins requires deeply understanding VPP's complex C-based graph architecture and memory management macros.
- Unsafe Extensibility: If you want to add custom logic (e.g., a proprietary protocol scrubber), you must write a C plugin. If that plugin has a segmentation fault, it brings down the entire VPP instance and drops all traffic.
Click Modular Router (The Pioneer of Modularity)
- The Approach: Click introduced the brilliant concept of assembling data planes by chaining modular "elements" together, making it incredibly flexible.
- The Trade-offs:
- Aging Architecture: Click was designed around C++ object-oriented paradigms that introduce virtual method dispatch overhead in the hot path.
- Integration Friction: While FastClick improved performance with DPDK backends, the core architecture still predates modern zero-copy kernel mechanisms.
The Modern Paradigm Shift
The argument for building a new data plane today centers on leveraging technologies that simply did not exist when the legacy frameworks were architected. A modern data plane can solve the historical trade-offs by focusing on:
- Kernel Synergy via AF_XDP: Instead of stealing the NIC from Linux (like traditional DPDK), modern kernel-bypass uses AF_XDP. This allows for zero-copy packet mapping directly into user space at hardware speeds, while still letting the Linux kernel handle the management plane, standard traffic, and traditional network observability tools.
- Memory Safety by Default: Writing the core data plane in a memory-safe systems language (like Rust) eliminates entire classes of vulnerabilities—such as dangling pointers or data races—without sacrificing C-level performance.
- Sandboxed Extensibility: Historically, extending a data plane meant linking unsafe C code. By integrating a WebAssembly runtime, a modern data plane can execute highly optimized, custom packet-processing plugins in an isolated sandbox. If a WebAssembly module panics, the main data plane pipeline catches it and replaces the module with a proven fallback version.
- Hot reloading: Modern data planes can dynamically update their packet-processing plugins without requiring a restart. This allows for rapid iteration and deployment of new features and bug fixes without downtime.
- Open Platform & Ergonomic Plugin APIs: Legacy data planes often force third-party developers to navigate obscure C macros, private graph APIs, and host-coupled build systems just to inspect a header. An open, modern platform exposes a stable, language-agnostic API contract (e.g., via WebAssembly Interface Types). Third-party vendors can build, test, and ship custom processing modules in Rust, C/C++, Go, or Zig using standard toolchains—democratizing data plane development without exposing core internal state.
When you look at the landscape through this lens, the question isn't why someone would build another data plane. The question is how long the industry can continue accepting memory-unsafe, monolithic architectures when the primitives for secure, zero-copy, sandboxed packet processing are finally available.