Method and Apparatus for Transforming Java Native Interface Function Calls into Simpler Operations During Just-In-Time Compilation

• US 20090144710A1
• Filed: 02/05/2009
• Published: 06/04/2009
• Est. Priority Date: 02/18/2005
• Status: Active Grant

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Stoodley, Kevin Alexander, Stepanian, Levon Sassoon, Kielstra, Allan Henry
• Granted Patent: US 7,913,240 B2
• Time in Patent Office: Days
• US Class Current: 717/148
• CPC Class Codes: G06F 9/45516 Runtime code conversion or optimisation

Abstract

A method, apparatus, and computer instructions are provided for transforming Java Native Interface function calls to constants, internal just-in-time compiler operations or simpler intermediate representation. A compiler generates a plurality of intermediate representations for a plurality of native interface function calls. During inlining of native code, matching is performed on each native function call (against this list) and a list of native interface function calls is generated. For each native interface function call, a JIT call transformer attempts to replace the native interface function call with a constant, internal just-in-time compiler operation or a simpler intermediate representation depending on the type of native interface function call.

Claims

1. A method in a data processing system for transforming native interface function calls into simpler operations during just-in-time compilation, the method comprising:

constructing a list of shapes rendered in an intermediate language of a just-in-time compiler and representing a plurality of native interface function calls;

identifying a list of native interface function calls for possible transformation by matching the plurality of native interface function calls made in the native language program against the list of shapes;

performing a definition and use analysis on each of the list of identified native interface function calls by tracking a plurality of values passed as parameters to a plurality of arguments of native interface functions; and

transforming a portion of the list of native interface function calls into one of a constant, an internal just-in-time compiler operation, and a simpler intermediate representation using results of the definition and use analysis.

2. The method of claim 1, wherein the list of shapes comprises intermediate representation of the plurality of native interface function calls and includes usage of a native interface environment variable and user arguments by the plurality of native functions calls.

3. The method of claim 2, wherein identifying step is performed during inlining of native function calls, responsive to detecting a native interface function call in an inlined native function call, and wherein the identifying step further comprises:

determining, for each of the list of identified native interface function calls, if the native interface environment variable is used in a same manner as in a shape in the list of generated shapes;

if the native interface environment variable is used in the same manner as in a shape in the list of constructed shapes, determining if a match exists between the shape and an intermediate representation of the native interface function call, wherein a match exists if the intermediate representation of the native interface function call has a same number of arguments and each argument in the native interface function call is compatible with a type of argument in the shape; and

if a match exists between the shape and the intermediate representation of the native interface function call, adding the native interface function call to the list of native interface function calls, wherein the list of native interface function calls is sorted in an order of appearance in the intermediate representation of the plurality of native interface function calls.

4. The method of claim 3, wherein the definition and use analysis includes tracking a plurality of objects passed to the list of native interface function calls to point where the plurality of objects are passed as arguments to a native interface function after the list of native interface function calls is identified.

5. The method of claim 4, wherein the transforming step comprising:

for each native interface function call in the list of native interface function calls, determining if the definition and use analysis returns conclusive result;

if the definition and use analysis returns conclusive result, determining a type of the native interface function call; and

replacing the native interface function call with one of a constant value, an internal just-in-time compiler operation, and a simpler intermediate representation depending on the type of native interface function call.

6. The method of claim 5, further comprising:

if the definition and use analysis returns a known result, replacing the callsite with intermediate representation containing conditional logic, representing the semantics of the specified call;

if the definition and use analysis returns an unknown result, discarding the native interface function call and any other native interface function call that uses the native interface function call from the list of native interface calls under consideration.

7. The method of claim 5, wherein the constants, internal just-in-time compiler operations and simpler intermediate representation provide direct and faster access to services and data of a virtual machine, wherein the internal just-in-time compiler operation performs its function without using the native interface.

8. The method of claim 1, wherein a shape in the list of shapes includes means represented in intermediate representation for accessing an actual target native interface function and treatment represented in intermediate representation each actual argument receives, and wherein the shape uniquely identifies the actual target native interface function.

9. The method of claim 1, wherein the definition and use analysis determines what variables are defined and where the defined variables are used.

10. A data processing system for transforming native interface function calls into simpler operations during just-in-time compilation, the data processing system comprising:

a processor and a memory communicatively coupled to the processor, the memory storing instructions comprising;

a just-in-time compiler for constructing a list of shapes rendered in an intermediate language of a just-in-time compiler for a plurality of native interface function calls;

a just-in-time compiler inliner for identifying, from the list of shapes, a list of native interface function calls for possible transformation;

wherein the just-in-time compiler performs a definition and use analysis on the list of native interface function calls and a plurality of arguments passed to the native interface functions, wherein the definition and use analysis determines what variables are defined and where the defined variables are used; and

a just-in-time call transformer for transforming a portion of the list of native interface function calls into one of a constant, an internal just-in-time compiler operation and a simpler intermediate representation using results of the definition and use analysis.

