Application-Controlled Network Packet Classification via Thread-Local Hashing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing network systems lack flexibility in processing data packets, leading to inefficient load balancing and performance issues as they rely on a shared hash function for both packet classification and TCP processing, which restricts applications' ability to manage how data packets are processed across different connections.
Innovation Solution
Each network thread is associated with its own TCP table, allowing applications to use custom hash functions for distributing connections and enabling pre-assignment and migration of connections to different network contexts, thereby eliminating the need for locking mechanisms and enhancing load balancing.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Device complexity
If a shared hash function is used for both packet classification and TCP processing, then system complexity is reduced, but application flexibility and load balancing performance deteriorate
Solution Approach 1:
The patent segments the previously shared hash function into separate hash functions for packet classification and TCP processing. Each network thread maintains its own TCP table with dedicated hash functions, allowing independent optimization for different purposes while eliminating the need for locking mechanisms.
Solution Approach 2:
The patent implements local quality by allowing different hash functions to be used in different parts of the system - packet classification uses one hash function while TCP processing uses another. This enables each component to be optimized independently for its specific function, improving overall system performance and flexibility.
2Ease of manufacture
If a shared hash function is used for both packet classification and TCP processing, then implementation simplicity is maintained, but throughput and load balancing efficiency deteriorate
Solution Approach 1:
The patent divides the monolithic hash function into separate instances for classification and TCP processing. This segmentation allows each hash function to be independently optimized for throughput, enabling better load balancing across network threads without complicating the overall implementation.
Solution Approach 2:
The patent changes the parameters of the hash function by allowing different algorithms and configurations for packet classification versus TCP processing. This enables optimization of throughput parameters specifically for high-performance network processing while maintaining implementation simplicity through modular design.
3Stability of the object's composition
If the same hash function is used by packet classifier and TCP module, then consistency is maintained, but application control over packet processing deteriorates
Solution Approach 1:
The patent segments the hash function usage into distinct components - one for packet classification and another for TCP processing. This allows applications to control packet routing decisions independently from TCP connection management, providing fine-grained control over packet processing while maintaining consistency within each segmented function.
Solution Approach 2:
The patent introduces separate hash functions as intermediaries between the packet classifier and TCP module. This allows the system to maintain consistency through structured interfaces while giving applications the flexibility to influence packet processing behavior through the classification stage without affecting TCP processing directly.
4Reliability
If locking mechanisms are used to protect shared TCP hash table, then data integrity is ensured, but processing speed and throughput deteriorate
Solution Approach 1:
The patent extracts the locking mechanism from the system by eliminating the shared TCP hash table. Each network thread maintains its own dedicated TCP table, removing the need for inter-thread synchronization and locking entirely. This extraction of the shared resource eliminates the bottleneck while ensuring data integrity through isolation.
Solution Approach 2:
The patent segments the shared TCP hash table into multiple thread-local TCP tables. This segmentation eliminates the need for locking mechanisms because each thread operates on its own data structure. Data integrity is maintained through this isolation while processing speed improves by removing synchronization overhead.
Data Source
AI summary
Embodiments of the present invention provide a system, method, and computer program product that enables applications transferring data packets over a network to a multi-processing system to choose how the data packets are going to be processed by, e.g., allowing the applications to pre-assign connections to a particular network thread and migrate a connection from one network thread to another network thread without putting the connection into an inconsistent state.