JP2000047879A - Method and device for compilation, executing method, and program executing device - Google Patents

Abstract

PROBLEM TO BE SOLVED: To suppress an increase in code size in a code versioning optimization process by generating a code for a part of a program in a 1st execution state and profile information used in case of transition to a 2nd execution state and generating a code for activating a code generating process in case of the transition to the 2nd execution state. SOLUTION: At the compilation, parts of the program which can be classified into at least the 1st and 2nd execution states are selected under given conditions. A check code for the classification of the execution states generated and a code for the part of the program in the 1st execution state is generated. The profile information used in case of the transition to the 2nd execution state is generated. A code for activating the code generating process needed in case of the transition to the 2nd execution state is generated. Then the profile information, etc., are further put together by using the address where the code for activation is generated as an identification number to generate a table.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a compiler, and more particularly, to a Java (trademark of Sun Microsystems) just-in-time compiler.
e: JIT) or the like, generates an executable code (executable code) for the first execution state of at least a portion of the program that can be classified into the first and second execution states, and executes the executable code for the second execution state. As needed.

[0002]

2. Description of the Related Art In a conventional JIT compiler, a unit to be compiled is a method to be executed. Therefore, even if there are paths (partial programs) that are hardly executed in the method, they are all compiled and code is generated. When such code generation is performed, there are disadvantages that the code size increases and the compile time increases.

[0003]

SUMMARY OF THE INVENTION An object of the present invention is to provide a code versioning optimizing process (at the time of compiling, classifying a state in which the code is executed with respect to a partial program in a method, and classifying the state into several states. The process of generating a check code for classification and an execution code for each state.) Suppresses an increase in code size, and a hotspot (a process that takes an execution time that is repeated many times here) That is, dynamically compiling a portion at which the optimization level is raised for a portion that can be determined as.

Another object of the present invention is to reduce the size of an execution code by not generating a code having a lower execution frequency by versioning until the code is actually required. Furthermore, by dynamically detecting code that becomes a hot spot and performing a more effective optimization process that takes time only when such a condition occurs, the compile time of code other than the hot spot is reduced. It is to be able to hold down.

[0005]

SUMMARY OF THE INVENTION The present invention relates to a method for compiling a partial program included in a method being compiled, not when the code is actually being compiled but when the code is actually needed. (Delayed compilation) to generate code. This makes it possible to suppress an increase in the code size in the code versioning optimizing process and dynamically execute a compilation with an increased optimization level for a portion that can be determined to be a hot spot. Note that the versioning optimization processing targeted by the present invention includes loop versioning and virtual call versioning.

The necessary processing will be summarized below. At the time of compiling, a selecting step of selecting at least a part of the program that can be classified into the first and second execution states according to a predetermined condition; a step of generating a check code for classification of the execution state; Generating code for a portion of the program in an executing state;
Generating the profile information to be used in the case of transition to the second execution state, and generating the code for starting the process of generating the code required in the case of transition to the second execution state. .

[0007] The above predetermined condition may be such that the possibility of being executed in the first execution state is greater than the possibility of being executed in the second execution state. By doing so, the frequency of performing the delayed compilation is reduced, and the compilation + execution time is shortened. This predetermined condition may be, for example, when the part of the program is a loop process and includes an array access, or when the part of the program is a recursive method that is virtually called, or when the part of the program is a method execution. If a virtual call using a dis object, which is an object used for, is included, or if a part of the program is a loop processing capable of performing optimization processing in a plurality of stages, or a part of the program, There may be a case where array access by a constant index is included.

In some cases, the selection step includes a step of generating information for specifying a part of the program. For example, it is specified by the upper end address and the lower end address of the program portion. Then, it may be stored together with a code for starting a process for generating a code required when the state transits to the second execution state.

Further, it is conceivable that the profile information includes a code condition required when the state transits to the second execution state. For example, data indicating what processing is being performed by the program part,
For hotspots, specify the degree of optimization.

