TL;DR
NFVactor is a high-performance framework that uses the Distributed Actor Model to manage Network Function Virtualization (NFV). By treating every network flow as an independent "actor," it achieves 10Gbps line-rate processing, reduces failure recovery delays to microseconds, and performs flow migrations up to 144 times faster than existing centralized systems.
What Problem Does This Paper Address?
In modern cloud networking, "Middleboxes" (firewalls, load balancers, etc.) are being replaced by software-based Network Functions (NFs). However, making these software NFs "resilient"—meaning they can survive hardware failures or move traffic (flow migration) when a server is overloaded—is incredibly difficult.
Current solutions suffer from two main bottlenecks:
- Heavyweight Checkpointing: To survive a crash, systems often "freeze" the entire NF process to save its state. This causes massive spikes in packet delay (latency), sometimes up to thousands of microseconds.
- Centralized Bottlenecks: When thousands of flows need to move to a new server, a centralized controller usually manages the process step-by-step. This is slow and doesn't scale well for the millions of concurrent flows found in real-world data centers.
Methods
The authors propose NFVactor, which shifts the architecture from a monolithic process to a per-flow actor model.
Key Innovations:
- One-Actor-One-Flow: Every individual network flow is assigned its own "actor"—a lightweight, isolated execution unit. This allows flows to replicate or migrate themselves in parallel without waiting for a global controller.
- Transparent Resilience: The framework provides specific APIs (
process_pkt,allocate_new_fs) that decouple the NF's logic from its state. If a developer uses these APIs, the framework handles all the complex replication and migration logic automatically. - Custom High-Performance Runtime: Standard actor libraries (like
libcaf) aren't fast enough for 10Gbps networking. The authors built a custom runtime using DPDK (Data Plane Development Kit) and a Module Graph Scheduler. This bypasses the slow Linux kernel and uses a "run-to-completion" model to minimize context switching. - Decentralized Migration Protocol: Instead of a controller moving flows, the "Source Actor" on one server communicates directly with a "Target Actor" on another to hand off state in a three-step handshake.
Datasets
The paper evaluates the system using synthetic traffic generated by a customized version of BESS (Berkeley Extensible Software Switch).
- Traffic Profile: They used 64-byte TCP packets (the "worst-case" scenario for packet processing) at rates up to 10Gbps (~14 million packets per second).
- Flow Mixture: Tests included a mix of "short flows" (1 second) and "long flows" (10 seconds) to simulate realistic internet traffic patterns.
Key Insights and Ideas
- Parallelism is the Cure for Latency: By decentralizing migration, NFVactor can move 600,000 flows simultaneously. Because each actor handles its own handoff, the total time to migrate a massive cluster is drastically reduced.
- Micro-Checkpointing: Instead of saving the state of an entire virtual machine, NFVactor only replicates the state of a single flow after it processes a packet. This keeps the "output-commit" latency (the time a packet is held before being sent to ensure the state is saved) at a steady 20 microseconds.
- The "Liaison Actor": To bridge the gap between the outside world (the controller) and the millions of flow actors, the authors introduced a "Liaison Actor" on each runtime to coordinate management tasks without becoming a bottleneck.
Key Results
- Throughput: Achieved 10Gbps line-rate processing for 64-byte packets across multiple NFs (Firewall, NAT, Load Balancer, and IDS).
- Migration Speed: NFVactor migrated 1,000 flows in just 1.5ms—144 times faster than OpenNF, a leading research competitor.
- Scalability: The system successfully migrated 600,000 concurrent flows in approximately 700 milliseconds.
- Failure Recovery: A single runtime could be fully recovered in under 70 milliseconds after a crash.
- Latency Stability: Unlike checkpoint-based systems (like FTMB) that see latency spikes up to 3,000µs, NFVactor maintained a stable processing delay of roughly 20 microseconds during active replication.
Limitations and Future Work
- Refactoring Required: To use NFVactor, existing NFs must be rewritten or ported to use the framework's specific API. This "holistic" approach offers better performance but requires more initial effort from developers.
- Service Chain Complexity: The current prototype focuses on sequential service chains (e.g., Firewall → NAT). The authors note that the actor model's flexibility could eventually support more complex, non-linear "graphs" of NFs, but this was left for future exploration.
- Hardware Dependency: The results rely on DPDK-compatible NICs and dedicated CPU pinning, which may limit deployment in highly heterogeneous or older cloud environments.
Summary updated