Method, system and program product for implementing single threaded optimizations in a potentially multi-threaded environment

• US 20060048116A1
• Filed: 08/30/2004
• Published: 03/02/2006
• Est. Priority Date: 08/30/2004
• Status: Active Grant

• Current Assignee: Meta Platforms, Inc. (f/k/a Facebook, Inc.)
• Original Assignee: International Business Machines Corporation
• Inventors: Sundaresan, Vijay, Gray-Donald, Trent A., Inglis, Derek B., Stoodley, Kevin A.
• Granted Patent: US 7,395,530 B2
• Time in Patent Office: Days
• US Class Current: 717/151
• CPC Class Codes: G06F 8/443 Optimisation

Abstract

Under the present invention, program code is examined (statically or dynamically) for characteristics indicative of a potential to generate multiple threads. If none are found, single threaded optimization(s) such as desynchronization, optimization of globals, etc., can be implemented. In addition, if the program code is later revealed to have the potential to generate multiple threads, the single threaded optimization(s) can be corrected to avoid incorrect execution.

Claims

1. A method for implementing single threaded optimizations in a potentially multi-threaded environment, comprising:

examining program code for characteristics indicative of a potential to generate multiple threads; and

implementing at least one single threaded optimization if the examining step reveals that the program code does not have the potential to generate multiple threads, wherein the implementing step is correctible if the program code is later revealed to have the potential to generate multiple threads.

2. The method of claim 1, wherein the examining step is performed dynamically as the program code is running.

3. The method of claim 2, wherein performing the examining step dynamically allows the method to be refined, and wherein the method is refined by at least one of reducing a number of situations that prevent single threaded optimizations from being implemented and delaying correction of single threaded optimizations that have been implemented.

4. The method of claim 1, wherein the examining step is performed statically before the program is run.

5. The method of claim 1, wherein the examining step comprises examining the program code for a thread creation primitive.

6. The method of claim 1, wherein the examining step comprises examining a finalizer method in each class that is loaded by the program code for the potential to generate multiple threads.

7. The method of claim 1, wherein the examining step comprises examining whether a native thread created by any process of the program code is attached to a Java process.

8. The method of claim 1, wherein the implementing step comprises desynchronizing the program code if the examining step reveals that the program code does not have the potential to generate multiple threads.

9. The method of claim 1, wherein the implementing step comprises at least one of:

optimizing globals for the program code if the examining step reveals that the program code does not have the potential to generate multiple threads; and

removing the at least one single threaded optimization if the examining step is erroneous.

10. A method for implementing single threaded optimizations in a potentially multi-threaded environment, comprising:

dynamically examining program code for characteristics indicative of a potential to generate multiple threads;

implementing at least one single threaded optimization if the dynamically examining step reveals that the program code does not have the potential to generate multiple threads; and

removing the at least one single threaded optimization if the program code is later revealed to have the potential to generate multiple threads.

11. A system for implementing single threaded optimizations in a potentially multi-threaded environment, comprising:

a code examination system for examining program code for characteristics indicative of a potential to generate multiple threads;

an optimization system for implementing at least one single threaded optimization if the code examination system reveals that the program code does not have the potential to generate multiple threads; and

a review system for removing the at least one single threaded optimization if the program code is later revealed to have the potential to generate multiple threads.

12. The system of claim 11, wherein the code examination system examines the program code dynamically as the program code is running.

13. The system of claim 11, wherein the code examination system examines the program code statically as the program code is being compiled.

14. The system of claim 11, wherein the code examination system examines the program code for a thread creation primitive.

15. The system of claim 11, wherein the code examination system examines a finalizer method in each class that is loaded by the program code for the potential.

16. The system of claim 11, wherein the code examination system examines whether a native thread created by any process of the program code is attached to a Java process.

17. The system of claim 11, wherein the optimization system desynchronizes the program code if the code examination system reveals that the program code does not have the potential to generate multiple threads.

18. The system of claim 11, wherein the optimization system optimizes globals for the program code if the code examination system reveals that the program code does not have the potential to generate multiple threads.

19. A program product stored on a recordable medium for implementing single threaded optimizations in a potentially multi-threaded environment, which when executed, comprises:

means for examining program code for characteristics indicative of a potential to generate multiple threads;

means for implementing at least one single threaded optimization if the means for examining reveals that the program code does not have the potential to generate multiple threads; and

means for removing the at least one single threaded optimization if the program code is later revealed to have the potential to generate multiple threads.

20. The program product of claim 19, wherein the means for examining examines the program code dynamically as the program code is running.

21. The program product of claim 19, wherein the means for examining examines the program code statically as the program code is being compiled.

22. The program product of claim 19, wherein the means for examining examines the program code for a thread creation primitive.

23. The program product of claim 19, wherein the means for examining examines a finalizer method in each class that is loaded by the program code for the potential.

24. The program product of claim 19, wherein the means for examining examines whether a native thread created by any process of the program code is attached to a Java process.

25. The program product of claim 19, wherein the means for implementing desynchronizes the program code if the means for examining reveals that the program code does not have the potential to generate multiple threads.

26. The program product of claim 19, wherein the means for implementing optimizes globals for the program code means for examining reveals that the program code does not have the potential to generate multiple threads.

27. A system for deploying an application for implementing single threaded optimizations in a potentially multi-threaded environment, comprising:

a computer infrastructure being operable to;

examine program code for characteristics indicative of a potential to generate multiple threads;

implement at least one single threaded optimization if the means for examining reveals that the program code does not have the potential to generate multiple threads; and

remove the at least one single threaded optimization if the program code is later revealed to have the potential to generate multiple threads.

28. Computer software embodied in a propagated signal for implementing single threaded optimizations in a potentially multi-threaded environment, the computer software comprises instructions to cause a computer system to perform the following functions:

examine program code for characteristics indicative of a potential to generate multiple threads;

implement at least one single threaded optimization if the means for examining reveals that the program code does not have the potential to generate multiple threads; and

remove the at least one single threaded optimization if the program code is later revealed to have the potential to generate multiple threads.