[0010] In some cases, the method further includes a step of generating information for linking a code necessary for transitioning to the second execution state to another code. Information for linking may not be required depending on the execution environment.

[0011] When the code and information as described above have been generated, but the check code requires the program part to be executed in the second execution state, the second execution state is determined using the profile information. Performing the steps of generating the code that needs to be executed at, linking the generated code to other codes, and executing the generated code. When such processing is performed, the processing time becomes longer. However, if the “predetermined conditions” as described above are appropriately set, there is a high possibility that the processing need not be performed.

Setting a process of generating a code that needs to be executed in the second execution state by using the profile information so that the process is executed by a single thread at a time; May be further included.
Locks are required for multi-threading.

Although the present invention has been described as a processing flow, the present invention can be embodied as an apparatus for executing the processing of the present invention or as a program. When the program is executed, the program is stored in a storage medium such as a floppy disk, a CD-ROM, or a hard disk.

[0014]

DESCRIPTION OF THE PREFERRED EMBODIMENTS The processing required for the present invention will be described below in order.

A. Compile Processing (1) When compiling a method using a JIT compiler or a normal compiler, select a partial program that generates code by delayed compilation. In practicing the present invention, there is no restriction on the determination itself of the partial program to be subjected to delayed compilation. However, from the viewpoint of effectiveness and effect, it is important that the portion is a candidate for a hot spot or a portion that can be guaranteed that the frequency of execution by versioning or the like is extremely low.

More specifically, the following cases can be considered. Versioning will be described first. Versioning divides, at compile time, the state in which the code is executed for a partial program in a method into several states, and generates check code for classifying the state and execution code for each state. Processing. Tables 1 and 2 show examples described in Java. In Table 1, there is one loop repeated by the loop variable i. In Java, when accessing an array, it is required to perform a test of whether an array variable itself is NULL and a check of whether an array index falls within the range of the array at the time of execution. For this loop, if the array variable a is not null and the change range of the loop variable i falls within the range of the array a, it is classified into two cases, one that fits and the other that does not fit, and a check code Table 2 shows the generated code. By this versioning, the code for the case where the array variable is not null and the loop variable i falls within the range of the array (then-side code) can be removed because the test in array access is obvious to always succeed. On the other hand, in the code for the case where the array variable a is null or the loop variable i may access outside the range of the array (else side code), for the array access of a [i], a is null There is a possibility that the loop variable i may access outside the range of the array.

[Table 1]

