Multi-version asynchronous dynamic software update system and method for applications with multiple threads

• US 10,430,208 B2
• Filed: 05/02/2017
• Issued: 10/01/2019
• Est. Priority Date: 05/02/2017
• Status: Active Grant

• Current Assignee: Huawei Technologies Co., Ltd. (Huawei Investment & Holding Co., Ltd.)
• Original Assignee: Huawei Technologies Co., Ltd. (Huawei Investment & Holding Co., Ltd.)
• Inventors: Wang, Kai-Ting Amy, Wu, Peng, Dobry, Brice, Wang, Haichuan
• Primary Examiner(s): Aponte, Francisco J
• Application Number:
  US15/584,785
• Publication Number:
  US 20180321956A1
• Time in Patent Office: 882 Days
• Field of Search: 717170
• CPC Class Codes: G06F 8/434 Pointers; Aliasing
• CPC Class Codes: G06F 8/656 while running
• CPC Class Codes: G06F 8/71 Version control security arrangements therefor G06F21/57; Configuration management
• CPC Class Codes: G06F 9/223 Execution means for microinstructions irrespective of the microinstruction function, e.g. decoding of microinstructions and nanoinstructions; timing of microinstructions; programmable logic arrays; delays and fan-out problems
• CPC Class Codes: G06F 9/3893 controlled in tandem, e.g. multiplier-accumulator
• CPC Class Codes: G06F 9/44521 Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
• CPC Class Codes: G06F 9/44526 Plug-ins; Add-ons
• CPC Class Codes: G06F 9/44536 Selecting among different versions
• CPC Class Codes: G06F 9/44552 Conflict resolution, i.e. enabling coexistence of conflicting executables
• CPC Class Codes: G06F 9/449 Object-oriented method invocation or resolution
• CPC Class Codes: G06F 9/52 Program synchronisation; Mutual exclusion, e.g. by means of semaphores

Abstract

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.

Claims

1. A method for updating a software component used by a multi-threaded application, comprising:

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;

setting a global pointer to point to the first function table;

copying the global pointer to a local pointer of a first application thread of the multi-threaded application;

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 that the local pointer of the first application thread points to, when running the first application thread, to execute the functions from the first version of the software component;

responsive to receiving a signal indicating that the second version of the software component is available, updating the global pointer to point to the second function table;

copying the global pointer to a local pointer of a second application thread of the multi-thread application; and

referencing the second function table that the local pointer of the second application thread points to, when running the second application thread that is active concurrently with the first application thread, to execute the functions from the second version of the software component.

2. The method of claim 1 wherein the first function table and the second function table are stored as objects in a linked list.

3. The method of claim 1 comprising copying the global pointer to the local pointer of the first application thread to update the first application thread to the functions from the second version of the software component.

4. The method of claim 3 comprising de-allocating memory for the first version of the software component when no application threads have a local pointer that references the first function table.

5. The method of claim 1 comprising including a pointer in the second function table that points to the first function table.

6. The method of claim 1 wherein the application is a Go program and the running threads are goroutines.

7. A processing system configured to update a live software component used by a multi-threaded application, comprising:

a processing device;

a memory associated with the processing device;

a non-transient storage for storing instructions that when loaded to the memory and executed by the processing device cause the processing system to;

store, in the memory, a first function table that points to executable code in the memory for functions from a first version of a software component;

set a global pointer to point to the first function table;

copy the global pointer to a local pointer of a first application thread of the multi-threaded application;

store, 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;

reference the first function table that the local pointer of the first application thread points to, when running the first thread of an application, to execute the functions from the first version of the software component;

responsive to receiving a signal indicating that the second version of the software component is available, update the global pointer to point to the second function table;

copy the global pointer to a local pointer of a second application thread of the multi-thread application; and

reference the second function table that the local pointer of the second application thread points to, when running the second thread of the application that is active concurrently with the first thread, to execute the functions from the second version of the software component.

8. The system of claim 7 wherein the instructions:

cause the processing system to copy the global pointer to the local pointer of the first application thread, by;

setting, when the first thread is created, the local pointer of the first thread equal to the global pointer; and

cause the processing system to copy the global pointer to the local pointer of the second application thread, by;

setting, when the second thread is created, the local pointer of the second thread equal to the global pointer.

9. The system of claim 8 wherein the instructions cause the processing system to:

for each of the threads of the application, asynchronously set the local pointer of the thread to a current value of the global pointer if the local pointer is not equal to the current value of the global pointer.

10. The system of claim 9 wherein the instructions cause the processing system to:

maintain a counter for each of the stored function tables that identifies a number of active threads having local pointers that point to the function table; and

delete stored function tables that are not pointed at by the local pointers of any active threads.

11. The system of claim 7 wherein the function tables are stored in the memory as a linked list of shared objects.

12. The system of claim 11 where in the function tables are stored in a cache region of the memory allocated to the application.

13. The system of claim 7 wherein the application is a Go program and the threads are goroutines.

14. A computer program product comprising a non-transient storage medium storing instructions to cause a processing device to:

store, in memory allocated to a program, a first function table that points to executable code in the memory for functions from a first version of a software component;

set a global pointer to point to the first function table;

copy the global pointer to a local pointer of a first application thread of the multi-threaded application;

store, 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;

reference the first function table that the local pointer of the first application thread points to, when running the first application thread, to execute the functions from the first version of the software component;

responsive to receiving a signal indicating that the second version of the software component is available, update the global pointer to point to the second function table in accordance with the received signal;

copy the global pointer to a local pointer of a second application thread; and

reference the second function table that the local pointer of the second application thread points to, when running the second application thread that is active concurrently with the first application thread, to execute the functions from the second version of the software component.

15. The computer program product of claim 14 wherein the first function table and the second function table are stored as shared objects in a linked list.