JUST-IN-TIME COMPILER SUPPORT FOR INTERRUPTIBLE CODE

• US 20090055814A1
• Filed: 08/20/2007
• Published: 02/26/2009
• Est. Priority Date: 08/20/2007
• Status: Active Grant

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Gallop, Patrick G., Inglis, Derek Bruce, Stoodley, Mark Graham
• Granted Patent: US 8,291,393 B2
• Time in Patent Office: Days
• US Class Current: 717/159
• CPC Class Codes: G06F 8/4441 Reducing the execution time required by the program code
• CPC Class Codes: G06F 9/45516 Runtime code conversion or optimisation

Abstract

A computer implemented method for performing inlining in a just-in-time compiler. Compilation of a first code of a program is begun. The first code is one of an interruptible code and a non-interruptible code. A try region is established around a second code of the program to form a wrapped second code. The try region is a boundary between interruptible and non-interruptible code such that a third code that modifies an observable state of the program cannot be moved across the boundary. The second code is, relative to the first code, the other of the interruptible code and the non-interruptible code. The wrapped second code is inlined with the first code during compilation. Compilation of the first code is completed to form a resultant code. The resultant code is stored.

Claims

1. A method for performing inlining in a just-in-time compiler, the method comprising the computer implemented steps of:

beginning compilation of a first code of a program, wherein the first code comprises one of an interruptible code and a non-interruptible code;

establishing a try region around a second code of the program to establish a wrapped second code, wherein the try region comprises a boundary between interruptible and non-interruptible code such that a third code that modifies an observable state of the program cannot be moved across the boundary, and wherein the second code comprises, relative to the first code, the other of the interruptible code and the non-interruptible code;

inlining the wrapped second code with the first code during compilation;

completing compilation of the first code to form a resultant code; and

storing the resultant code.

2. The method of claim 1 wherein the try region has a single exception handler.

3. The method of claim 1 wherein the third code comprises at least one of the first code, the second code, a part of the first code, a part of the second code, and combinations thereof.

4. The method of claim 1 further comprising:

adding a pointer on a thread structure associated with the program, wherein during execution of the resultant code and when a thread associated with the thread structure should be interrupted, the pointer is set to an address of an interrupt exception object.

5. The method of claim 4 wherein at a time during execution of the resultant code, and other than when the thread should be interrupted, a value of the pointer is null.

6. The method of claim 1 further comprising:

inserting a fourth code into the interruptible code at a point where, upon execution of the resultant code and responsive to a determination that a current thread should be interrupted, execution will transfer to the non-interruptible code by throwing an exception associated with interruption of the current thread.

7. The method of claim 6 wherein the fourth code is inserted on entry to the interruptible code and at every exit from an interruptible code.

8. The method of claim 6 wherein the program is written in JAVA and wherein the program supports asynchronous transfer of control, and wherein the fourth code is inserted before outermost monitorenter byte codes and after monitorexit byte codes in the interruptible code.

9. The method of claim 6 wherein the fourth code is inserted inside a loop of the interruptible code so that, upon execution of the resultant code, a pending interrupt will be detected within one iteration of the loop being posted on the thread.

10. The method of claim 1 wherein the resultant code further comprises metadata, wherein the metadata comprises a corresponding flag for all handlers of the resultant code, and wherein the flag indicates whether a code range associated with the handlers is one of interruptible and non-interruptible.

11. The method of claim 10 further comprising:

executing the resultant code; and

responsive to a determination that a current thread has thrown a current exception, directing, during runtime, program execution to a first correct exception handler for a program point where the current exception was thrown and for a class of the current exception.

12. The method of claim 11, further comprising:

responsive to a determination that a particular flag associated with the first correct exception handler indicates that the first correct exception handler is interruptible and that the current exception is an interrupt, ignoring the first correct exception handler;

searching for a new correct exception handler, wherein the new correct exception handler is different than the first correct exception handler;

determining whether the new correct exception handler is a suitable non-interruptible exception handler;

responsive to the new correct handler being an unsuitable non-interruptible exception handler, repeating searching; and

