Instances of just-in-time (JIT) compilation of code using different compilation settings

Patent metadata

Field	Value
Publication number	US-11487565-B2
Application number	US-202017083769-A
Country	US
Kind code	B2
Filing date	Oct 29, 2020
Priority date	Oct 29, 2020
Publication date	Nov 1, 2022
Grant date	Nov 1, 2022

Abstract

In some examples, just-in-time (JIT) control instructions upon execution cause a system to initiate a plurality of instances of JIT compilation of a first code called by a program, where the initiating of the plurality of instances of the JIT compilation of the first code is under control of the JIT control instructions that are outside the program, and the plurality of instances of the JIT compilation of the first code use respective different compilation settings, and are to produce respective JIT compiled instances of the first code.

First claim

What is claimed is:

1. A non-transitory machine-readable storage medium comprising just-in-time (JIT) control instructions that upon execution cause a system to:
initiate a plurality of instances of JIT compilation of a first code called by a program, wherein the initiating of the plurality of instances of the JIT compilation of the first code is under control of the JIT control instructions that are outside the program, the plurality of instances of the JIT compilation of the first code using respective different compilation settings, and are to produce respective plural JIT compiled instances of the first code;
store, in a data repository, the plural JIT compiled instances of the first code produced using the respective different compilation settings; and
in response to a call of the first code in the program, select a JIT compiled instance of the first code from among the plural JIT compiled instances of the first code stored in the data repository, the selecting being based on a criterion.

2. The non-transitory machine-readable storage medium of claim 1 , wherein the JIT control instructions upon execution cause the system to:
receive measurements relating to executions of the plural JIT compiled instances of the first code; and
select, in response to the call of the first code in the program, the JIT compiled instance of the first code from among the plural JIT compiled instances of the first code based on the measurements.

3. The non-transitory machine-readable storage medium of claim 2 , wherein the measurements are acquired at runtime of the program, and are acquired by measurement instructions invoked responsive to execution of a JIT compiled instance of the first code in response to the first code being called by the program.

4. The non-transitory machine-readable storage medium of claim 1 , wherein the program comprises a first instruction to indirectly call the first code by calling a first pointer entry in a data structure, and wherein the JIT control instructions upon execution cause the system to:
add, at runtime of the program under control of the JIT control instructions, a first pointer for the first code to the first pointer entry, wherein the first pointer refers to a location at which a first JIT compiled instance of the first code is stored.

5. The non-transitory machine-readable storage medium of claim 2 , wherein the selecting based on the measurements comprises selecting the JIT compiled instance of the first code from among the plural JIT compiled instances of the first code based on a determination of which of the plural JIT compiled instances of the first code provides better performance according to the measurements.

6. The non-transitory machine-readable storage medium of claim 4 , wherein the program comprises a second instruction, different from the first instruction, to indirectly call the first code by calling a second pointer entry in the data structure, and wherein the JIT control instructions upon execution cause the system to:
add, at the runtime of the program under control of the JIT control instructions, a second pointer for the first code to the second pointer entry, wherein the second pointer refers to a location at which a second JIT compiled instance of the first code is stored, the second JIT compiled instance of the first code being different from the first JIT compiled instance of the first code.

7. The non-transitory machine-readable storage medium of claim 5 , wherein the measurements indicate how long each JIT compiled instance of the plural JIT compiled instances took to execute, or a size of each JIT compiled instance of the plural JIT compiled instances.

8. The non-transitory machine-readable storage medium of claim 7 , wherein the measurements further indicate how many times each JIT compiled instance of the plural JIT compiled instances was called.

9. The non-transitory machine-readable storage medium of claim 1 , wherein the program is without any instruction related to the JIT compilation of the first code.

10. The non-transitory machine-readable storage medium of claim 1 , wherein an execution of the program is not blocked for measurement of an execution of a JIT compiled instance of the first code or for patching a pointer for a JIT compiled instance of the first code responsive to the call of the first code in the program.

11. The non-transitory machine-readable storage medium of claim 1 , wherein the plurality of instances of the JIT compilation of the first code are useable by multiple instances of the program.

12. The non-transitory machine-readable storage medium of claim 1 , wherein the first code has an input variable, and wherein initiating the plurality of instances of the JIT compilation of the first code comprises:
initiating multiple instances of JIT compilation of the first code where the input variable satisfies a logical predicate.

13. The non-transitory machine-readable storage medium of claim 1 , wherein the JIT control instructions upon execution cause the system to:
select, for the call of the first code in the program, the JIT compiled instance of the first code from among the plural JIT compiled instances of the first code based on which location of a plurality of locations the first code is to execute at in response to the call.

14. The non-transitory machine-readable storage medium of claim 1 , wherein the JIT control instructions upon execution cause the system to:
select, for the call of the first code in the program, the JIT compiled instance of the first code from among the plural JIT compiled instances of the first code based on a status of a processor that is to execute the first code in response to the call.

15. The non-transitory machine-readable storage medium of claim 1 , wherein the JIT control instructions upon execution cause the system to:
select, for the call of the first code in the program, the JIT compiled instance of the first code from among the plural JIT compiled instances of the first code based on a physical layout of physical resources of a computer system in which the program is executed.

16. A system comprising:
a processor; and
a non-transitory storage medium storing just-in-time (JIT) control instructions separate from a program that is to call a function a plurality of times, the JIT control instructions executable on the processor to:
for a first call of the function by the program:
select a first JIT compiled instance of the function compiled by a compiler using a first compilation setting, and cause execution of the first JIT compiled instance of the function that is stored in a data repository storing a plurality of JIT compiled instances of the function; and

for a second call of the function by the program:
select a second JIT compiled instance of the function compiled by the compiler using a second compilation setting that is different from the first compilation setting, and cause execution of the second JIT compiled instance of the function that is stored in the data repository.

17. The system of claim 16 , wherein the JIT control instructions are executable on the processor to:
for the first call of the function, patch a first pointer to a first pointer entry of a patch pointer data structure, the first pointer referring to a storage location of the first JIT compiled instance of the function; and
for the second call of the function, patch a second pointer to the first pointer entry of the patch pointer data structure, the second pointer referring to a storage location of the second JIT compiled instance of the function.

Assignees

• Hewlett Packard Entpr Dev Lp

Inventors

• Keen Benjamin
• Mendygral Peter J
• Eilertson Eric Edward
• Lee Kent D

Classifications

• G06F8/4441

  Reducing the execution time required by the program code · CPC title

• G06F9/449 Primary

  Object-oriented method invocation or resolution · CPC title

• G06F8/434

  Pointers; Aliasing · CPC title

• G06F9/4552 Primary

  Involving translation to a different instruction set architecture, e.g. just-in-time translation in a JVM · CPC title

• G06F11/3616

  using software metrics · CPC title