In-Service Software Patching via Thread Coordination Zone
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing software patch mechanisms in multiple-core and multiple-thread environments often cause significant service disruption by requiring all threads to be stopped during the patch installation process, leading to prolonged downtime and non-atomic patching where some threads use both old and new functions simultaneously.
Innovation Solution
A method where new functions are installed and a thread coordination zone is created to direct software threads to use either existing or new functions based on synchronization status, ensuring all threads use either the old or new functions, thereby maintaining continuous operation and achieving atomic patching without stopping threads.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If all threads are stopped during patch installation to ensure atomicity, then patch reliability is improved, but service disruption increases and productivity decreases
Solution Approach 1:
The patent applies preliminary action by installing the new software version into a staging area before it becomes active. The new version is prepared and validated in advance, then switched to when ready, avoiding the need to stop threads during the actual patch installation process. This resolves the contradiction by preparing the patch beforehand rather than applying it during operation.
Solution Approach 2:
The patent introduces an intermediary mechanism through version control data structures and staging areas that mediate between the old and new software versions. This intermediary layer allows threads to continue operating on the stable version while the new version is prepared, and enables atomic switching when the patch is ready, thus maintaining both reliability and service continuity.
2Productivity
If threads continue running during patch installation to maintain service continuity, then productivity is improved, but patch atomicity may be compromised and reliability worsens
Solution Approach 1:
The new software version is installed and validated in a staging area before becoming active. This preliminary preparation ensures that when the patch is applied, it is already ready and verified, maintaining atomicity without requiring thread suspension. Threads continue running throughout the process.
Solution Approach 2:
A staging area and version control mechanism act as intermediaries between the running threads and the new software version. This intermediary structure allows the new version to be prepared without affecting running threads, and enables atomic switching when the patch is ready, thus maintaining both service continuity and patch atomicity.
3Productivity
If new functions are installed without thread synchronization, then service disruption is minimized, but non-atomic patching occurs where some threads use both old and new functions
Solution Approach 1:
The new software version is completely installed and validated in the staging area before any threads are directed to use it. This preliminary completion ensures that when the switch occurs, all new functions are ready, preventing the mixed state where some threads use old and some use new functions.
Solution Approach 2:
The version control data structure and staging area serve as intermediaries that manage the transition between old and new versions. This intermediary mechanism ensures that threads atomically switch from the old version to the complete new version, preventing the non-atomic state where threads would use a mix of old and new functions.
4Reliability
If thread synchronization is implemented to ensure atomicity, then patch reliability is improved, but the complexity of the patching mechanism increases
Solution Approach 1:
The new software version is prepared and validated in advance in a staging area, eliminating the need for complex runtime synchronization. The preliminary preparation ensures atomicity through the staging mechanism rather than through complex thread coordination during patch application.
Solution Approach 2:
The version control data structure and staging area act as intermediaries that simplify the patching mechanism. Instead of implementing complex thread synchronization logic, the system uses the intermediary staging mechanism to automatically ensure atomic transitions, reducing overall system complexity while maintaining reliability.
Data Source
AI summary
A method in a network device with a processor that runs multiple software threads for software that needs an update for updating the software while mitigating service disruption, the method comprising installing at least one new function, modifying at least one existing function to point to a synchronization code, wherein the synchronization code indicates whether the multiple software threads use the at least one new function or the at least one existing function, synchronizing software threads in the network device, based on the synchronization code indicating that the synchronization of the software threads is not complete, using, by the multiple software threads, the at least one existing function, and based on the synchronization code indicating that the synchronization of the software threads is complete, using, by the multiple software threads, the at least one new function, wherein the multiple software threads continually run on the network device during the synchronization.