Protocol Stack Tight Embrace Bypassing Streams Overhead
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The Streams framework in computer communications incurs significant overhead due to mutual exclusion locking and queuing, degrading performance even when module additions or removals are rare, and merging protocol modules to avoid this overhead complicates flexibility and efficiency.
Innovation Solution
Establishing a 'tight embrace' between adjacent protocol layer modules allows direct invocation of each other's functionality, bypassing the Streams framework's canputnext and putnext functions, using pointers or references for data communication, while control messages still pass through the framework.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If the Streams framework is used to provide modular protocol stack implementation, then protocol stack flexibility and ease of module addition/removal are improved, but communication performance deteriorates due to continual locking and unlocking overhead
Solution Approach 1:
The patent segments the protocol stack into distinct modules that can independently establish tight embraces with adjacent modules. Each module maintains its independence and flexibility while selectively bypassing the Streams framework overhead through direct invocation paths with neighboring modules, thus resolving the contradiction between modular flexibility and communication performance.
2Productivity
If protocol modules are merged to avoid Streams framework overhead, then communication efficiency is improved, but system flexibility and ease of reconfiguration deteriorate
Solution Approach 1:
The patent implements dynamic tight embraces where adjacent protocol modules can selectively invoke each other's functionality directly without merging. This dynamic approach allows modules to maintain independence and flexibility for reconfiguration while achieving efficient direct communication paths, avoiding the drawbacks of permanent merging while capturing efficiency benefits.
Solution Approach 2:
The patent extracts the overhead-inducing Streams framework calls (canputnext and putnext) from the direct communication path between adjacent protocol modules. By establishing tight embraces that bypass these framework calls, the essential overhead is removed while modules remain separate and reconfigurable, resolving the contradiction between efficiency and flexibility.
3Productivity
If tight embrace is established between adjacent protocol modules, then processing overhead is reduced and data communication efficiency is improved, but module independence and reconfiguration capability may be affected
Solution Approach 1:
The tight embrace mechanism is implemented dynamically, allowing modules to establish and terminate direct invocation relationships as needed. This dynamic nature enables modules to maintain independence and reconfiguration capability while achieving efficient direct communication paths when tight embraces are active, resolving the contradiction between efficiency and reconfiguration capability.
Data Source
AI summary
A system and method for improving the efficiency with which data communications are passed through a protocol stack. Protocol layer modules within a protocol stack built upon the Streams framework are modified to establish tight embraces between adjacent modules. A tight embrace may be established by passing from one, upper, protocol layer module to its adjacent lower protocol layer module a pointer or reference to the upper module's functionality (e.g., rput) for reading a data communication into the upper module from the lower module. Similarly, the lower module passes the upper module a pointer or reference to its functionality (e.g., wput) for writing a data communication into the lower module from the upper module. After a tight embrace is established, the protocol layer modules can directly invoke each other's functionality, without incurring the overhead associated with the Streams framework's “canputnext” and “putnext” messages.