Asynchronous Dynamic Software Update for Multi-Threaded Applications
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing dynamic software update (DSU) procedures for multi-threaded applications require system quiescing, which increases overhead as the number of active threads increases, making synchronous updates disadvantageous.
Innovation Solution
An asynchronous DSU method that allows each thread to update to a new software component version independently at an opportune time, without requiring the application environment to be quiesced, by using a global pointer to manage function tables for different versions of a software component, enabling concurrent execution of different version functions across threads.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If synchronous DSU procedures are used to ensure consistent update observation by all threads, then update reliability is improved, but system overhead increases as the number of active threads increases
Solution Approach 1:
The patent divides the monolithic update process into thread-specific update operations. Each thread maintains its own version of the software component and can update independently without requiring other threads to be quiesced. This segmentation eliminates the need for system-wide quiescing while maintaining update consistency within each thread's context.
Solution Approach 2:
The patent implements dynamic versioning where each thread can operate on different versions of the software component simultaneously. The system dynamically assigns and manages version pointers for each thread, allowing flexible transition between versions without requiring synchronous coordination across all threads.
2Reliability
If synchronous DSU procedures are used to apply updates, then update consistency is maintained, but productivity decreases due to system quiescing requirements
Solution Approach 1:
The update process is segmented into independent thread-level operations rather than a monolithic system-wide operation. This allows the system to maintain productivity by continuing to process requests in other threads while one thread undergoes update, eliminating the need for complete system quiescing.
Solution Approach 2:
The patent enables continuous system operation during updates by allowing threads to proceed with their work while updates are applied to other threads. The useful action of processing requests continues uninterrupted in threads that have not yet been updated, maintaining high system availability and productivity.
3Reliability
If system quiescing is implemented before dynamic updates, then update reliability is improved, but loss of time increases due to system-wide downtime
Solution Approach 1:
The patent segments the update process so that only the specific thread being updated needs to be paused, rather than quiescing the entire system. This dramatically reduces the time loss by limiting the impact to a single thread's execution context while other threads continue operating normally.
Solution Approach 2:
The patent applies partial quiescing only to the extent necessary for the specific thread being updated, rather than quiescing the entire system. This partial action approach minimizes the time loss while still ensuring update safety for the targeted thread.
Data Source
AI summary
A method and system for using multiple versions of a software component, includes storing, in memory, a first function table that points to executable code in the memory for functions from a first version of the software component, and storing, in the memory, a second function table that points to executable code in the memory for functions from a second version of the software component, referencing the first function table, when running a first application thread, to execute the functions from the first version of the software component; and referencing the second function table, when running a second application thread that is active concurrently with the first application thread, to execute the functions from the second version of the software component.