Inlining native functions into compiled java code

• US 8,312,439 B2
• Filed: 04/06/2009
• Issued: 11/13/2012
• Est. Priority Date: 02/18/2005
• Status: Expired due to Fees

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Kielstra, Allan Henry, Stepanian, Levon Sassoon, Stoodley, Kevin Alexander
• Primary Examiner(s): Bullock, Jr., Lewis A
• Assistant Examiner(s): Gooray, Mark
• Application Number:
  US12/418,989
• Publication Number:
  US 20090193404A1
• Time in Patent Office: 1,317 Days
• Field of Search: None
• 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 inlining native functions into compiled Java code. A conversion engine is provided by the present invention for converting the intermediate representation of native functions to the just-in-time (JIT) compiler'"'"'s intermediate representation. With the converted intermediate representation, an inliner recursively inlines the converted JIT compiler'"'"'s intermediate representation into the native callsite to remove the need of invoking the native function and subsequent native calls made by the function. The inlining process continues until either a call to an opaque function is encountered or until a JIT compiler intermediate representation growth limits are reached. The inliner also replaces calls to most native functions that are non-inlineable or opaque with calls to synthesized native functions that provide access to native libraries containing implementations of the original non-inlineable calls.

Claims

1. A method in a data processing system for inlining native functions into compiled Java code, the method comprising;

running a just-in-time compiler by a Java runtime environment to a standard inlining phase;

responsive to running the just-in-time compiler to the standard inlining phase, detecting a native function call at a Java callsite;

determining if the native function call is to an opaque function, wherein the call to the opaque function invokes procedures for which a just-in-time compiler cannot render an intermediate representation;

if the native function call is to an opaque function, determine whether the Java callsite was created while processing Java bytecodes;

if the Java callsite was not created while processing Java bytecode, synthesizing a Java callable native function, and replacing the native function call with a call to the synthesized native function, wherein the synthesized native function provides access to a native library containing an implementation of the opaque function;

responsive to determining that the native function call is not an opaque function, converting an intermediate representation of native function to a just-in-time compiler intermediate representation and omitting inlining of native functions called from opaque functions; and

inlining the just-in-time compiler intermediate representation into the Java callsite.

2. The method of claim 1, wherein the inlining step is recursively performed until one of the following:

determining that a just-in-time compiler growth limit is reached; and

responsive to determining that the just-in-time compiler growth limit is reached, limiting a number of native functions recursively inlined in order to limit negative side-effects on an instruction cache;

determining that the native function call is to an opaque function; and

determining that no additional native function call is present in a native function implementation.

3. The method of claim 1, wherein the native function call is invoked using a Java Native Interface, and is recursively inlined such that any native calls an inlined native function contains may also be subsequently inlined.

4. The method of claim 1, wherein the converting step comprises:

iterating through the intermediate representation of the native function; and

generating a just-in-time compiler intermediate representation for each instruction in the intermediate representation of the native function,

wherein the intermediate representation of the native function is retrieved from a native library containing native binary code and the intermediate representation of the native function.

5. The method of claim 1, wherein the inlining step comprises:

materializing a native interface environment pointer and making the pointer available to the actual implementation of the native function call.

6. The method of claim 5, further comprising:

if the native function call is to an opaque function, determining if the native function call represents a call from Java to a native function; and

if the native function call represents a call from Java to a native function, determining if the native function call is an original function call that started an entire inlining process.

7. The method of claim 6, further comprising:

if the native function call is the original function call that started the entire inlining process, resuming just-in-time compiler processing;

if the native function call is not an original function call that started the entire inlining process, converting the intermediate representation of the native function call to a just-in-time compiler intermediate representation.

8. The method of claim 1, wherein the just-in-time compiler intermediate representation is subsequently treated as Java Bytecodes, while maintaining adherence to semantics of original source language of the native function, by a just-in-time compiler after the converting step.

9. The method of claim 5, wherein the inlining step further comprises:

mapping parameters to arguments; and

merging native compiler and JIT compiler intermediate representation and control flow graphs.

10. The method of claim 6, further comprising:

inserting code to the compiled Java code to provide linkage to shared memory for data shared by inlined native functions, synthesized native functions and other functions in the native library.

11. The method of claim 6, further comprising:

inserting code in the compiled Java code to provide interaction between the actual implementation of the native function call and virtual machine components.

12. The method of claim 1, wherein the intermediate representation of the native function is binary code of the native function.

13. A data processing system for inlining native functions into compiled Java code, the data processing system comprising:

one or more processors, one or more non-transitory computer readable mediums, and one or more computer readable memories;

program instructions, stored in at least one non-transitory computer readable medium, for running a just-in-time compiler by a Java runtime environment to a standard inlining phase;

program instructions, stored in at least one non-transitory computer readable medium, for detecting, responsive to running the just-in-time compiler to the standard inlining phase, a native function call at a Java callsite;

