User Space Networking Stack Autoscaling via Container Segmentation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Network device performance is hindered by CPU load, memory bandwidth, and driver limitations, leading to inefficiencies in scaling with the addition of cores due to increased load balancing and process scheduling overheads.
Innovation Solution
A system and method that maintain a cluster of containers in user space separate from the kernel space, allowing packets to bypass the kernel and be processed by virtual functions, with dynamic scaling based on core utilization, and error management through daemon operations and configuration files.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If multiple cores are added to a network device to increase performance, then processing capacity is improved, but load balancing and process scheduling overhead increases
Solution Approach 1:
The patent segments the network processing function by creating multiple independent container instances, each handling a subset of network packets. This segmentation allows parallel processing across multiple cores while reducing the complexity of centralized load balancing, as each container independently manages its own packet processing queue.
Solution Approach 2:
The patent introduces a new dimensional approach by implementing hierarchical load balancing: first distributing packets to container instances (coarse-grained), then to cores within each container (fine-grained). This multi-dimensional distribution strategy reduces the overhead compared to traditional single-level load balancing across all cores.
2Reliability
If kernel space drivers are used for network interface management, then system stability is maintained, but performance is limited by CPU and memory constraints
Solution Approach 1:
The patent extracts the network packet processing function from the kernel space driver and relocates it to user space container instances. This extraction allows the processing logic to bypass kernel space CPU and memory constraints, achieving higher performance while the kernel driver maintains system stability through basic interface management.
Solution Approach 2:
The patent introduces container instances as intermediary layers between the kernel network driver and the application layer. These intermediaries handle the performance-critical packet processing in user space, while the kernel driver continues to provide stable system-level network interface management, thus decoupling stability from performance constraints.
3Productivity
If containers are clustered to reduce load balancing overhead, then processing efficiency is improved, but system complexity increases
Solution Approach 1:
The patent merges multiple container instances into a unified cluster managed by a single load balancer. This merging allows the system to process packets in parallel across containers while presenting a single point of control, thus improving efficiency without proportionally increasing management complexity.
Solution Approach 2:
The patent creates universal container instances that can handle multiple network protocols and traffic types. This multi-functionality allows a single container design to serve various purposes, reducing the complexity of managing specialized containers for different functions while maintaining processing efficiency.
Data Source
AI summary
Managing an autoscaled user space networking stack is provided. A cluster of containers are disposed in a userspace separate from a kernel space of a device. Each container in the cluster of containers can execute a respective one of a plurality of virtual functions, for a network interface card of the device, to cause packets received by the device to bypass the kernel space. The device can forward, via a load balancing technique, a packet received by the device to a container in the cluster of containers. The container can execute a virtual function of the plurality of virtual functions. The device can update a queue for a core managed by the virtual function. The update can cause the core to process the packet in accordance with the queue.