SCTP Network Node Parallel Processing Architecture
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The existing Stream Control Transmission Protocol (SCTP) implementation is limited by single-threaded processing, which restricts throughput and capacity on multi-core computer systems, as all functions are performed in a single core, and existing solutions for parallel processing are either limited to resources hidden behind Network Address Translation (NAT) or not scalable.
Innovation Solution
A network node is configured to handle SCTP packets by separating tasks into a control instance for administrative chunks and data instances for association-specific chunks, allowing these to be processed on different processing cores, thereby increasing capacity and scalability by exploiting multiple cores.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If all SCTP functions are performed in a single thread on a single core, then implementation simplicity is maintained, but throughput and capacity are limited
Solution Approach 1:
The SCTP implementation is segmented into multiple independent threads, each handling specific SCTP associations. The segmentation divides the single-threaded monolithic structure into multi-threaded modular units, allowing parallel processing on multi-core systems while maintaining clear separation of concerns for different association handling tasks.
Solution Approach 2:
The implementation transitions from a single-dimensional single-threaded architecture to a multi-dimensional multi-threaded architecture that exploits the additional dimension of parallel processing across multiple cores. This dimensional expansion allows simultaneous handling of multiple associations without the sequential limitations of single-threaded processing.
2Productivity
If independent resources are dedicated to each association, then parallel processing capacity increases, but resource utilization efficiency decreases
Solution Approach 1:
Each thread is designed with universal functionality to handle any SCTP association, rather than being dedicated to a single association. This multi-functional design allows threads to dynamically accept and process different associations, improving resource utilization while maintaining parallel processing capacity through thread pooling and association assignment mechanisms.
3Productivity
If a single core processes all SCTP packets, then implementation simplicity is maintained, but bandwidth and scalability are restricted
Solution Approach 1:
The processing architecture is segmented across multiple cores, with each core running independent threads that handle subsets of SCTP associations. This segmentation distributes the processing load from a single core bottleneck to multiple parallel processing units, increasing overall bandwidth while maintaining manageable complexity through modular thread design.
Solution Approach 2:
An intermediary mechanism is introduced to manage the distribution of SCTP associations to appropriate threads and cores. This mediator layer handles the complexity of multi-core coordination, packet routing to correct threads, and thread management, thereby enabling scalable bandwidth utilization without requiring each application to directly manage complex multi-core architecture details.
4Productivity
If existing parallel processing solutions are used with NAT resources, then computational resource capacity increases, but adaptability to general multi-core systems is limited
Solution Approach 1:
The thread-based implementation provides universal adaptability to any multi-core system architecture, unlike NAT-specific solutions. Each thread can handle any SCTP association independently, making the implementation versatile across different hardware platforms and network configurations without being constrained to specific NAT infrastructure or proprietary resource pools.
Data Source
Figure 1~2
Figure 3~4
Figure 5
AI summary
A method and a network node (110) for handling SCTP packets are disclosed. The network node (110) provides (A010, A020) a control instance of a control procedure for handling administrative chunks of the SCTP packets and at least one data instance of a data procedure for handling association specific chunks of the SCTP packets. With the control instance, the network node (110) discards (A050) association specific chunks of a received SCTP packet, and processes (A060) administrative chunks of the received SCTP packet. With each of said at least one data instance, the network node (110) discards (A080, A090) administrative chunks and a first set of association specific chunks of the received SCTP packet, and processes (A100) a second set of association specific chunks of the received SCTP packet, wherein the second set of association specific chunks relates the respective set of said at least one association. A corresponding computer program (803) and a carrier (805) therefor are also disclosed.