Shared Memory Process Isolation for Service Stability
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing electronic device programs face instability issues due to the integration of third-party components, leading to potential crashes during service processing, and existing watchdog designs primarily focus on maintenance rather than ensuring deeper program stability.
Innovation Solution
A service processing method that creates a shared memory region and determines a startup parameter to start a second process, allowing communication between processes through the shared memory, ensuring the second process runs independently and stabilizes the first process even if the second process crashes.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If a third-party component is integrated into the program to implement a service function, then the program can achieve the required service capability, but the program stability deteriorates due to the poor stability of the third-party component
Solution Approach 1:
The patent divides the program into multiple independent processes: a first process (main program) and a second process (third-party component). This segmentation isolates the unstable third-party component into a separate process space, preventing its crashes from affecting the main program's stability while still allowing the service function to be executed.
Solution Approach 2:
The patent introduces a shared memory region as an intermediary communication mechanism between the first process and the second process. This intermediary allows the main program to send service requests to the third-party component and receive results without direct integration, thereby maintaining stability while achieving service functionality.
2Ease of repair
If a watchdog mechanism is implemented to detect and recover crashed processes, then the program can be maintained and recovered after crashes, but the fundamental program stability problem is not solved
Solution Approach 1:
The patent implements preliminary action by pre-establishing a watchdog mechanism that proactively monitors the running state of the second process. The watchdog detects crashes before they propagate to the first process and automatically triggers recovery actions, preventing crashes rather than merely responding to them.
Solution Approach 2:
The patent establishes a feedback loop where the watchdog continuously monitors the second process's running state and provides feedback to the first process. When a crash is detected, the feedback triggers automatic recovery actions, creating a closed-loop control system that maintains program stability.
3Ease of operation
If shared memory regions are created for every service request to enable process communication, then communication between processes is achieved, but system resources are wasted due to frequent creation and destruction of shared memory
Solution Approach 1:
The patent creates a shared memory region once during process initialization and reuses it for multiple service requests. This universal shared memory structure serves multiple communication purposes over time, eliminating the need to create and destroy shared memory regions for each individual request, thereby reducing system resource consumption.
4Device complexity
If the second process is integrated into the first process to simplify the system structure, then the system becomes simpler, but the first process becomes vulnerable to crashes from the unstable second process
Solution Approach 1:
The patent segments the system into two independent processes rather than integrating them. The first process (main program) and second process (third-party component) run in separate address spaces, which simplifies the coupling between components while maintaining stability through isolation. The segmentation prevents crash propagation while enabling controlled communication via shared memory.
Data Source
AI summary
The present disclosure provides service processing methods and apparatuses. The method includes: in response to receiving a to-be-processed service request, creating a shared memory region, and determining a startup parameter, where the startup parameter includes information of the shared memory region; conveying the startup parameter to a second process such that the second process is started up based on the startup parameter; where the second process indicates a functional module used to implement the to-be-processed service request; based on the to-be-processed service request, generating a first processing command; writing the first processing command into the shared memory region such that the second process reads the first processing command from the shared memory region based on the information of the shared memory region, and performs a processing operation based on the first processing command.