METHOD AND APPARATUS FOR INLINING NATIVE FUNCTIONS INTO COMPILED JAVA CODE

• US 20090193404A1
• Filed: 04/06/2009
• Published: 07/30/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 8,312,439 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 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:

detecting a native function call at a Java callsite;

converting an intermediate representation of a native function to a just-in-time compiler intermediate representation; 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, wherein the just-in-time compiler growth limit indicates how many native functions may be 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:

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 not to an opaque function, replacing the native function call with an actual implementation of the native function call using the just-in-time compiler intermediate representation; and

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;

if the native function call does not represent a call from Java to a native function, 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; and

if the native function call represent 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:

a conversion engine for converting an intermediate representation of a native function to a just-in-time compiler intermediate representation, responsive to detecting a native function call at a Java callsite;

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

14. The data processing system of claim 13, wherein the just-in-time compiler inliner performs inlining recursively until a just-in-time compiler growth limit is reached, wherein the just-in-time compiler growth limit indicates how many native functions may be 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, wherein the conversion engine iterates through the intermediate representation of the native function;

and

generates 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.

17. The data processing system of claim 13, wherein the just-in-time compiler inliner further determines 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 not to an opaque function, replaces the native function call with the actual implementation of the native function call using the intermediate just-in-time compiler intermediate representation; and

materializes a native interface environment pointer and passes the pointer to the actual implementation of the native function call.

18. The data processing system of claim 17, wherein the just-in-time compiler inliner further determines if the native function call represents a call from Java to a native function, if the native function call is to an opaque function;

if the native function call does not represent a call from Java to a native function, synthesizes a Java callable native function; and

replaces the native function call with a call to the synthesized native function, wherein the synthesized native function provides access to a native library containing implementation of the opaque function.

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

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

first instructions for detecting a native function call at a Java callsite;

second instructions for converting an intermediate representation of a native function to a just-in-time compiler intermediate representation; and

third instructions for inlining the just-in-time compiler intermediate representation into the native callsite.

21. The computer program product of claim 20, wherein the second instructions comprises:

first sub-instructions for iterating through the intermediate representation of the native function; and

second sub-instructions 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.

22. The computer program product of claim 20, wherein the third instructions comprises:

first sub-instructions 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;

second sub-instructions for replacing the native function call with an actual implementation of the native function call using the just-in-time compiler intermediate representation, if the native function call is not to an opaque function; and

third sub-instructions for materializing a native interface environment pointer and passing the pointer to the actual implementation of the native function call.

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

fourth sub-instructions 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;

fifth instructions for synthesizing the native function, if the native function call does not represent a call from Java to a native function; and

sixth sub-instructions for 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 implementation of the opaque function.

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