Server Communication Channel Architecture for Multi-Protocol Load Management
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current client/server communication models are inadequate for efficiently processing client requests from different protocols on different sockets, as they often require separate processes or threads for each client, leading to inefficiencies and increased resource usage.
Innovation Solution
A multi-process, multi-threaded server communication channel architecture that creates a parent process with a pool of child processes, each with its own thread pool, allowing for dynamic adjustment based on service load and using an abstract base class with subclasses for protocol-specific service interfaces.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If a separate child process is created for each client, then each client can be serviced independently, but the number of processes increases leading to higher resource consumption and system overhead
Solution Approach 1:
The server is segmented into multiple hierarchical levels: a parent process that manages overall coordination, child processes that handle specific protocol families, and threads within child processes that service individual clients. This segmentation allows independent client service while consolidating process usage through shared parent and child processes.
Solution Approach 2:
Child processes are designed to be multi-functional, capable of handling multiple client connections from the same protocol family through thread pooling. A single child process can service multiple clients simultaneously via its thread pool, reducing the total number of processes needed while maintaining independent service capability.
2Quantity of substance
If a separate thread is created for each client within a server process, then resource usage is more efficient compared to separate processes, but all threads share the same socket descriptor leading to potential conflicts and complexity in socket management
Solution Approach 1:
Socket management is segmented by introducing child processes as intermediate layers between the parent process and client threads. Each child process owns specific socket descriptors for its protocol family, while threads within the child process share the child's sockets. This segmentation isolates socket descriptor usage, preventing conflicts between threads of different child processes.
Solution Approach 2:
Child processes act as intermediaries between the parent process's socket management and the thread pool's client service operations. The child process receives socket descriptors from the parent, manages them within its scope, and provides access to threads in its pool, thereby mediating socket descriptor sharing and reducing direct conflicts between threads.
3Stability of the object's composition
If the server uses a fixed number of child processes and threads, then system stability is maintained, but the server cannot adapt to varying service loads efficiently
Solution Approach 1:
The server implements dynamic process and thread pool management where the parent process can create or terminate child processes based on observed system load and service demands. Thread pools within child processes can also dynamically adjust their size. This dynamic behavior allows the system to adapt to varying loads while maintaining stability through controlled parent process oversight.
Solution Approach 2:
The parent process monitors system conditions and service load metrics, using this feedback to make informed decisions about creating or terminating child processes. This feedback loop enables the server to automatically adjust its process composition in response to changing demands, balancing stability with adaptability.
Data Source
AI summary
A Sever Communication Channel (“SCC”) architecture is described. The SCC architecture provides an abstract base class that describes specific service interfaces called for each service and allows handling of specific protocols for servicing the clients. Worker threads that provide services through different protocols call the specific service interfaces. One application program thereby can implement different protocols for providing diverse types of services such as, for example, scanning services.