Dynamic Software Updating Function Retirement via Collector Thread
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing dynamic software updating (DSU) systems fail to efficiently retire older versions of software applications without synchronization overhead, especially in multi-threaded environments where multiple versions coexist concurrently.
Innovation Solution
A method and system utilizing reference counters and a collector-thread to monitor and retire dynamically updatable functions by tracking active calls across multiple execution threads, allowing for the deletion of older versions without synchronization, and enabling indirect calls to the most recent version through a pointer system.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If a lockstep system is used to ensure all threads migrate to the newer version before retiring the older version, then system consistency is maintained, but update time and productivity are reduced due to synchronization overhead
Solution Approach 1:
The system divides the update process into independent per-thread tracking units. Each thread's version execution state is monitored separately through individual counters, allowing parallel progression rather than forced sequential migration. This segmentation enables threads to retire old versions at different times based on their own execution pace, eliminating global synchronization barriers while maintaining overall system consistency.
Solution Approach 2:
The patent introduces a collector thread as an intermediary that periodically checks counter values without blocking execution threads. This intermediary approach allows the system to monitor version usage across all threads and coordinate retirement decisions without requiring threads to synchronize at specific points, thus maintaining consistency while avoiding synchronization overhead.
2Productivity
If multiple versions of the same module execute concurrently in a multiple-version system, then productivity is improved through parallel updates, but device complexity increases due to version management overhead
Solution Approach 1:
The patent extracts the version tracking logic from the main execution flow and places it in a separate collector thread that periodically checks counter values. This extraction removes the complexity of version management from individual execution threads, allowing them to focus solely on their computational tasks while the collector thread handles the coordination of version retirement across the system.
Solution Approach 2:
Each execution thread automatically increments its own counter when calling a function version, and the collector thread uses these self-maintained counters to determine retirement timing. This self-service approach to version tracking eliminates the need for complex centralized version management mechanisms, reducing overall system complexity while enabling parallel version execution.
Data Source
AI summary
An embodiment method for retiring a dynamically updatable function includes receiving, by a collector-thread, a registration of the function, wherein the registration indicates to the collector-thread addresses of memory locations for counters that count a number of calls currently being made to a previous version of the function by a plurality of execution threads; reading, by the collector-thread, values of the counters; and when the values of all the counters are zero, deleting, by the collector-thread, the function from a storage medium on a device previously executing the previous version of the function.