responsive to the new correct exception handler being a suitable non-interruptible exception handler, establishing the new correct exception handler as the exception handler for the current exception.

13. A computer program product comprising:

a computer usable medium having computer usable program code for performing inlining in a just-in-time compiler, the computer program product including;

computer usable program code for beginning compilation of a first code of a program, wherein the first code comprises one of an interruptible code and a non-interruptible code;

computer usable program code for establishing a try region around a second code of the program to form a wrapped second code, wherein the try region comprises a boundary between interruptible and non-interruptible code such that a third code that modifies an observable state of the program cannot be moved across the boundary, and wherein the second code comprises, relative to the first code, the other of the interruptible code and the non-interruptible code;

computer usable program code for inlining the wrapped second code with the first code during compilation; and

computer usable program code for completing compilation of the first code to form a resultant code.

14. The computer program product of claim 13 wherein the resultant code further comprises metadata, wherein the metadata comprises a corresponding flag for all handlers of the resultant code, and wherein the flag indicates whether a code range associated with the handlers is one of interruptible and non-interruptible.

15. The computer program product of claim 14 further comprising:

computer usable program code for executing the resultant code; and

computer usable program code for, responsive to a determination that a current thread has thrown a current exception, directing, during runtime, program execution to a first correct exception handler for a program point where the current exception was thrown and for a class of the current exception.

16. The computer program product of claim 15, further comprising:

computer usable program code for, responsive to a determination that a particular flag associated with the first correct exception handler indicates that the first correct exception handler is interruptible and that the current exception is an interrupt, ignoring the first correct exception handler;

computer usable program code for searching for a new correct exception handler, wherein the new correct exception handler is different than the first correct exception handler;

computer usable program code for determining whether the new correct exception handler is a suitable non-interruptible exception handler;

computer usable program code for, responsive to the new correct handler being an unsuitable non-interruptible exception handler, repeating searching; and

computer usable program code for, responsive to the new correct exception handler being a suitable non-interruptible exception handler, establishing the new correct exception handler as the exception handler for the current exception.

17. A data processing system comprising:

a bus;

at least one processor coupled to the bus;

a computer usable medium coupled to the bus, wherein the computer usable medium contains a set of instructions for performing inlining in a just-in-time compiler, wherein the at least one processor is adapted to carry out the set of instructions to;

begin compilation of a first code of a program, wherein the first code comprises one of an interruptible code and a non-interruptible code;

establish a try region around a second code of the program to form a wrapped second code, wherein the try region comprises a boundary between interruptible and non-interruptible code such that a third code that modifies an observable state of the program cannot be moved across the boundary, and wherein the second code comprises, relative to the first code, the other of the interruptible code and the non-interruptible code;

inline the wrapped second code with the first code during compilation; and

complete compilation of the first code to form a resultant code.

18. The data processing system of claim 17 wherein the resultant code further comprises metadata, wherein the metadata comprises a corresponding flag for all handlers of the resultant code, and wherein the flag indicates whether a code range associated with the handlers is one of interruptible and non-interruptible.

19. The data processing system of claim 18 wherein the at least one processor is further adapted to carry out the set of instructions to:

execute the resultant code; and

responsive to a determination that a current thread has thrown a current exception, direct, during runtime, program execution to a first correct exception handler for a program point where the current exception was thrown and for a class of the current exception.

20. The data processing system of claim 19, wherein the at least one processor is further adapted to carry out the set of instructions to:

responsive to a determination that a particular flag associated with the first correct exception handler indicates that the first correct exception handler is interruptible and that the current exception is an interrupt, ignore the first correct exception handler;

search for a new correct exception handler, wherein the new correct exception handler is different than the first correct exception handler;

determine whether the new correct exception handler is a suitable non-interruptible exception handler;

responsive to the new correct handler being an unsuitable non-interruptible exception handler, repeat searching; and

responsive to the new correct exception handler being a suitable non-interruptible exception handler, establish the new correct exception handler as the exception handler for the current exception.