11. The data processing system of claim 10, wherein the list of shape comprises intermediate representation of the plurality of native interface function calls and includes usage of a native interface environment variable and user arguments by the plurality of native functions calls.

12. The data processing system of claim 11, wherein the just-in-time compiler inliner identifies the list of native interface function calls for transformation during inlining of native function calls, responsive to detecting a native interface function call in an inlined native function call, and wherein the just-in-time compiler inliner further:

determines, for each of the list of identified native interface function calls, if the native interface environment variable is used in a same manner as in a shape in the list of constructed shapes;

if the native interface environment variable is used in the same manner as in a shape in the list of generated shapes, determines if a match exists between the shape and an intermediate representation of the native function call, wherein a match exists if the intermediate representation of the native interface function call has a same number of arguments and each argument in the native interface function call is compatible with a type of argument in the shape; and

if a match exists between the shape and the intermediate representation of the native interface function call, adds the native interface function call to the list of native interface function calls, wherein the list of native interface function calls is sorted in an order of appearance in the intermediate representation of the plurality of native interface function calls.

13. The data processing system of claim 12, wherein the just-in-time compiler tracks a plurality of objects passed to the list of native interface function calls to point where the plurality of objects are passed as arguments to a native interface function after the list of native interface function calls is identified.

14. The data processing system of claim 13, wherein the just-in-time call transformer further:

for each native interface function call in the list of native interface function calls, determines if the definition and use analysis returns a known result;

if the definition and use analysis returns a known result, determines a type of the native interface function call; and

replaces the native interface function call with one of a constant value, an internal just-in-time compiler operation, and a simpler intermediate representation depending on the type of native interface function call.

15. The data processing system of claim 14, wherein the just-in-time transformer further:

discards the native interface function call and any other native interface function call that uses the native interface function call from the list of native interface calls, if the definition and use analysis returns an unknown result.

16. The data processing system of claim 14, wherein the internal just-in-time compiler operation provides direct and faster access to services and data of a virtual machine, wherein the internal just-in-time compiler operation performs its function without using the native interface.

17. A computer program product in a computer readable recordable medium for transforming native interface function calls into simpler operations during just-in-time compilation, the computer program product comprising:

first instructions for constructing a list of intermediate representation shapes representing a plurality of native interface function calls;

second instructions for identifying a list of native interface function calls for possible transformation by matching the plurality of native interface function calls made in the native language program against the list of shapes;

third instructions for performing a definition and use analysis on each of the list of identified native interface function calls by tracking a plurality of values passed as parameters to a plurality of arguments of native interface functions, wherein the definition and use analysis determines what variables are defined and where the defined variables are used; and

fourth instructions for transforming a portion of the list of native interface function calls into one of a constant, an internal just-in-time compiler operations and a simpler intermediate representation using results of the definition and use analysis.

18. The computer program product of claim 17, wherein the list of shape comprises intermediate representation of the plurality of native interface function calls and includes usage of a native interface environment variable and user arguments by the plurality of native interface functions calls.

19. The computer program product of claim 18, wherein second instructions is performed during inlining of native functions calls, responsive to detecting a native interface function call in an inlined native function call, and wherein the second instructions further comprise:

first sub-instructions for determining, for each of the list of identified native interface function calls, if the native interface environment variable is used in a same manner as in a shape in the list of constructed shapes;

second sub-instructions for determining if a match exists between the shape and an intermediate representation of the native function call, if the native interface environment variable is used in the same manner as in a shape in the list of generated shapes wherein a match exists if the intermediate representation of the native interface function call has a same number of arguments and each argument in the native interface function call is compatible with a type of argument in the shape; and

third sub-instruction for adding the native interface function call to the list of native interface function calls, if a match exists between the shape and the intermediate representation of the native interface function call, wherein the list of native interface function calls is sorted in an order of appearance in the intermediate representation of the plurality of native interface function calls.

20. The computer program product of claim 19, wherein the third instructions include first sub-instructions for tracking a plurality of objects passed to the list of native interface function calls to point where the plurality of objects are passed as arguments to a native interface function after the list of native interface function calls is identified.

21. The computer program product of claim 20, wherein the fourth instructions comprising:

first sub-instructions for determining if the definition and use analysis returns a known result for each native interface function call in the list of native interface function calls;

second sub-instructions for determining a type of the native interface function call if the definition and use analysis returns a known result; and

third sub-instructions for replacing the native interface function call with one of a constant value, an internal just-in-time compiler operation, and a simpler intermediate representation depending on the type of native interface function call.

22. The computer program product of claim 21, further comprising:

fourth instructions for discarding the native interface function call and any other native interface function call that uses the native interface function call from the list of native interface calls, if the definition and use analysis returns an unknown result.

23. The computer program product of claim 21, wherein the internal just-in-time compiler operation provides direct and faster access to services and data of a virtual machine, wherein the internal just-in-time compiler operation comprises sub-instructions for performing its function without using a native interface.