program instructions, stored in at least one non-transitory computer readable medium, for determining if the native function call is to an opaque function, wherein the call to the opaque function invokes procedures for which a just-in-time compiler cannot render an intermediate representation;

program instructions, stored in at least one non-transitory computer readable medium, for determining, responsive to determining that the native function call is to an opaque function, whether the Java callsite was created while processing Java bytecodes;

program instructions, stored in at least one non-transitory computer readable medium, for synthesizing, responsive to determining that the Java callsite was not created while processing Java bytecode, a Java callable native function, and replacing the native function call with a call to the synthesized native function, wherein the synthesized native function provides access to a native library containing an implementation of the opaque function;

program instructions, stored in at least one non-transitory computer readable medium, for converting, responsive to determining that the native function call is not an opaque function, an intermediate representation of native function to a just-in-time compiler intermediate representation and omitting inlining of native functions called from opaque functions;

program instructions, stored in at least one non-transitory computer readable medium, for inlining the just-in-time compiler intermediate representation into the Java callsite.

14. The data processing system of claim 13, further comprising:

program instructions, stored in at least one non-transitory computer readable medium for recursively inlining until a just-in-time compiler growth limit is reached, and responsive to determining that the just-in-time compiler growth limit is reached, limiting a number of native functions recursively inlined in order to limit negative side-effects on an instruction cache until determining that the native function call is to an opaque function and until determining that no additional native function call is present in a native function implementation.

15. The data processing system of claim 13, wherein the native function call is invoked using a native interface, and is recursively inlined such that any native calls an inlined native function contains may also be subsequently inlined.

16. The data processing system of claim 13, further comprising:

program instructions, stored in at least one non-transitory computer readable medium, for iterating through the intermediate representation of the native function;

program instructions, stored in at least one non-transitory computer readable medium, for generating a just-in-time compiler intermediate representation for each instruction in the intermediate representation of the native function,

wherein the intermediate representation of the native function is retrieved from the native library, wherein the native library contains native binary code and the intermediate representation of the native function.

17. The data processing system of claim 13, further comprising:

program instructions, stored in at least one non-transitory computer readable medium, for replacing, responsive to determining that the native function call is not to an opaque function, the native function call with an actual implementation of the native function call using the intermediate just-in-time compiler intermediate representation; and

program instructions, stored in at least one non-transitory computer readable medium, for materializing a native interface environment pointer and passing the pointer to the actual implementation of the native function call.

18. The data processing system of claim 13, wherein the intermediate representation of the native function is binary code of the native function.

19. A computer program product in a non-transitory computer readable medium for inlining native functions into compiled Java code, the computer program product comprising:

first instructions, stored in the non-transitory computer readable medium, for running a just-in-time compiler by a Java runtime environment to a standard inlining phase;

second instructions, stored in the non-transitory computer readable medium, for detecting, responsive to running the just-in-time compiler to the standard inlining phase, a native function call at a Java callsite;

third instructions, stored in the non-transitory computer readable medium, for determining if the native function call is to an opaque function, wherein the call to the opaque function invokes procedures for which a just-in-time compiler cannot render an intermediate representation;

fourth instructions, stored in the non-transitory computer readable medium, for determining, responsive to determining that the native function call is to an opaque function, whether the Java callsite was created while processing Java bytecodes;

fifth instructions, stored in the non-transitory computer readable medium, for synthesizing, responsive to determining that the Java callsite was not created while processing Java bytecode, a Java callable native function, and replacing the native function call with a call to the synthesized native function, wherein the synthesized native function provides access to a native library containing an implementation of the opaque function;

sixth instructions, stored in the non-transitory computer readable medium, for converting, responsive to determining that the native function call is not an opaque function, an intermediate representation of native function to a just-in-time compiler intermediate representation and omitting inlining of native functions called from opaque functions;

seventh instructions, stored in the non-transitory computer readable medium, for inlining the just-in-time compiler intermediate representation into the native function.

20. The computer program product of claim 19, wherein the second instructions further comprise:

first sub-instructions, stored in the non-transitory computer readable medium, for iterating through the intermediate representation of the native function; and

second sub-instructions, stored in the non-transitory computer readable medium, for generating a just-in-time compiler intermediate representation for each instruction in the intermediate representation of the native function,

wherein the intermediate representation of the native function is retrieved from a native library containing native binary code and the intermediate representation of the native function.

21. The computer program product of claim 19, wherein the seventh instructions further comprise:

a sub-instructions, stored in the computer readable medium, for materializing a native interface environment pointer and passing the pointer to the actual implementation of the native function call.

22. The computer program product of claim 19, wherein the intermediate representation of the native function is binary code of the native function.

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

a sub-instructions, stored in the non-transitory computer readable medium, for determining if the native function call represents a call from Java to a native function, if the native function call is to an opaque function.