[Table 2] public void f (int a [], int n) {int i; if (a! = Null && n <= a.length) {// Check if i is within the range of array a // If i accesses only the range of array a for (i = 0; i <n; i ++) {a [i] = a [i] * i; // null test and range test of a [i] are Unnecessary}} else {// If i accesses outside the range of array a for (i = 0; i <n; i ++) {// check (a! = Null); // check (i > = 0); // check (i <a.length); a [i] = a [i] * i; // requires null and range tests for a [i]}}}

A. Versioning for Loop Array Check In a language such as Java that has an array range check as a language specification, a program can be written at runtime using these range checks. For example, to describe the initialization processing of the array as shown in Table 3, it is possible to write such that each element of the array is initialized in an infinite loop, and the processing is terminated when the array exceeds the range of the array. However, such a description is a special case in many general programs, and is described in many programs as changing a loop variable within an array range and initializing as shown in Table 4. In such a situation, for example, if the array access range is checked using the change range of the loop variable by the loop versioning optimization process, and the version is checked into a loop that checks the range of the array and a loop that does not check, in many cases, A loop without range checking will be executed. Therefore, by generating the code to be checked using the present invention after it is executed, the code generated first becomes one unchecked loop, so that the code increase by versioning optimization is performed. Can be eliminated.

[Table 3]

[Table 4]

As described above, in this example, a change code of the loop variable is calculated to generate a check code for checking whether each array access falls within the array range. Create a loop that does not generate test code for array access and a loop that generates test code for each array access that does not fit (ii). Of these, the code in (b) is the subject of delayed compilation according to the present invention. That is, the code in (b) is not initially generated.

The partial programs shown in Table 5 are versioned as shown in Table 6.

[Table 5]

[Table 6] if (a! = NULL && b! = NULL && S> = 0 && E <a.length && E <b.length) {/ * Version when all array accesses are within the array range * / for (i = S; i <E; i ++) {a [i] = a [i] + b [i]; / * a [i] and b [i] do not perform array range check * /}} else {/ * Version when array access may be out of array range * / for (i = S; i <E; i ++) {a [i] = a [i] + b [i]; / * a [i] and b [i] perform array range check * /}} The part after else is delayed compiled.

B. Versioning of Recursive Calls of Virtual Methods For example, in the code shown in Table 7, call (1) looks like a recursive call at first glance. However, if the original call is a super call from a method in a derived class, for example, call (2) in Table 8, the call (1) executes the method r of class b. And call (1) is not a self-recursive call. However, in most cases, programs written in a recursive call form are self-recursive. Therefore, the code after else in Table 9 is a code generated later by the delayed compilation.

[Table 7]

[Table 8]

[Table 9] class a {public void r (int r) {if (this.r == method r of class a) {// Version in case of self-recursive method ..... // Optimal for self-recursive } Else {// version without self-recursive method if (i == 0) return 0; else return i + r (i-1);}}}

In this way, for a recursive method that is virtually called, a check code is generated to check whether or not a call to a method of the same name by an object used for the call is a recursive call to itself. B) Generate tail recursion optimization for recursive calls and one-stage unrolling of recursive calls, and (b) generate unmodified codes for non-recursive calls. Of these, the code in (b) is subjected to delayed compilation by the method of the present invention. That is, the code in (b) is not initially generated.

The one-stage unrolling of the recursive call is to inline the code of the recursive call method in the recursive call in the recursive call method. Tables 10 and 11 show examples described by Java. Table 10 shows the original recursive call method. Table 11 shows the result of one-stage unrolling.

[Table 10]

[Table 11]

C. Versioning Virtual Calls Using This (this) Object The "this" object here refers to the object used to execute the method. In object-oriented languages,
When executing a virtual call, always specify an object, and this will be this object.

Here, for a virtual call using this object, a check code for checking whether this is an instance of the class to which the method being compiled belongs is generated, and (a) the virtual call by this object is compiled. Sometimes solved (reso
lve: Generates code inlined by the resolved method and (b) the code that leaves the virtual call by this object as it is. Of these, the code in (b) is the subject of delayed compilation according to the present invention. That is, the code in (b) is not generated first.

An example of versioning the entire method code in response to a virtual method call using this object included in a virtual method depending on whether the class of this object belongs to the class to which the method being compiled belongs is shown below. . The advantage of this versioning process is that, for a version of code that can specify the class of this at compile time by versioning, the method actually executed by the virtual call by this can also be specified. In other words, optimization such as inlining can be performed on these methods. Tables 12 and 13 show examples described in Java. Consider method f in Table 12. Method f
Inside, a virtual call g by this object
Exists. Since the final attribute is not set for class a itself, a derived class may be defined. For this method f, versioning processing is performed by checking whether the object of this when f is executed is an instance of the class a to which the method f belongs. Thus, when this is an instance of the class a, the method invocation g can be uniquely specified as g in the class a, so that g can be inline-processed as in the then-side code in Table 13. On the other hand, if this is not an instance of the class a itself, the original code is generated.

[0026]

[Table 12]

[Table 13] class a {public void f () {if (this class == a) {// If the class of this object is a int x; x = 1 + 2; // Method g must be class a Return x;} else {// If the class of this object is not a int x; x = g (1, 2); // Actually executed by calling method g Return x;}} public int g (i, j) {return i + j;}}

D. Versioning for Optimizing Hot Spots For example, a loop shown in Table 14 is subjected to versioning processing based on the number of repetitions of the loop, to obtain a code as shown in Table 15. Of these, the code underlined in italics has the default value of "hotspot_thres
hold_number "or more, the code will be executed when the reduction in the execution time by the code generated by the maximum optimization is greater than the compile time by performing the maximum optimization. .

[Table 14]

[Table 15] if (n <hotspot_threshold_number) {// Execute only optimization that does not take much time for (i = 0; i <n; i ++) {dy [iy + dy_off] + = da * dx [ix + dx_off ]; ix + = incx; iy + = incy;}} else {// Perform maximal optimization for the next loop for (i = 0; i <n; i ++) {dy [iy + dy_off ] + = da * dx [ix + dx_off]; ix + = incx; iy + = incy;}}

As described above, the change range of the loop variable is calculated, a check code for comparison with a preset set value is generated, and (a) a loop in which only the optimization process that does not take much time is performed And (2) generate a code for a loop that has been subjected to (b) a more time-consuming and more effective optimization process. Of these, the code in (b) is the subject of delayed compilation according to the present invention. That is, the code in (b) is not generated first. Further, the code (a) can be combined with the processing of the above a.

E. Versioning for Constant Indexing of Arrays A frequently used method in numerical calculation algorithms is to use a specific region of an array given in advance as a constant matrix in a method for a coefficient matrix or the like. For example, by performing versioning processing on the loop shown in Table 16 depending on whether the variable k is included in the change range of the loop variable i, a code as shown in Table 17 is obtained. Of these, it is known that the code after the else always has different elements of a [i] and a [k], so it is possible to generate a code for caching the value of a [k] outside the loop.

[Table 16]

[Table 17]

As described above, a check code for testing whether or not the value of an invariant variable is included in another array access range is generated. A code that has been subjected to the optimization processing as having no relation and a code that has been subjected to the optimization processing assuming that (b) there is a dependency relationship with the array access when it is included are generated.
Of these, the code in (b) is the subject of delayed compilation according to the present invention. That is, the code in (b) is not generated first.

Under the above conditions, a partial program is selected. As described in the above description of the processing, it is necessary to generate the check code of the classification required in versioning and the code (a) of the partial program.

(2) Generate program information of a partial source code. The program information of the partial program to be subjected to the delayed compilation is generated at a location that can be obtained at the time of the delayed compilation.

In this example, as the program information of the partial program, the original Java bytecode information is left as it is, and the position on the bytecode is generated as the values of the upper and lower ends of the partial program.
The address at which the code for activating the delayed compile processing generated in the following (5) is generated as the identification number in the information at the upper and lower ends, and the profile information generated in (3) and the profile information generated in (4) are further generated. A table as shown in FIG. 1 is created by putting together all the parts to be deferred compiled in the method together with the link information to be obtained and placed so that it can be obtained from the method block currently being compiled (link information is not required in the Java execution environment). (Not shown). It is assumed that the method block mb itself can be obtained from the execution code address. The method block is a structure having information unique to each method used in the Java execution environment.

(3) Generate profile information to be used when delay compiling the partial program. This profile information is a value representing the attribute of the partial program, and is used as additional information when performing delayed compilation. In the case where the conditions of the selected partial program are a to e described above, information on which one of them is included. This is generated in a location (for example, FIG. 1) that can be obtained at the time of executing the delayed compilation. In the case of versioning using a hot spot, the degree of optimization is also included.

(4) Generate information for linking a partial program with a code of another part. Information necessary for linking a program, such as information on a method such as a stack address, is generated at a location where it can be obtained at the time of executing delayed compilation. It can be included in the table of FIG.

However, in the Java execution environment, only the link source address is required for the link.
Since that information can be obtained from the stack in the delayed compilation process, nothing is generated as link information.

(5) When the execution shifts to the code corresponding to the execution state of the partial program that has not been generated, the code for starting the delayed compilation processing is generated.
A pre-processing code, a code for activating a delayed compilation process described below, and a post-processing code are generated at a position where the partial program to be delayed compiled is originally generated.

As the pre-processing code, a process for writing a local variable and a stack value cached in a register to a memory as necessary is generated. The startup code is to push the value of the program counter onto the stack (PU
SH) and jump to the activation code routine (jm
p) Generate instructions. The post-processing code generates a process of caching a local variable and a stack value in a register as needed.

The above is the processing required at the time of compiling.

B. Processing when delayed compilation processing is started (1) Processing to prevent the delayed compilation processing from being repeatedly executed by a plurality of execution contexts. In situations such as in a multi-threaded environment where there is a possibility that multiple execution contexts, such as multiple threads, may simultaneously perform deferred compilation, only one of those contexts will be delayed when such a situation occurs. The compiling process is executed, and the other contexts use a lock mechanism or the like to perform a process for waiting for the completion. This process is not necessary in an environment where a plurality of execution contexts do not operate.

(2) The JIT compiler is activated and compiled using the program information and profile information of the partial program. Obtains program information and profile information, and invokes the JIT compiler using that information to generate executable code.

(3) The code generated using the link information is linked to the generated code. A process for replacing the generated code with a call code for the delayed compilation process is performed.

(4) If other execution contexts are waiting for the end of the delayed compilation in the processing for preventing the delayed compilation processing from being repeatedly executed, the processing is executed so that the generated code is executed for them. . If other contexts are in a waiting state by the process (1), the process is performed so that the codes generated sequentially for those contexts are executed. This process is not necessary in an environment where a plurality of execution contexts do not operate.

(5) Execution of the generated code is started.

Table 18 shows codes for handling the delayed compilation processing code as a common processing routine. (1.1) acquires a global lock to simplify the implementation. With this lock, only the thread that can acquire the lock performs subsequent processing. Note that the use of the global lock also affects threads for different delayed compilations. However, in this example, it is considered that there is no problem in execution because a thread whose delay compilation frequency is low is originally used. In (1.2), the instruction at the address where the JUMP instruction to the original delayed compilation processing routine was found is examined. If the compilation has already been performed by another thread, since it has been rewritten to the JUMP instruction to the compiled code by the process (3), this is a check to skip the subsequent compilation process.
(2.1) is a process of acquiring program information and profile information. (2.2) is a process of compiling the code by starting the JIT compiler. (3) is a process for rewriting a JUMP instruction to the original delayed compilation processing routine to a JUMP instruction to the compiled code. By this processing, when this address is subsequently executed, the compiled code is executed instead of the delayed compilation processing. In (4), the lock is released. As a result, the threads that have been waiting with the lock of (1.1) are executed in order. As mentioned earlier, these threads skip the compilation process according to the check in (1.2). (5) is processing for jumping to the address of op_addr in order to execute the compiled code.

[0046]

[Table 18] LOCK_IN (); // (1.1) Code for locking op_addr = Obtain the address where the delayed compilation processing routine was called from the stack. if (* op_addr == JUMP instruction to delay compilation routine) // (1.2) Code to check whether code has been generated {Obtain mb from op_addr Get delayed compilation information table from mb. // (2.1) Get source program information and profile information. Compile the partial program by JIT. // (2.2) Compile by JIT. // The return address is the position calculated from op_addr. Rewrite the op_addr instruction to a JUMP instruction for the start address of the generated code. // (3) Link the generated code to the original code. } LOCK_OUT (); // (4) Unlocking process Jump to op_addr. // (5) Execute the code of the partial program by jumping to op_addr.

[0047]

[Effect] An increase in code size can be suppressed in the code versioning optimization processing.

It was also possible to dynamically compile a part which can be determined as a hot spot with an increased optimization level.

Further, the code of the less frequently executed code is not generated by versioning until the code is actually required, so that the size of the executed code can be reduced.

Further, by dynamically detecting a code that becomes a hot spot and performing a more effective optimization process that takes time only when such a condition occurs, the code other than the hot spot is compiled. The time can be kept small.

[Brief description of the drawings]

FIG. 1 is an example of a table used in an embodiment of the present invention.

[Explanation of symbols] None

 ──────────────────────────────────────────────────の Continuing from the front page (72) Inventor Toshiaki Yasue 1623-14 Shimotsuruma, Yamato-shi, Kanagawa Japan IBM Japan, Ltd.Tokyo Basic Research Laboratory (72) Inventor Hideaki Komatsu Shimotsuruma, Yamato-shi, Kanagawa 1623-14 F-term (reference) 5B081 AA09 CC21, Tokyo Research Laboratory, IBM Japan, Ltd.

Claims (12)

[Claims] A step of selecting at least a part of a program that can be classified into a first and a second execution state according to a predetermined condition; and a step of generating a check code for classifying the execution state. A step of generating a code for the portion of the program in the first execution state; a step of generating profile information to be used when transitioning to the second execution state; and a step of transitioning to the second execution state. Generating code for initiating a process of generating required code. 2. The compilation according to claim 1, wherein the predetermined condition is that the possibility of being executed in the first execution state is greater than the possibility of being executed in the second execution state. Method. 3. The program according to claim 1, wherein the predetermined condition is that the part of the program is a loop process and includes an array access, or that the part of the program is a recursive method that is virtually called, or If the part includes a virtual call using a dis object that is an object used for method execution, or if the part of the program is a loop processing that can perform optimization processing in multiple stages, 2. The compiling method according to claim 1, further comprising: when the part of the program includes an array access by a constant index. 4. The compiling method according to claim 1, wherein said selecting step includes a step of generating information for specifying a part of said program. 5. The compiling method according to claim 1, wherein the profile information includes a code condition required when the state changes to the second execution state. 6. The compiling method according to claim 1, further comprising the step of generating information for linking a code required when the transition to the second execution state is made to another code. 7. A program which is used when at least a part of a program that can be classified into the first and second execution states is transited to the second execution state without generating necessary code in the second execution state. A method for executing a portion of the program in the second execution state when generating profile information, the method including: using the profile information to generate a code that needs to be executed in the second execution state. Linking the generated code to another code; and executing the generated code. 8. A step of setting a process for generating a code that needs to be executed in the second execution state using the profile information so that the process is executed by a single thread at a time, and the linking step. 8. The execution method according to claim 7, further comprising a step of releasing the setting later. 9. A means for selecting at least a portion of a program that can be classified into first and second execution states according to a predetermined condition; a means for generating a check code for classifying the execution states; Means for generating a code for the portion of the program in the first execution state; means for generating profile information used when transitioning to the second execution state; and when transitioning to the second execution state. Means for generating code for initiating a process for generating necessary code. 10. The compiling device according to claim 9, wherein said selecting means executes a process of generating information for specifying a portion of said program. 11. A program which is used when at least a portion of a program that can be classified into the first and second execution states transitions to the second execution state without generating necessary code in the second execution state. A program execution device that executes a part of the program in the second execution state when the profile information is generated, and generates a code that needs to be executed in the second execution state using the profile information. A program execution device, comprising: a compiler; means for linking generated code to another code; and means for starting execution of the generated code. 12. A storage medium storing a compiler, the compiler causing a computer to select at least a portion of a program that can be classified into a first and a second execution state according to a predetermined condition; Generating a check code for classifying an execution state; generating code for a portion of the program in the first execution state; and using profile information used when the state transits to the second execution state. Generating a code for activating a process of generating a code required when the state transitions to the second execution state.